76 files changed, 16812 insertions, 16591 deletions

diff --git a/src/fs/fs.h b/src/fs/fs.h
index 294a433fc..4c433e774 100644
--- a/src/fs/fs.h
+++ b/src/fs/fs.h
@@ -50,7 +50,8 @@
 /**
  * @brief content hash key
  */
-struct ContentHashKey {
+struct ContentHashKey
+{
   /**
    * Hash of the original content, used for encryption.
    */
@@ -70,7 +71,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * Message sent from a GNUnet (fs) publishing activity to sign
  * a LOC URI.
  */
-struct RequestLocSignatureMessage {
+struct RequestLocSignatureMessage
+{
   /**
    * Message type will be #GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN.
    */
@@ -102,7 +104,8 @@ struct RequestLocSignatureMessage {
 /**
  * Message sent from the service with the signed LOC URI.
  */
-struct ResponseLocSignatureMessage {
+struct ResponseLocSignatureMessage
+{
   /**
    * Message type will be
    * #GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE.
@@ -145,7 +148,8 @@ struct ResponseLocSignatureMessage {
  * computing it; this is an optimization that should be safe given
  * that the client is not our adversary).
  */
-struct IndexStartMessage {
+struct IndexStartMessage
+{
   /**
    * Message type will be #GNUNET_MESSAGE_TYPE_FS_INDEX_START.
    */
@@ -188,7 +192,8 @@ struct IndexStartMessage {
  * Message send by FS service in response to a request
  * asking for a list of all indexed files.
  */
-struct IndexInfoMessage {
+struct IndexInfoMessage
+{
   /**
    * Message type will be
    * #GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY.
@@ -218,7 +223,8 @@ struct IndexInfoMessage {
  * files and response with a confirmation message (even if the file
  * was already not on the list).
  */
-struct UnindexMessage {
+struct UnindexMessage
+{
   /**
    * Message type will be #GNUNET_MESSAGE_TYPE_FS_UNINDEX.
    */
@@ -259,7 +265,8 @@ struct UnindexMessage {
  * Message sent from a GNUnet (fs) search activity to the
  * gnunet-service-fs to start a search.
  */
-struct SearchMessage {
+struct SearchMessage
+{
   /**
    * Message type will be #GNUNET_MESSAGE_TYPE_FS_START_SEARCH.
    */
@@ -318,7 +325,8 @@ struct SearchMessage {
  * single response are considered done.  This message is transmitted
  * between peers.
  */
-struct PutMessage {
+struct PutMessage
+{
   /**
    * Message type will be #GNUNET_MESSAGE_TYPE_FS_PUT.
    */
@@ -343,7 +351,8 @@ struct PutMessage {
  * single response are considered done.  This message is transmitted
  * between the service and a client.
  */
-struct ClientPutMessage {
+struct ClientPutMessage
+{
   /**
    * Message type will be #GNUNET_MESSAGE_TYPE_FS_PUT.
    */
diff --git a/src/fs/fs_api.c b/src/fs/fs_api.c
index 45051ddcb..e04a93f9c 100644
--- a/src/fs/fs_api.c
+++ b/src/fs/fs_api.c
@@ -47,23 +47,23 @@
  * @param qe job to start
  */
 static void
-start_job(struct GNUNET_FS_QueueEntry *qe)
+start_job (struct GNUNET_FS_QueueEntry *qe)
 {
   qe->active = GNUNET_YES;
-  qe->start(qe->cls);
+  qe->start (qe->cls);
   qe->start_times++;
   qe->h->active_blocks += qe->blocks;
   qe->h->active_downloads++;
-  qe->start_time = GNUNET_TIME_absolute_get();
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Starting job %p (%u active)\n",
-             qe,
-             qe->h->active_downloads);
-  GNUNET_CONTAINER_DLL_remove(qe->h->pending_head, qe->h->pending_tail, qe);
-  GNUNET_CONTAINER_DLL_insert_after(qe->h->running_head,
-                                    qe->h->running_tail,
-                                    qe->h->running_tail,
-                                    qe);
+  qe->start_time = GNUNET_TIME_absolute_get ();
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting job %p (%u active)\n",
+              qe,
+              qe->h->active_downloads);
+  GNUNET_CONTAINER_DLL_remove (qe->h->pending_head, qe->h->pending_tail, qe);
+  GNUNET_CONTAINER_DLL_insert_after (qe->h->running_head,
+                                     qe->h->running_tail,
+                                     qe->h->running_tail,
+                                     qe);
 }
 
 
@@ -74,25 +74,25 @@ start_job(struct GNUNET_FS_QueueEntry *qe)
  * @param qe job to stop
  */
 static void
-stop_job(struct GNUNET_FS_QueueEntry *qe)
+stop_job (struct GNUNET_FS_QueueEntry *qe)
 {
   qe->active = GNUNET_NO;
-  qe->stop(qe->cls);
-  GNUNET_assert(0 < qe->h->active_downloads);
+  qe->stop (qe->cls);
+  GNUNET_assert (0 < qe->h->active_downloads);
   qe->h->active_downloads--;
   qe->h->active_blocks -= qe->blocks;
-  qe->run_time = GNUNET_TIME_relative_add(qe->run_time,
-                                          GNUNET_TIME_absolute_get_duration(
-                                            qe->start_time));
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Stopping job %p (%u active)\n",
-             qe,
-             qe->h->active_downloads);
-  GNUNET_CONTAINER_DLL_remove(qe->h->running_head, qe->h->running_tail, qe);
-  GNUNET_CONTAINER_DLL_insert_after(qe->h->pending_head,
-                                    qe->h->pending_tail,
-                                    qe->h->pending_tail,
-                                    qe);
+  qe->run_time = GNUNET_TIME_relative_add (qe->run_time,
+                                           GNUNET_TIME_absolute_get_duration (
+                                             qe->start_time));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Stopping job %p (%u active)\n",
+              qe,
+              qe->h->active_downloads);
+  GNUNET_CONTAINER_DLL_remove (qe->h->running_head, qe->h->running_tail, qe);
+  GNUNET_CONTAINER_DLL_insert_after (qe->h->pending_head,
+                                     qe->h->pending_tail,
+                                     qe->h->pending_tail,
+                                     qe);
 }
 
 
@@ -103,7 +103,7 @@ stop_job(struct GNUNET_FS_QueueEntry *qe)
  * @param cls the `struct GNUNET_FS_Handle *`
  */
 static void
-process_job_queue(void *cls)
+process_job_queue (void *cls)
 {
   struct GNUNET_FS_Handle *h = cls;
   struct GNUNET_FS_QueueEntry *qe;
@@ -131,22 +131,22 @@ process_job_queue(void *cls)
   num_probes_waiting = 0;
   num_downloads_waiting = 0;
   for (qe = h->pending_head; NULL != qe; qe = qe->next)
+  {
+    switch (qe->priority)
     {
-      switch (qe->priority)
-        {
-        case GNUNET_FS_QUEUE_PRIORITY_PROBE:
-          num_probes_waiting++;
-          break;
+    case GNUNET_FS_QUEUE_PRIORITY_PROBE:
+      num_probes_waiting++;
+      break;
 
-        case GNUNET_FS_QUEUE_PRIORITY_NORMAL:
-          num_downloads_waiting++;
-          break;
+    case GNUNET_FS_QUEUE_PRIORITY_NORMAL:
+      num_downloads_waiting++;
+      break;
 
-        default:
-          GNUNET_break(0);
-          break;
-        }
+    default:
+      GNUNET_break (0);
+      break;
     }
+  }
   /* now, calculate some basic statistics on running jobs */
   num_probes_active = 0;
   num_probes_expired = 0;
@@ -154,165 +154,165 @@ process_job_queue(void *cls)
   num_downloads_expired = 0;
   next = h->running_head;
   while (NULL != (qe = next))
-    {
-      next = qe->next;
-      switch (qe->priority)
-        {
-        case GNUNET_FS_QUEUE_PRIORITY_PROBE:
-          run_time = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2);
-          end_time = GNUNET_TIME_absolute_add(qe->start_time, run_time);
-          rst = GNUNET_TIME_absolute_get_remaining(end_time);
-          if (0 == rst.rel_value_us)
-            {
-              num_probes_expired++;
-              stop_job(qe);
-            }
-          else
-            {
-              num_probes_active++;
-              restart_at = GNUNET_TIME_relative_min(rst, restart_at);
-            }
-          break;
-
-        case GNUNET_FS_QUEUE_PRIORITY_NORMAL:
-          run_time =
-            GNUNET_TIME_relative_saturating_multiply(h->avg_block_latency,
-                                                     qe->blocks * qe->start_times);
-          end_time = GNUNET_TIME_absolute_add(qe->start_time, run_time);
-          rst = GNUNET_TIME_absolute_get_remaining(end_time);
-          if (0 == rst.rel_value_us)
-            {
-              num_downloads_expired++;
-              stop_job(qe);
-            }
-          else
-            {
-              num_downloads_active++;
-              restart_at = GNUNET_TIME_relative_min(rst, restart_at);
-            }
-          break;
-
-        default:
-          GNUNET_break(0);
-          break;
-        }
+  {
+    next = qe->next;
+    switch (qe->priority)
+    {
+    case GNUNET_FS_QUEUE_PRIORITY_PROBE:
+      run_time = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2);
+      end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
+      rst = GNUNET_TIME_absolute_get_remaining (end_time);
+      if (0 == rst.rel_value_us)
+      {
+        num_probes_expired++;
+        stop_job (qe);
+      }
+      else
+      {
+        num_probes_active++;
+        restart_at = GNUNET_TIME_relative_min (rst, restart_at);
+      }
+      break;
+
+    case GNUNET_FS_QUEUE_PRIORITY_NORMAL:
+      run_time =
+        GNUNET_TIME_relative_saturating_multiply (h->avg_block_latency,
+                                                  qe->blocks * qe->start_times);
+      end_time = GNUNET_TIME_absolute_add (qe->start_time, run_time);
+      rst = GNUNET_TIME_absolute_get_remaining (end_time);
+      if (0 == rst.rel_value_us)
+      {
+        num_downloads_expired++;
+        stop_job (qe);
+      }
+      else
+      {
+        num_downloads_active++;
+        restart_at = GNUNET_TIME_relative_min (rst, restart_at);
+      }
+      break;
+
+    default:
+      GNUNET_break (0);
+      break;
     }
-  GNUNET_break(h->active_downloads ==
-               num_downloads_active + num_probes_active);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "PA: %u, PE: %u, PW: %u; DA: %u, DE: %u, DW: %u\n",
-             num_probes_active,
-             num_probes_expired,
-             num_probes_waiting,
-             num_downloads_active,
-             num_downloads_expired,
-             num_downloads_waiting);
-  GNUNET_break(h->active_downloads + num_probes_active <=
-               h->max_parallel_downloads);
+  }
+  GNUNET_break (h->active_downloads ==
+                num_downloads_active + num_probes_active);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "PA: %u, PE: %u, PW: %u; DA: %u, DE: %u, DW: %u\n",
+              num_probes_active,
+              num_probes_expired,
+              num_probes_waiting,
+              num_downloads_active,
+              num_downloads_expired,
+              num_downloads_waiting);
+  GNUNET_break (h->active_downloads + num_probes_active <=
+                h->max_parallel_downloads);
   /* calculate start/stop decisions */
   if (h->active_downloads + num_downloads_waiting > h->max_parallel_downloads)
-    {
-      /* stop as many probes as there are downloads and probes */
-      num_probes_change = -GNUNET_MIN(num_probes_active, num_downloads_waiting);
-      /* start as many downloads as there are free slots, including those
-         we just opened up */
-      num_downloads_change =
-        h->max_parallel_downloads - h->active_downloads - num_probes_change;
-    }
+  {
+    /* stop as many probes as there are downloads and probes */
+    num_probes_change = -GNUNET_MIN (num_probes_active, num_downloads_waiting);
+    /* start as many downloads as there are free slots, including those
+       we just opened up */
+    num_downloads_change =
+      h->max_parallel_downloads - h->active_downloads - num_probes_change;
+  }
   else
-    {
-      /* start all downloads (we can) */
-      num_downloads_change = num_downloads_waiting;
-      /* also start probes if there is room, but use a lower cap of (mpd/4) + 1 */
-      if (1 + h->max_parallel_downloads / 4 >=
-          (h->active_downloads + num_downloads_change))
-        num_probes_change =
-          GNUNET_MIN(num_probes_waiting,
-                     (1 + h->max_parallel_downloads / 4) -
-                     (h->active_downloads + num_downloads_change));
-      else
-        num_probes_change = 0;
-    }
-  GNUNET_break(num_downloads_change <= num_downloads_waiting);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Changing %d probes and %d/%u/%u downloads\n",
-             num_probes_change,
-             num_downloads_change,
-             (unsigned int)h->active_downloads,
-             (unsigned int)h->max_parallel_downloads);
+  {
+    /* start all downloads (we can) */
+    num_downloads_change = num_downloads_waiting;
+    /* also start probes if there is room, but use a lower cap of (mpd/4) + 1 */
+    if (1 + h->max_parallel_downloads / 4 >=
+        (h->active_downloads + num_downloads_change))
+      num_probes_change =
+        GNUNET_MIN (num_probes_waiting,
+                    (1 + h->max_parallel_downloads / 4)
+                    - (h->active_downloads + num_downloads_change));
+    else
+      num_probes_change = 0;
+  }
+  GNUNET_break (num_downloads_change <= num_downloads_waiting);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Changing %d probes and %d/%u/%u downloads\n",
+              num_probes_change,
+              num_downloads_change,
+              (unsigned int) h->active_downloads,
+              (unsigned int) h->max_parallel_downloads);
   /* actually stop probes */
   next = h->running_head;
   while (NULL != (qe = next))
+  {
+    next = qe->next;
+    if (GNUNET_FS_QUEUE_PRIORITY_PROBE != qe->priority)
+      continue;
+    if (num_probes_change < 0)
     {
-      next = qe->next;
-      if (GNUNET_FS_QUEUE_PRIORITY_PROBE != qe->priority)
-        continue;
-      if (num_probes_change < 0)
-        {
-          stop_job(qe);
-          num_probes_change++;
-          if (0 == num_probes_change)
-            break;
-        }
+      stop_job (qe);
+      num_probes_change++;
+      if (0 == num_probes_change)
+        break;
     }
-  GNUNET_break(0 <= num_probes_change);
+  }
+  GNUNET_break (0 <= num_probes_change);
 
   /* start some more tasks if we now have empty slots */
   block_limit_hit = GNUNET_NO;
   next = h->pending_head;
   while ((NULL != (qe = next)) &&
          ((num_probes_change > 0) || (num_downloads_change > 0)))
-    {
-      next = qe->next;
-      switch (qe->priority)
-        {
-        case GNUNET_FS_QUEUE_PRIORITY_PROBE:
-          if (num_probes_change > 0)
-            {
-              start_job(qe);
-              num_probes_change--;
-              run_time = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2);
-              restart_at = GNUNET_TIME_relative_min(run_time, restart_at);
-            }
-          break;
-
-        case GNUNET_FS_QUEUE_PRIORITY_NORMAL:
-          if ((num_downloads_change > 0) &&
-              ((qe->blocks + h->active_blocks <= h->max_parallel_requests) ||
-               ((qe->blocks > h->max_parallel_requests) &&
-                (0 == h->active_downloads))))
-            {
-              start_job(qe);
-              num_downloads_change--;
-            }
-          else if (num_downloads_change > 0)
-            block_limit_hit = GNUNET_YES;
-          break;
-
-        default:
-          GNUNET_break(0);
-          break;
-        }
+  {
+    next = qe->next;
+    switch (qe->priority)
+    {
+    case GNUNET_FS_QUEUE_PRIORITY_PROBE:
+      if (num_probes_change > 0)
+      {
+        start_job (qe);
+        num_probes_change--;
+        run_time = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2);
+        restart_at = GNUNET_TIME_relative_min (run_time, restart_at);
+      }
+      break;
+
+    case GNUNET_FS_QUEUE_PRIORITY_NORMAL:
+      if ((num_downloads_change > 0) &&
+          ((qe->blocks + h->active_blocks <= h->max_parallel_requests) ||
+           ((qe->blocks > h->max_parallel_requests) &&
+            (0 == h->active_downloads))))
+      {
+        start_job (qe);
+        num_downloads_change--;
+      }
+      else if (num_downloads_change > 0)
+        block_limit_hit = GNUNET_YES;
+      break;
+
+    default:
+      GNUNET_break (0);
+      break;
     }
-  GNUNET_break((0 == num_downloads_change) || (GNUNET_YES == block_limit_hit));
-  GNUNET_break(0 == num_probes_change);
+  }
+  GNUNET_break ((0 == num_downloads_change) || (GNUNET_YES == block_limit_hit));
+  GNUNET_break (0 == num_probes_change);
 
-  GNUNET_log(
+  GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "AD: %u, MP: %u; %d probes and %d downloads to start, will run again in %s\n",
     h->active_downloads,
     h->max_parallel_requests,
     num_probes_change,
     num_downloads_change,
-    GNUNET_STRINGS_relative_time_to_string(restart_at, GNUNET_YES));
+    GNUNET_STRINGS_relative_time_to_string (restart_at, GNUNET_YES));
 
   /* make sure we run again, callbacks might have
      already re-scheduled the job, so cancel such
      an operation (if it exists) */
   if (NULL != h->queue_job)
-    GNUNET_SCHEDULER_cancel(h->queue_job);
+    GNUNET_SCHEDULER_cancel (h->queue_job);
   h->queue_job =
-    GNUNET_SCHEDULER_add_delayed(restart_at, &process_job_queue, h);
+    GNUNET_SCHEDULER_add_delayed (restart_at, &process_job_queue, h);
 }
 
 
@@ -328,31 +328,31 @@ process_job_queue(void *cls)
  * @return queue handle
  */
 struct GNUNET_FS_QueueEntry *
-GNUNET_FS_queue_(struct GNUNET_FS_Handle *h,
-                 GNUNET_SCHEDULER_TaskCallback start,
-                 GNUNET_SCHEDULER_TaskCallback stop,
-                 void *cls,
-                 unsigned int blocks,
-                 enum GNUNET_FS_QueuePriority priority)
+GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
+                  GNUNET_SCHEDULER_TaskCallback start,
+                  GNUNET_SCHEDULER_TaskCallback stop,
+                  void *cls,
+                  unsigned int blocks,
+                  enum GNUNET_FS_QueuePriority priority)
 {
   struct GNUNET_FS_QueueEntry *qe;
 
-  qe = GNUNET_new(struct GNUNET_FS_QueueEntry);
+  qe = GNUNET_new (struct GNUNET_FS_QueueEntry);
   qe->h = h;
   qe->start = start;
   qe->stop = stop;
   qe->cls = cls;
-  qe->queue_time = GNUNET_TIME_absolute_get();
+  qe->queue_time = GNUNET_TIME_absolute_get ();
   qe->blocks = blocks;
   qe->priority = priority;
-  GNUNET_CONTAINER_DLL_insert_after(h->pending_head,
-                                    h->pending_tail,
-                                    h->pending_tail,
-                                    qe);
+  GNUNET_CONTAINER_DLL_insert_after (h->pending_head,
+                                     h->pending_tail,
+                                     h->pending_tail,
+                                     qe);
   if (NULL != h->queue_job)
-    GNUNET_SCHEDULER_cancel(h->queue_job);
-  h->queue_job = GNUNET_SCHEDULER_add_now(&process_job_queue, h);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Queueing job %p\n", qe);
+    GNUNET_SCHEDULER_cancel (h->queue_job);
+  h->queue_job = GNUNET_SCHEDULER_add_now (&process_job_queue, h);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Queueing job %p\n", qe);
   return qe;
 }
 
@@ -363,19 +363,19 @@ GNUNET_FS_queue_(struct GNUNET_FS_Handle *h,
  * @param qe handle for the job
  */
 void
-GNUNET_FS_dequeue_(struct GNUNET_FS_QueueEntry *qe)
+GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qe)
 {
   struct GNUNET_FS_Handle *h;
 
   h = qe->h;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Dequeueing job %p\n", qe);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Dequeueing job %p\n", qe);
   if (GNUNET_YES == qe->active)
-    stop_job(qe);
-  GNUNET_CONTAINER_DLL_remove(h->pending_head, h->pending_tail, qe);
-  GNUNET_free(qe);
+    stop_job (qe);
+  GNUNET_CONTAINER_DLL_remove (h->pending_head, h->pending_tail, qe);
+  GNUNET_free (qe);
   if (NULL != h->queue_job)
-    GNUNET_SCHEDULER_cancel(h->queue_job);
-  h->queue_job = GNUNET_SCHEDULER_add_now(&process_job_queue, h);
+    GNUNET_SCHEDULER_cancel (h->queue_job);
+  h->queue_job = GNUNET_SCHEDULER_add_now (&process_job_queue, h);
 }
 
 
@@ -388,16 +388,16 @@ GNUNET_FS_dequeue_(struct GNUNET_FS_QueueEntry *qe)
  * @return fresh top-level activity handle
  */
 struct TopLevelActivity *
-GNUNET_FS_make_top(struct GNUNET_FS_Handle *h,
-                   SuspendSignalFunction ssf,
-                   void *ssf_cls)
+GNUNET_FS_make_top (struct GNUNET_FS_Handle *h,
+                    SuspendSignalFunction ssf,
+                    void *ssf_cls)
 {
   struct TopLevelActivity *ret;
 
-  ret = GNUNET_new(struct TopLevelActivity);
+  ret = GNUNET_new (struct TopLevelActivity);
   ret->ssf = ssf;
   ret->ssf_cls = ssf_cls;
-  GNUNET_CONTAINER_DLL_insert(h->top_head, h->top_tail, ret);
+  GNUNET_CONTAINER_DLL_insert (h->top_head, h->top_tail, ret);
   return ret;
 }
 
@@ -409,17 +409,18 @@ GNUNET_FS_make_top(struct GNUNET_FS_Handle *h,
  * @param top top level activity entry
  */
 void
-GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
+GNUNET_FS_end_top (struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
 {
-  GNUNET_CONTAINER_DLL_remove(h->top_head, h->top_tail, top);
-  GNUNET_free(top);
+  GNUNET_CONTAINER_DLL_remove (h->top_head, h->top_tail, top);
+  GNUNET_free (top);
 }
 
 
 /**
  * Closure for #GNUNET_FS_data_reader_file_().
  */
-struct FileInfo {
+struct FileInfo
+{
   /**
    * Name of the file to read.
    */
@@ -453,63 +454,63 @@ struct FileInfo {
  * @return number of bytes written, usually @a max, 0 on error
  */
 size_t
-GNUNET_FS_data_reader_file_(void *cls,
-                            uint64_t offset,
-                            size_t max,
-                            void *buf,
-                            char **emsg)
+GNUNET_FS_data_reader_file_ (void *cls,
+                             uint64_t offset,
+                             size_t max,
+                             void *buf,
+                             char **emsg)
 {
   struct FileInfo *fi = cls;
   ssize_t ret;
 
   if (UINT64_MAX == offset)
+  {
+    if (NULL != fi->fd)
     {
-      if (NULL != fi->fd)
-        {
-          GNUNET_DISK_file_close(fi->fd);
-          fi->fd = NULL;
-        }
-      return 0;
+      GNUNET_DISK_file_close (fi->fd);
+      fi->fd = NULL;
     }
+    return 0;
+  }
   if (0 == max)
-    {
-      if (NULL != fi->fd)
-        GNUNET_DISK_file_close(fi->fd);
-      GNUNET_free(fi->filename);
-      GNUNET_free(fi);
-      return 0;
-    }
+  {
+    if (NULL != fi->fd)
+      GNUNET_DISK_file_close (fi->fd);
+    GNUNET_free (fi->filename);
+    GNUNET_free (fi);
+    return 0;
+  }
   if (NULL == fi->fd)
-    {
-      fi->fd = GNUNET_DISK_file_open(fi->filename,
-                                     GNUNET_DISK_OPEN_READ,
-                                     GNUNET_DISK_PERM_NONE);
-      if (NULL == fi->fd)
-        {
-          GNUNET_asprintf(emsg,
-                          _("Could not open file `%s': %s"),
-                          fi->filename,
-                          strerror(errno));
-          return 0;
-        }
-    }
-  if ((GNUNET_SYSERR ==
-       GNUNET_DISK_file_seek(fi->fd, offset, GNUNET_DISK_SEEK_SET)) ||
-      (-1 == (ret = GNUNET_DISK_file_read(fi->fd, buf, max))))
-    {
-      GNUNET_asprintf(emsg,
-                      _("Could not read file `%s': %s"),
-                      fi->filename,
-                      strerror(errno));
+  {
+    fi->fd = GNUNET_DISK_file_open (fi->filename,
+                                    GNUNET_DISK_OPEN_READ,
+                                    GNUNET_DISK_PERM_NONE);
+    if (NULL == fi->fd)
+    {
+      GNUNET_asprintf (emsg,
+                       _ ("Could not open file `%s': %s"),
+                       fi->filename,
+                       strerror (errno));
       return 0;
     }
+  }
+  if ((GNUNET_SYSERR ==
+       GNUNET_DISK_file_seek (fi->fd, offset, GNUNET_DISK_SEEK_SET)) ||
+      (-1 == (ret = GNUNET_DISK_file_read (fi->fd, buf, max))))
+  {
+    GNUNET_asprintf (emsg,
+                     _ ("Could not read file `%s': %s"),
+                     fi->filename,
+                     strerror (errno));
+    return 0;
+  }
   if (ret != max)
-    {
-      GNUNET_asprintf(emsg,
-                      _("Short read reading from file `%s'!"),
-                      fi->filename);
-      return 0;
-    }
+  {
+    GNUNET_asprintf (emsg,
+                     _ ("Short read reading from file `%s'!"),
+                     fi->filename);
+    return 0;
+  }
   return max;
 }
 
@@ -521,17 +522,17 @@ GNUNET_FS_data_reader_file_(void *cls,
  * @return closure to use, NULL on error
  */
 void *
-GNUNET_FS_make_file_reader_context_(const char *filename)
+GNUNET_FS_make_file_reader_context_ (const char *filename)
 {
   struct FileInfo *fi;
 
-  fi = GNUNET_new(struct FileInfo);
-  fi->filename = GNUNET_STRINGS_filename_expand(filename);
+  fi = GNUNET_new (struct FileInfo);
+  fi->filename = GNUNET_STRINGS_filename_expand (filename);
   if (NULL == fi->filename)
-    {
-      GNUNET_free(fi);
-      return NULL;
-    }
+  {
+    GNUNET_free (fi);
+    return NULL;
+  }
   return fi;
 }
 
@@ -557,22 +558,22 @@ GNUNET_FS_make_file_reader_context_(const char *filename)
  * @return number of bytes written, usually @a max, 0 on error
  */
 size_t
-GNUNET_FS_data_reader_copy_(void *cls,
-                            uint64_t offset,
-                            size_t max,
-                            void *buf,
-                            char **emsg)
+GNUNET_FS_data_reader_copy_ (void *cls,
+                             uint64_t offset,
+                             size_t max,
+                             void *buf,
+                             char **emsg)
 {
   char *data = cls;
 
   if (UINT64_MAX == offset)
     return 0;
   if (0 == max)
-    {
-      GNUNET_free_non_null(data);
-      return 0;
-    }
-  GNUNET_memcpy(buf, &data[offset], max);
+  {
+    GNUNET_free_non_null (data);
+    return 0;
+  }
+  GNUNET_memcpy (buf, &data[offset], max);
   return max;
 }
 
@@ -587,30 +588,30 @@ GNUNET_FS_data_reader_copy_(void *cls,
  * @return NULL on error
  */
 static char *
-get_serialization_file_name(struct GNUNET_FS_Handle *h,
-                            const char *ext,
-                            const char *ent)
+get_serialization_file_name (struct GNUNET_FS_Handle *h,
+                             const char *ext,
+                             const char *ent)
 {
   char *basename;
   char *ret;
 
   if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
     return NULL; /* persistence not requested */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(h->cfg,
-                                                           "fs",
-                                                           "STATE_DIR",
-                                                           &basename))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (h->cfg,
+                                                            "fs",
+                                                            "STATE_DIR",
+                                                            &basename))
     return NULL;
-  GNUNET_asprintf(&ret,
-                  "%s%s%s%s%s%s%s",
-                  basename,
-                  DIR_SEPARATOR_STR,
-                  h->client_name,
-                  DIR_SEPARATOR_STR,
-                  ext,
-                  DIR_SEPARATOR_STR,
-                  ent);
-  GNUNET_free(basename);
+  GNUNET_asprintf (&ret,
+                   "%s%s%s%s%s%s%s",
+                   basename,
+                   DIR_SEPARATOR_STR,
+                   h->client_name,
+                   DIR_SEPARATOR_STR,
+                   ext,
+                   DIR_SEPARATOR_STR,
+                   ent);
+  GNUNET_free (basename);
   return ret;
 }
 
@@ -627,33 +628,33 @@ get_serialization_file_name(struct GNUNET_FS_Handle *h,
  * @return NULL on error
  */
 static char *
-get_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h,
-                                   const char *ext,
-                                   const char *uni,
-                                   const char *ent)
+get_serialization_file_name_in_dir (struct GNUNET_FS_Handle *h,
+                                    const char *ext,
+                                    const char *uni,
+                                    const char *ent)
 {
   char *basename;
   char *ret;
 
   if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
     return NULL; /* persistence not requested */
-  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(h->cfg,
-                                                           "fs",
-                                                           "STATE_DIR",
-                                                           &basename))
+  if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (h->cfg,
+                                                            "fs",
+                                                            "STATE_DIR",
+                                                            &basename))
     return NULL;
-  GNUNET_asprintf(&ret,
-                  "%s%s%s%s%s%s%s.dir%s%s",
-                  basename,
-                  DIR_SEPARATOR_STR,
-                  h->client_name,
-                  DIR_SEPARATOR_STR,
-                  ext,
-                  DIR_SEPARATOR_STR,
-                  uni,
-                  DIR_SEPARATOR_STR,
-                  ent);
-  GNUNET_free(basename);
+  GNUNET_asprintf (&ret,
+                   "%s%s%s%s%s%s%s.dir%s%s",
+                   basename,
+                   DIR_SEPARATOR_STR,
+                   h->client_name,
+                   DIR_SEPARATOR_STR,
+                   ext,
+                   DIR_SEPARATOR_STR,
+                   uni,
+                   DIR_SEPARATOR_STR,
+                   ent);
+  GNUNET_free (basename);
   return ret;
 }
 
@@ -667,16 +668,16 @@ get_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h,
  * @return NULL on error
  */
 static struct GNUNET_BIO_ReadHandle *
-get_read_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
+get_read_handle (struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
 {
   char *fn;
   struct GNUNET_BIO_ReadHandle *ret;
 
-  fn = get_serialization_file_name(h, ext, ent);
+  fn = get_serialization_file_name (h, ext, ent);
   if (NULL == fn)
     return NULL;
-  ret = GNUNET_BIO_read_open(fn);
-  GNUNET_free(fn);
+  ret = GNUNET_BIO_read_open (fn);
+  GNUNET_free (fn);
   return ret;
 }
 
@@ -690,17 +691,17 @@ get_read_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
  * @return NULL on error
  */
 static struct GNUNET_BIO_WriteHandle *
-get_write_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
+get_write_handle (struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
 {
   char *fn;
   struct GNUNET_BIO_WriteHandle *ret;
 
-  fn = get_serialization_file_name(h, ext, ent);
+  fn = get_serialization_file_name (h, ext, ent);
   if (NULL == fn)
     return NULL;
-  ret = GNUNET_BIO_write_open(fn);
-  GNUNET_break(NULL != ret);
-  GNUNET_free(fn);
+  ret = GNUNET_BIO_write_open (fn);
+  GNUNET_break (NULL != ret);
+  GNUNET_free (fn);
   return ret;
 }
 
@@ -715,19 +716,19 @@ get_write_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
  * @return NULL on error
  */
 static struct GNUNET_BIO_WriteHandle *
-get_write_handle_in_dir(struct GNUNET_FS_Handle *h,
-                        const char *ext,
-                        const char *uni,
-                        const char *ent)
+get_write_handle_in_dir (struct GNUNET_FS_Handle *h,
+                         const char *ext,
+                         const char *uni,
+                         const char *ent)
 {
   char *fn;
   struct GNUNET_BIO_WriteHandle *ret;
 
-  fn = get_serialization_file_name_in_dir(h, ext, uni, ent);
+  fn = get_serialization_file_name_in_dir (h, ext, uni, ent);
   if (NULL == fn)
     return NULL;
-  ret = GNUNET_BIO_write_open(fn);
-  GNUNET_free(fn);
+  ret = GNUNET_BIO_write_open (fn);
+  GNUNET_free (fn);
   return ret;
 }
 
@@ -740,24 +741,24 @@ get_write_handle_in_dir(struct GNUNET_FS_Handle *h,
  * @param ent entity identifier
  */
 void
-GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h,
-                            const char *ext,
-                            const char *ent)
+GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
+                             const char *ext,
+                             const char *ent)
 {
   char *filename;
 
-  if ((NULL == ent) || (0 == strlen(ent)))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  filename = get_serialization_file_name(h, ext, ent);
+  if ((NULL == ent) || (0 == strlen (ent)))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  filename = get_serialization_file_name (h, ext, ent);
   if (NULL != filename)
-    {
-      if ((0 != unlink(filename)) && (ENOENT != errno))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
-      GNUNET_free(filename);
-    }
+  {
+    if ((0 != unlink (filename)) && (ENOENT != errno))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
+    GNUNET_free (filename);
+  }
 }
 
 
@@ -770,24 +771,24 @@ GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h,
  * @param ent entity identifier
  */
 static void
-remove_sync_file_in_dir(struct GNUNET_FS_Handle *h,
-                        const char *ext,
-                        const char *uni,
-                        const char *ent)
+remove_sync_file_in_dir (struct GNUNET_FS_Handle *h,
+                         const char *ext,
+                         const char *uni,
+                         const char *ent)
 {
   char *filename;
 
-  if ((NULL == ent) || (0 == strlen(ent)))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  filename = get_serialization_file_name_in_dir(h, ext, uni, ent);
+  if ((NULL == ent) || (0 == strlen (ent)))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  filename = get_serialization_file_name_in_dir (h, ext, uni, ent);
   if (NULL == filename)
     return;
-  if (0 != unlink(filename))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
-  GNUNET_free(filename);
+  if (0 != unlink (filename))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
+  GNUNET_free (filename);
 }
 
 
@@ -799,21 +800,21 @@ remove_sync_file_in_dir(struct GNUNET_FS_Handle *h,
  * @param uni unique name of parent
  */
 void
-GNUNET_FS_remove_sync_dir_(struct GNUNET_FS_Handle *h,
-                           const char *ext,
-                           const char *uni)
+GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
+                            const char *ext,
+                            const char *uni)
 {
   char *dn;
 
   if (NULL == uni)
     return;
-  dn = get_serialization_file_name_in_dir(h, ext, uni, "");
+  dn = get_serialization_file_name_in_dir (h, ext, uni, "");
   if (NULL == dn)
     return;
-  if ((GNUNET_YES == GNUNET_DISK_directory_test(dn, GNUNET_YES)) &&
-      (GNUNET_OK != GNUNET_DISK_directory_remove(dn)))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "rmdir", dn);
-  GNUNET_free(dn);
+  if ((GNUNET_YES == GNUNET_DISK_directory_test (dn, GNUNET_YES)) &&
+      (GNUNET_OK != GNUNET_DISK_directory_remove (dn)))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "rmdir", dn);
+  GNUNET_free (dn);
 }
 
 
@@ -832,13 +833,13 @@ GNUNET_FS_remove_sync_dir_(struct GNUNET_FS_Handle *h,
  * @return #GNUNET_OK on success
  */
 static int
-write_start_time(struct GNUNET_BIO_WriteHandle *wh,
-                 struct GNUNET_TIME_Absolute timestamp)
+write_start_time (struct GNUNET_BIO_WriteHandle *wh,
+                  struct GNUNET_TIME_Absolute timestamp)
 {
   struct GNUNET_TIME_Relative dur;
 
-  dur = GNUNET_TIME_absolute_get_duration(timestamp);
-  return GNUNET_BIO_write_int64(wh, dur.rel_value_us);
+  dur = GNUNET_TIME_absolute_get_duration (timestamp);
+  return GNUNET_BIO_write_int64 (wh, dur.rel_value_us);
 }
 
 
@@ -857,14 +858,14 @@ write_start_time(struct GNUNET_BIO_WriteHandle *wh,
  * @return #GNUNET_OK on success
  */
 static int
-read_start_time(struct GNUNET_BIO_ReadHandle *rh,
-                struct GNUNET_TIME_Absolute *timestamp)
+read_start_time (struct GNUNET_BIO_ReadHandle *rh,
+                 struct GNUNET_TIME_Absolute *timestamp)
 {
   struct GNUNET_TIME_Relative dur;
 
-  if (GNUNET_OK != GNUNET_BIO_read_int64(rh, &dur.rel_value_us))
+  if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dur.rel_value_us))
     return GNUNET_SYSERR;
-  *timestamp = GNUNET_TIME_absolute_subtract(GNUNET_TIME_absolute_get(), dur);
+  *timestamp = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (), dur);
   return GNUNET_OK;
 }
 
@@ -879,7 +880,7 @@ read_start_time(struct GNUNET_BIO_ReadHandle *rh,
  * @return NULL on error
  */
 static struct GNUNET_FS_FileInformation *
-deserialize_file_information(struct GNUNET_FS_Handle *h, const char *filename);
+deserialize_file_information (struct GNUNET_FS_Handle *h, const char *filename);
 
 
 /**
@@ -893,9 +894,9 @@ deserialize_file_information(struct GNUNET_FS_Handle *h, const char *filename);
  * @return NULL on error
  */
 static struct GNUNET_FS_FileInformation *
-deserialize_fi_node(struct GNUNET_FS_Handle *h,
-                    const char *fn,
-                    struct GNUNET_BIO_ReadHandle *rh)
+deserialize_fi_node (struct GNUNET_FS_Handle *h,
+                     const char *fn,
+                     struct GNUNET_BIO_ReadHandle *rh)
 {
   struct GNUNET_FS_FileInformation *ret;
   struct GNUNET_FS_FileInformation *nxt;
@@ -906,209 +907,209 @@ deserialize_fi_node(struct GNUNET_FS_Handle *h,
   char *filename;
   uint32_t dsize;
 
-  if (GNUNET_OK != GNUNET_BIO_read(rh, "status flag", &b, sizeof(b)))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  ret = GNUNET_new(struct GNUNET_FS_FileInformation);
+  if (GNUNET_OK != GNUNET_BIO_read (rh, "status flag", &b, sizeof(b)))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  ret = GNUNET_new (struct GNUNET_FS_FileInformation);
   ret->h = h;
   ksks = NULL;
   chks = NULL;
   skss = NULL;
   filename = NULL;
-  if ((GNUNET_OK != GNUNET_BIO_read_meta_data(rh, "metadata", &ret->meta)) ||
-      (GNUNET_OK != GNUNET_BIO_read_string(rh, "ksk-uri", &ksks, 32 * 1024)) ||
+  if ((GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "metadata", &ret->meta)) ||
+      (GNUNET_OK != GNUNET_BIO_read_string (rh, "ksk-uri", &ksks, 32 * 1024)) ||
       ((NULL != ksks) &&
-       ((NULL == (ret->keywords = GNUNET_FS_uri_parse(ksks, NULL))) ||
-        (GNUNET_YES != GNUNET_FS_uri_test_ksk(ret->keywords)))) ||
-      (GNUNET_OK != GNUNET_BIO_read_string(rh, "chk-uri", &chks, 1024)) ||
+       ((NULL == (ret->keywords = GNUNET_FS_uri_parse (ksks, NULL))) ||
+        (GNUNET_YES != GNUNET_FS_uri_test_ksk (ret->keywords)))) ||
+      (GNUNET_OK != GNUNET_BIO_read_string (rh, "chk-uri", &chks, 1024)) ||
       ((NULL != chks) &&
-       ((NULL == (ret->chk_uri = GNUNET_FS_uri_parse(chks, NULL))) ||
-        (GNUNET_YES != GNUNET_FS_uri_test_chk(ret->chk_uri)))) ||
-      (GNUNET_OK != GNUNET_BIO_read_string(rh, "sks-uri", &skss, 1024)) ||
+       ((NULL == (ret->chk_uri = GNUNET_FS_uri_parse (chks, NULL))) ||
+        (GNUNET_YES != GNUNET_FS_uri_test_chk (ret->chk_uri)))) ||
+      (GNUNET_OK != GNUNET_BIO_read_string (rh, "sks-uri", &skss, 1024)) ||
       ((NULL != skss) &&
-       ((NULL == (ret->sks_uri = GNUNET_FS_uri_parse(skss, NULL))) ||
-        (GNUNET_YES != GNUNET_FS_uri_test_sks(ret->sks_uri)))) ||
-      (GNUNET_OK != read_start_time(rh, &ret->start_time)) ||
+       ((NULL == (ret->sks_uri = GNUNET_FS_uri_parse (skss, NULL))) ||
+        (GNUNET_YES != GNUNET_FS_uri_test_sks (ret->sks_uri)))) ||
+      (GNUNET_OK != read_start_time (rh, &ret->start_time)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "emsg", &ret->emsg, 16 * 1024)) ||
+       GNUNET_BIO_read_string (rh, "emsg", &ret->emsg, 16 * 1024)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "fn", &ret->filename, 16 * 1024)) ||
+       GNUNET_BIO_read_string (rh, "fn", &ret->filename, 16 * 1024)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_int64(rh, &ret->bo.expiration_time.abs_value_us)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &ret->bo.anonymity_level)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &ret->bo.content_priority)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &ret->bo.replication_level)))
+       GNUNET_BIO_read_int64 (rh, &ret->bo.expiration_time.abs_value_us)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &ret->bo.anonymity_level)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &ret->bo.content_priority)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &ret->bo.replication_level)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  switch (b)
+  {
+  case 0:   /* file-insert */
+    if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size))
     {
-      GNUNET_break(0);
+      GNUNET_break (0);
       goto cleanup;
     }
-  switch (b)
+    ret->is_directory = GNUNET_NO;
+    ret->data.file.do_index = GNUNET_NO;
+    ret->data.file.have_hash = GNUNET_NO;
+    ret->data.file.index_start_confirmed = GNUNET_NO;
+    if (GNUNET_NO == ret->is_published)
     {
-    case 0: /* file-insert */
-      if (GNUNET_OK != GNUNET_BIO_read_int64(rh, &ret->data.file.file_size))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      ret->is_directory = GNUNET_NO;
-      ret->data.file.do_index = GNUNET_NO;
-      ret->data.file.have_hash = GNUNET_NO;
-      ret->data.file.index_start_confirmed = GNUNET_NO;
-      if (GNUNET_NO == ret->is_published)
-        {
-          if (NULL == ret->filename)
-            {
-              ret->data.file.reader = &GNUNET_FS_data_reader_copy_;
-              ret->data.file.reader_cls =
-                GNUNET_malloc_large(ret->data.file.file_size);
-              if (ret->data.file.reader_cls == NULL)
-                goto cleanup;
-              if (GNUNET_OK != GNUNET_BIO_read(rh,
-                                               "file-data",
-                                               ret->data.file.reader_cls,
-                                               ret->data.file.file_size))
-                {
-                  GNUNET_break(0);
-                  goto cleanup;
-                }
-            }
-          else
-            {
-              ret->data.file.reader = &GNUNET_FS_data_reader_file_;
-              ret->data.file.reader_cls =
-                GNUNET_FS_make_file_reader_context_(ret->filename);
-            }
-        }
-      break;
-
-    case 1: /* file-index, no hash */
       if (NULL == ret->filename)
-        {
-          GNUNET_break(0);
+      {
+        ret->data.file.reader = &GNUNET_FS_data_reader_copy_;
+        ret->data.file.reader_cls =
+          GNUNET_malloc_large (ret->data.file.file_size);
+        if (ret->data.file.reader_cls == NULL)
           goto cleanup;
-        }
-      if (GNUNET_OK != GNUNET_BIO_read_int64(rh, &ret->data.file.file_size))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      ret->is_directory = GNUNET_NO;
-      ret->data.file.do_index = GNUNET_YES;
-      ret->data.file.have_hash = GNUNET_NO;
-      ret->data.file.index_start_confirmed = GNUNET_NO;
-      ret->data.file.reader = &GNUNET_FS_data_reader_file_;
-      ret->data.file.reader_cls =
-        GNUNET_FS_make_file_reader_context_(ret->filename);
-      break;
-
-    case 2: /* file-index-with-hash */
-      if (NULL == ret->filename)
+        if (GNUNET_OK != GNUNET_BIO_read (rh,
+                                          "file-data",
+                                          ret->data.file.reader_cls,
+                                          ret->data.file.file_size))
         {
-          GNUNET_break(0);
+          GNUNET_break (0);
           goto cleanup;
         }
-      if ((GNUNET_OK != GNUNET_BIO_read_int64(rh, &ret->data.file.file_size)) ||
-          (GNUNET_OK != GNUNET_BIO_read(rh,
-                                        "fileid",
-                                        &ret->data.file.file_id,
-                                        sizeof(struct GNUNET_HashCode))))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      ret->is_directory = GNUNET_NO;
-      ret->data.file.do_index = GNUNET_YES;
-      ret->data.file.have_hash = GNUNET_YES;
-      ret->data.file.index_start_confirmed = GNUNET_NO;
-      ret->data.file.reader = &GNUNET_FS_data_reader_file_;
-      ret->data.file.reader_cls =
-        GNUNET_FS_make_file_reader_context_(ret->filename);
-      break;
+      }
+      else
+      {
+        ret->data.file.reader = &GNUNET_FS_data_reader_file_;
+        ret->data.file.reader_cls =
+          GNUNET_FS_make_file_reader_context_ (ret->filename);
+      }
+    }
+    break;
 
-    case 3: /* file-index-with-hash-confirmed */
-      if (NULL == ret->filename)
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      if ((GNUNET_OK != GNUNET_BIO_read_int64(rh, &ret->data.file.file_size)) ||
-          (GNUNET_OK != GNUNET_BIO_read(rh,
-                                        "fileid",
-                                        &ret->data.file.file_id,
-                                        sizeof(struct GNUNET_HashCode))))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      ret->is_directory = GNUNET_NO;
-      ret->data.file.do_index = GNUNET_YES;
-      ret->data.file.have_hash = GNUNET_YES;
-      ret->data.file.index_start_confirmed = GNUNET_YES;
-      ret->data.file.reader = &GNUNET_FS_data_reader_file_;
-      ret->data.file.reader_cls =
-        GNUNET_FS_make_file_reader_context_(ret->filename);
-      break;
+  case 1:   /* file-index, no hash */
+    if (NULL == ret->filename)
+    {
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size))
+    {
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    ret->is_directory = GNUNET_NO;
+    ret->data.file.do_index = GNUNET_YES;
+    ret->data.file.have_hash = GNUNET_NO;
+    ret->data.file.index_start_confirmed = GNUNET_NO;
+    ret->data.file.reader = &GNUNET_FS_data_reader_file_;
+    ret->data.file.reader_cls =
+      GNUNET_FS_make_file_reader_context_ (ret->filename);
+    break;
 
-    case 4: /* directory */
-      ret->is_directory = GNUNET_YES;
-      if ((GNUNET_OK != GNUNET_BIO_read_int32(rh, &dsize)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_read_int64(rh, &ret->data.dir.contents_completed)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_read_int64(rh, &ret->data.dir.contents_size)) ||
-          (NULL == (ret->data.dir.dir_data = GNUNET_malloc_large(dsize))) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_read(rh, "dir-data", ret->data.dir.dir_data, dsize)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_read_string(rh, "ent-filename", &filename, 16 * 1024)))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      ret->data.dir.dir_size = (uint32_t)dsize;
-      if (NULL != filename)
-        {
-          ret->data.dir.entries = deserialize_file_information(h, filename);
-          GNUNET_free(filename);
-          filename = NULL;
-          nxt = ret->data.dir.entries;
-          while (NULL != nxt)
-            {
-              nxt->dir = ret;
-              nxt = nxt->next;
-            }
-        }
-      break;
+  case 2:   /* file-index-with-hash */
+    if (NULL == ret->filename)
+    {
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    if ((GNUNET_OK != GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size)) ||
+        (GNUNET_OK != GNUNET_BIO_read (rh,
+                                       "fileid",
+                                       &ret->data.file.file_id,
+                                       sizeof(struct GNUNET_HashCode))))
+    {
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    ret->is_directory = GNUNET_NO;
+    ret->data.file.do_index = GNUNET_YES;
+    ret->data.file.have_hash = GNUNET_YES;
+    ret->data.file.index_start_confirmed = GNUNET_NO;
+    ret->data.file.reader = &GNUNET_FS_data_reader_file_;
+    ret->data.file.reader_cls =
+      GNUNET_FS_make_file_reader_context_ (ret->filename);
+    break;
 
-    default:
-      GNUNET_break(0);
+  case 3:   /* file-index-with-hash-confirmed */
+    if (NULL == ret->filename)
+    {
+      GNUNET_break (0);
       goto cleanup;
     }
-  ret->serialization = GNUNET_strdup(fn);
-  if (GNUNET_OK !=
-      GNUNET_BIO_read_string(rh, "nxt-filename", &filename, 16 * 1024))
+    if ((GNUNET_OK != GNUNET_BIO_read_int64 (rh, &ret->data.file.file_size)) ||
+        (GNUNET_OK != GNUNET_BIO_read (rh,
+                                       "fileid",
+                                       &ret->data.file.file_id,
+                                       sizeof(struct GNUNET_HashCode))))
     {
-      GNUNET_break(0);
+      GNUNET_break (0);
       goto cleanup;
     }
-  if (NULL != filename)
+    ret->is_directory = GNUNET_NO;
+    ret->data.file.do_index = GNUNET_YES;
+    ret->data.file.have_hash = GNUNET_YES;
+    ret->data.file.index_start_confirmed = GNUNET_YES;
+    ret->data.file.reader = &GNUNET_FS_data_reader_file_;
+    ret->data.file.reader_cls =
+      GNUNET_FS_make_file_reader_context_ (ret->filename);
+    break;
+
+  case 4:   /* directory */
+    ret->is_directory = GNUNET_YES;
+    if ((GNUNET_OK != GNUNET_BIO_read_int32 (rh, &dsize)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_read_int64 (rh, &ret->data.dir.contents_completed)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_read_int64 (rh, &ret->data.dir.contents_size)) ||
+        (NULL == (ret->data.dir.dir_data = GNUNET_malloc_large (dsize))) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_read (rh, "dir-data", ret->data.dir.dir_data, dsize)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_read_string (rh, "ent-filename", &filename, 16 * 1024)))
+    {
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    ret->data.dir.dir_size = (uint32_t) dsize;
+    if (NULL != filename)
     {
-      ret->next = deserialize_file_information(h, filename);
-      GNUNET_free(filename);
+      ret->data.dir.entries = deserialize_file_information (h, filename);
+      GNUNET_free (filename);
       filename = NULL;
-    }
-  GNUNET_free_non_null(ksks);
-  GNUNET_free_non_null(skss);
-  GNUNET_free_non_null(chks);
+      nxt = ret->data.dir.entries;
+      while (NULL != nxt)
+      {
+        nxt->dir = ret;
+        nxt = nxt->next;
+      }
+    }
+    break;
+
+  default:
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  ret->serialization = GNUNET_strdup (fn);
+  if (GNUNET_OK !=
+      GNUNET_BIO_read_string (rh, "nxt-filename", &filename, 16 * 1024))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  if (NULL != filename)
+  {
+    ret->next = deserialize_file_information (h, filename);
+    GNUNET_free (filename);
+    filename = NULL;
+  }
+  GNUNET_free_non_null (ksks);
+  GNUNET_free_non_null (skss);
+  GNUNET_free_non_null (chks);
   return ret;
 cleanup:
-  GNUNET_free_non_null(ksks);
-  GNUNET_free_non_null(chks);
-  GNUNET_free_non_null(skss);
-  GNUNET_free_non_null(filename);
-  GNUNET_FS_file_information_destroy(ret, NULL, NULL);
+  GNUNET_free_non_null (ksks);
+  GNUNET_free_non_null (chks);
+  GNUNET_free_non_null (skss);
+  GNUNET_free_non_null (filename);
+  GNUNET_FS_file_information_destroy (ret, NULL, NULL);
   return NULL;
 }
 
@@ -1123,36 +1124,36 @@ cleanup:
  * @return NULL on error
  */
 static struct GNUNET_FS_FileInformation *
-deserialize_file_information(struct GNUNET_FS_Handle *h, const char *filename)
+deserialize_file_information (struct GNUNET_FS_Handle *h, const char *filename)
 {
   struct GNUNET_FS_FileInformation *ret;
   struct GNUNET_BIO_ReadHandle *rh;
   char *emsg;
   char *fn;
 
-  rh = get_read_handle(h, GNUNET_FS_SYNC_PATH_FILE_INFO, filename);
+  rh = get_read_handle (h, GNUNET_FS_SYNC_PATH_FILE_INFO, filename);
   if (NULL == rh)
     return NULL;
-  ret = deserialize_fi_node(h, filename, rh);
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failed to resume publishing information `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+  ret = deserialize_fi_node (h, filename, rh);
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to resume publishing information `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   if (NULL == ret)
+  {
+    fn =
+      get_serialization_file_name (h, GNUNET_FS_SYNC_PATH_FILE_INFO, filename);
+    if (NULL != fn)
     {
-      fn =
-        get_serialization_file_name(h, GNUNET_FS_SYNC_PATH_FILE_INFO, filename);
-      if (NULL != fn)
-        {
-          if (0 != unlink(fn))
-            GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
-          GNUNET_free(fn);
-        }
+      if (0 != unlink (fn))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+      GNUNET_free (fn);
     }
+  }
   return ret;
 }
 
@@ -1166,7 +1167,7 @@ deserialize_file_information(struct GNUNET_FS_Handle *h, const char *filename)
  * @return copy of the basename, NULL on error
  */
 static char *
-get_serialization_short_name(const char *fullname)
+get_serialization_short_name (const char *fullname)
 {
   const char *end;
   const char *nxt;
@@ -1176,18 +1177,18 @@ get_serialization_short_name(const char *fullname)
   /* FIXME: we could do this faster since we know
    * the length of 'end'... */
   while ('\0' != *nxt)
-    {
-      if (DIR_SEPARATOR == *nxt)
-        end = nxt + 1;
-      nxt++;
-    }
-  if ((NULL == end) || (0 == strlen(end)))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  GNUNET_break(6 == strlen(end));
-  return GNUNET_strdup(end);
+  {
+    if (DIR_SEPARATOR == *nxt)
+      end = nxt + 1;
+    nxt++;
+  }
+  if ((NULL == end) || (0 == strlen (end)))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  GNUNET_break (6 == strlen (end));
+  return GNUNET_strdup (end);
 }
 
 
@@ -1200,7 +1201,7 @@ get_serialization_short_name(const char *fullname)
  * @return NULL on errror
  */
 static char *
-make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
+make_serialization_file_name (struct GNUNET_FS_Handle *h, const char *ext)
 {
   char *fn;
   char *dn;
@@ -1208,20 +1209,20 @@ make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
 
   if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
     return NULL; /* persistence not requested */
-  dn = get_serialization_file_name(h, ext, "");
+  dn = get_serialization_file_name (h, ext, "");
   if (NULL == dn)
     return NULL;
-  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(dn))
-    {
-      GNUNET_free(dn);
-      return NULL;
-    }
-  fn = GNUNET_DISK_mktemp(dn);
-  GNUNET_free(dn);
+  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (dn))
+  {
+    GNUNET_free (dn);
+    return NULL;
+  }
+  fn = GNUNET_DISK_mktemp (dn);
+  GNUNET_free (dn);
   if (NULL == fn)
     return NULL; /* epic fail */
-  ret = get_serialization_short_name(fn);
-  GNUNET_free(fn);
+  ret = get_serialization_short_name (fn);
+  GNUNET_free (fn);
   return ret;
 }
 
@@ -1236,9 +1237,9 @@ make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
  * @return NULL on errror
  */
 static char *
-make_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h,
-                                    const char *ext,
-                                    const char *uni)
+make_serialization_file_name_in_dir (struct GNUNET_FS_Handle *h,
+                                     const char *ext,
+                                     const char *uni)
 {
   char *fn;
   char *dn;
@@ -1246,20 +1247,20 @@ make_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h,
 
   if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
     return NULL; /* persistence not requested */
-  dn = get_serialization_file_name_in_dir(h, ext, uni, "");
+  dn = get_serialization_file_name_in_dir (h, ext, uni, "");
   if (NULL == dn)
     return NULL;
-  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(dn))
-    {
-      GNUNET_free(dn);
-      return NULL;
-    }
-  fn = GNUNET_DISK_mktemp(dn);
-  GNUNET_free(dn);
+  if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (dn))
+  {
+    GNUNET_free (dn);
+    return NULL;
+  }
+  fn = GNUNET_DISK_mktemp (dn);
+  GNUNET_free (dn);
   if (NULL == fn)
     return NULL; /* epic fail */
-  ret = get_serialization_short_name(fn);
-  GNUNET_free(fn);
+  ret = get_serialization_short_name (fn);
+  GNUNET_free (fn);
   return ret;
 }
 
@@ -1272,8 +1273,8 @@ make_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h,
  * @return #GNUNET_OK on success
  */
 static int
-copy_from_reader(struct GNUNET_BIO_WriteHandle *wh,
-                 struct GNUNET_FS_FileInformation *fi)
+copy_from_reader (struct GNUNET_BIO_WriteHandle *wh,
+                  struct GNUNET_FS_FileInformation *fi)
 {
   char buf[32 * 1024];
   uint64_t off;
@@ -1284,19 +1285,19 @@ copy_from_reader(struct GNUNET_BIO_WriteHandle *wh,
   emsg = NULL;
   off = 0;
   while (off < fi->data.file.file_size)
-    {
-      left = GNUNET_MIN(sizeof(buf), fi->data.file.file_size - off);
-      ret =
-        fi->data.file.reader(fi->data.file.reader_cls, off, left, buf, &emsg);
-      if (0 == ret)
-        {
-          GNUNET_free(emsg);
-          return GNUNET_SYSERR;
-        }
-      if (GNUNET_OK != GNUNET_BIO_write(wh, buf, ret))
-        return GNUNET_SYSERR;
-      off += ret;
-    }
+  {
+    left = GNUNET_MIN (sizeof(buf), fi->data.file.file_size - off);
+    ret =
+      fi->data.file.reader (fi->data.file.reader_cls, off, left, buf, &emsg);
+    if (0 == ret)
+    {
+      GNUNET_free (emsg);
+      return GNUNET_SYSERR;
+    }
+    if (GNUNET_OK != GNUNET_BIO_write (wh, buf, ret))
+      return GNUNET_SYSERR;
+    off += ret;
+  }
   return GNUNET_OK;
 }
 
@@ -1308,7 +1309,7 @@ copy_from_reader(struct GNUNET_BIO_WriteHandle *wh,
  * @param fi file information to sync with disk
  */
 void
-GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *fi)
+GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *fi)
 {
   char *fn;
   struct GNUNET_BIO_WriteHandle *wh;
@@ -1319,17 +1320,17 @@ GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *fi)
 
   if (NULL == fi->serialization)
     fi->serialization =
-      make_serialization_file_name(fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO);
+      make_serialization_file_name (fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO);
   if (NULL == fi->serialization)
     return;
   wh =
-    get_write_handle(fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO, fi->serialization);
+    get_write_handle (fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO, fi->serialization);
   if (NULL == wh)
-    {
-      GNUNET_free(fi->serialization);
-      fi->serialization = NULL;
-      return;
-    }
+  {
+    GNUNET_free (fi->serialization);
+    fi->serialization = NULL;
+    return;
+  }
   if (GNUNET_YES == fi->is_directory)
     b = 4;
   else if (GNUNET_YES == fi->data.file.index_start_confirmed)
@@ -1341,147 +1342,147 @@ GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *fi)
   else
     b = 0;
   if (NULL != fi->keywords)
-    ksks = GNUNET_FS_uri_to_string(fi->keywords);
+    ksks = GNUNET_FS_uri_to_string (fi->keywords);
   else
     ksks = NULL;
   if (NULL != fi->chk_uri)
-    chks = GNUNET_FS_uri_to_string(fi->chk_uri);
+    chks = GNUNET_FS_uri_to_string (fi->chk_uri);
   else
     chks = NULL;
   if (NULL != fi->sks_uri)
-    skss = GNUNET_FS_uri_to_string(fi->sks_uri);
+    skss = GNUNET_FS_uri_to_string (fi->sks_uri);
   else
     skss = NULL;
-  if ((GNUNET_OK != GNUNET_BIO_write(wh, &b, sizeof(b))) ||
-      (GNUNET_OK != GNUNET_BIO_write_meta_data(wh, fi->meta)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, ksks)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, chks)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, skss)) ||
-      (GNUNET_OK != write_start_time(wh, fi->start_time)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, fi->emsg)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, fi->filename)) ||
+  if ((GNUNET_OK != GNUNET_BIO_write (wh, &b, sizeof(b))) ||
+      (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, fi->meta)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, ksks)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, chks)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, skss)) ||
+      (GNUNET_OK != write_start_time (wh, fi->start_time)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, fi->emsg)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, fi->filename)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_write_int64(wh, fi->bo.expiration_time.abs_value_us)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, fi->bo.anonymity_level)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, fi->bo.content_priority)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, fi->bo.replication_level)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  GNUNET_free_non_null(chks);
+       GNUNET_BIO_write_int64 (wh, fi->bo.expiration_time.abs_value_us)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->bo.anonymity_level)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->bo.content_priority)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->bo.replication_level)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  GNUNET_free_non_null (chks);
   chks = NULL;
-  GNUNET_free_non_null(ksks);
+  GNUNET_free_non_null (ksks);
   ksks = NULL;
-  GNUNET_free_non_null(skss);
+  GNUNET_free_non_null (skss);
   skss = NULL;
 
   switch (b)
+  {
+  case 0:   /* file-insert */
+    if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, fi->data.file.file_size))
     {
-    case 0: /* file-insert */
-      if (GNUNET_OK != GNUNET_BIO_write_int64(wh, fi->data.file.file_size))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      if ((GNUNET_NO == fi->is_published) && (NULL == fi->filename))
-        if (GNUNET_OK != copy_from_reader(wh, fi))
-          {
-            GNUNET_break(0);
-            goto cleanup;
-          }
-      break;
-
-    case 1: /* file-index, no hash */
-      if (NULL == fi->filename)
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      if (GNUNET_OK != GNUNET_BIO_write_int64(wh, fi->data.file.file_size))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      break;
-
-    case 2: /* file-index-with-hash */
-    case 3: /* file-index-with-hash-confirmed */
-      if (NULL == fi->filename)
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      if ((GNUNET_OK != GNUNET_BIO_write_int64(wh, fi->data.file.file_size)) ||
-          (GNUNET_OK != GNUNET_BIO_write(wh,
-                                         &fi->data.file.file_id,
-                                         sizeof(struct GNUNET_HashCode))))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      break;
-
-    case 4: /* directory */
-      if ((NULL != fi->data.dir.entries) &&
-          (NULL == fi->data.dir.entries->serialization))
-        GNUNET_FS_file_information_sync_(fi->data.dir.entries);
-      if ((GNUNET_OK != GNUNET_BIO_write_int32(wh, fi->data.dir.dir_size)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_write_int64(wh, fi->data.dir.contents_completed)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_write_int64(wh, fi->data.dir.contents_size)) ||
-          (GNUNET_OK != GNUNET_BIO_write(wh,
-                                         fi->data.dir.dir_data,
-                                         (uint32_t)fi->data.dir.dir_size)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_write_string(wh,
-                                   (fi->data.dir.entries == NULL)
-                                   ? NULL
-                                   : fi->data.dir.entries->serialization)))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      break;
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    if ((GNUNET_NO == fi->is_published) && (NULL == fi->filename))
+      if (GNUNET_OK != copy_from_reader (wh, fi))
+      {
+        GNUNET_break (0);
+        goto cleanup;
+      }
+    break;
 
-    default:
-      GNUNET_assert(0);
+  case 1:   /* file-index, no hash */
+    if (NULL == fi->filename)
+    {
+      GNUNET_break (0);
       goto cleanup;
     }
-  if ((NULL != fi->next) && (NULL == fi->next->serialization))
-    GNUNET_FS_file_information_sync_(fi->next);
-  if (GNUNET_OK != GNUNET_BIO_write_string(wh,
-                                           (fi->next != NULL)
-                                           ? fi->next->serialization
-                                           : NULL))
+    if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, fi->data.file.file_size))
     {
-      GNUNET_break(0);
+      GNUNET_break (0);
       goto cleanup;
     }
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
+    break;
+
+  case 2:   /* file-index-with-hash */
+  case 3:   /* file-index-with-hash-confirmed */
+    if (NULL == fi->filename)
     {
-      wh = NULL;
-      GNUNET_break(0);
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    if ((GNUNET_OK != GNUNET_BIO_write_int64 (wh, fi->data.file.file_size)) ||
+        (GNUNET_OK != GNUNET_BIO_write (wh,
+                                        &fi->data.file.file_id,
+                                        sizeof(struct GNUNET_HashCode))))
+    {
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    break;
+
+  case 4:   /* directory */
+    if ((NULL != fi->data.dir.entries) &&
+        (NULL == fi->data.dir.entries->serialization))
+      GNUNET_FS_file_information_sync_ (fi->data.dir.entries);
+    if ((GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->data.dir.dir_size)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_write_int64 (wh, fi->data.dir.contents_completed)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_write_int64 (wh, fi->data.dir.contents_size)) ||
+        (GNUNET_OK != GNUNET_BIO_write (wh,
+                                        fi->data.dir.dir_data,
+                                        (uint32_t) fi->data.dir.dir_size)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_write_string (wh,
+                                  (fi->data.dir.entries == NULL)
+                                  ? NULL
+                                  : fi->data.dir.entries->serialization)))
+    {
+      GNUNET_break (0);
       goto cleanup;
     }
+    break;
+
+  default:
+    GNUNET_assert (0);
+    goto cleanup;
+  }
+  if ((NULL != fi->next) && (NULL == fi->next->serialization))
+    GNUNET_FS_file_information_sync_ (fi->next);
+  if (GNUNET_OK != GNUNET_BIO_write_string (wh,
+                                            (fi->next != NULL)
+                                            ? fi->next->serialization
+                                            : NULL))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
   return; /* done! */
 cleanup:
   if (NULL != wh)
-    (void)GNUNET_BIO_write_close(wh);
-  GNUNET_free_non_null(chks);
-  GNUNET_free_non_null(ksks);
-  GNUNET_free_non_null(skss);
-  fn = get_serialization_file_name(fi->h,
-                                   GNUNET_FS_SYNC_PATH_FILE_INFO,
-                                   fi->serialization);
+    (void) GNUNET_BIO_write_close (wh);
+  GNUNET_free_non_null (chks);
+  GNUNET_free_non_null (ksks);
+  GNUNET_free_non_null (skss);
+  fn = get_serialization_file_name (fi->h,
+                                    GNUNET_FS_SYNC_PATH_FILE_INFO,
+                                    fi->serialization);
   if (NULL != fn)
-    {
-      if (0 != unlink(fn))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
-      GNUNET_free(fn);
-    }
-  GNUNET_free(fi->serialization);
+  {
+    if (0 != unlink (fn))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+    GNUNET_free (fn);
+  }
+  GNUNET_free (fi->serialization);
   fi->serialization = NULL;
 }
 
@@ -1495,19 +1496,19 @@ cleanup:
  * @return NULL if srch was not found in this subtree
  */
 static struct GNUNET_FS_FileInformation *
-find_file_position(struct GNUNET_FS_FileInformation *pos, const char *srch)
+find_file_position (struct GNUNET_FS_FileInformation *pos, const char *srch)
 {
   struct GNUNET_FS_FileInformation *r;
 
   while (NULL != pos)
-    {
-      if (0 == strcmp(srch, pos->serialization))
-        return pos;
-      if ((GNUNET_YES == pos->is_directory) &&
-          (NULL != (r = find_file_position(pos->data.dir.entries, srch))))
-        return r;
-      pos = pos->next;
-    }
+  {
+    if (0 == strcmp (srch, pos->serialization))
+      return pos;
+    if ((GNUNET_YES == pos->is_directory) &&
+        (NULL != (r = find_file_position (pos->data.dir.entries, srch))))
+      return r;
+    pos = pos->next;
+  }
   return NULL;
 }
 
@@ -1527,33 +1528,33 @@ find_file_position(struct GNUNET_FS_FileInformation *pos, const char *srch)
  * @return #GNUNET_OK to continue (always)
  */
 static int
-fip_signal_resume(void *cls,
-                  struct GNUNET_FS_FileInformation *fi,
-                  uint64_t length,
-                  struct GNUNET_CONTAINER_MetaData *meta,
-                  struct GNUNET_FS_Uri **uri,
-                  struct GNUNET_FS_BlockOptions *bo,
-                  int *do_index,
-                  void **client_info)
+fip_signal_resume (void *cls,
+                   struct GNUNET_FS_FileInformation *fi,
+                   uint64_t length,
+                   struct GNUNET_CONTAINER_MetaData *meta,
+                   struct GNUNET_FS_Uri **uri,
+                   struct GNUNET_FS_BlockOptions *bo,
+                   int *do_index,
+                   void **client_info)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
   if (GNUNET_YES == pc->skip_next_fi_callback)
-    {
-      pc->skip_next_fi_callback = GNUNET_NO;
-      return GNUNET_OK;
-    }
+  {
+    pc->skip_next_fi_callback = GNUNET_NO;
+    return GNUNET_OK;
+  }
   pi.status = GNUNET_FS_STATUS_PUBLISH_RESUME;
   pi.value.publish.specifics.resume.message = fi->emsg;
   pi.value.publish.specifics.resume.chk_uri = fi->chk_uri;
-  *client_info = GNUNET_FS_publish_make_status_(&pi, pc, fi, 0);
-  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(meta))
-    {
-      /* process entries in directory */
-      pc->skip_next_fi_callback = GNUNET_YES;
-      GNUNET_FS_file_information_inspect(fi, &fip_signal_resume, pc);
-    }
+  *client_info = GNUNET_FS_publish_make_status_ (&pi, pc, fi, 0);
+  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (meta))
+  {
+    /* process entries in directory */
+    pc->skip_next_fi_callback = GNUNET_YES;
+    GNUNET_FS_file_information_inspect (fi, &fip_signal_resume, pc);
+  }
   return GNUNET_OK;
 }
 
@@ -1567,7 +1568,7 @@ fip_signal_resume(void *cls,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-deserialize_publish_file(void *cls, const char *filename)
+deserialize_publish_file (void *cls, const char *filename)
 {
   struct GNUNET_FS_Handle *h = cls;
   struct GNUNET_BIO_ReadHandle *rh;
@@ -1580,115 +1581,115 @@ deserialize_publish_file(void *cls, const char *filename)
   char *fi_pos;
   char *emsg;
 
-  pc = GNUNET_new(struct GNUNET_FS_PublishContext);
+  pc = GNUNET_new (struct GNUNET_FS_PublishContext);
   pc->h = h;
-  pc->serialization = get_serialization_short_name(filename);
+  pc->serialization = get_serialization_short_name (filename);
   fi_root = NULL;
   fi_pos = NULL;
-  rh = GNUNET_BIO_read_open(filename);
+  rh = GNUNET_BIO_read_open (filename);
   if (NULL == rh)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if ((GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "publish-nid", &pc->nid, 1024)) ||
+       GNUNET_BIO_read_string (rh, "publish-nid", &pc->nid, 1024)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "publish-nuid", &pc->nuid, 1024)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &options)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &all_done)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &have_ns)) ||
+       GNUNET_BIO_read_string (rh, "publish-nuid", &pc->nuid, 1024)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &options)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &all_done)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &have_ns)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "publish-firoot", &fi_root, 128)) ||
+       GNUNET_BIO_read_string (rh, "publish-firoot", &fi_root, 128)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "publish-fipos", &fi_pos, 128)) ||
+       GNUNET_BIO_read_string (rh, "publish-fipos", &fi_pos, 128)) ||
       ((GNUNET_YES == have_ns) &&
-       (GNUNET_OK != GNUNET_BIO_read(rh, "publish-ns", &ns, sizeof(ns)))))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+       (GNUNET_OK != GNUNET_BIO_read (rh, "publish-ns", &ns, sizeof(ns)))))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   pc->options = options;
   pc->all_done = all_done;
   if (NULL == fi_root)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  pc->fi = deserialize_file_information(h, fi_root);
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  pc->fi = deserialize_file_information (h, fi_root);
   if (NULL == pc->fi)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if (GNUNET_YES == have_ns)
-    {
-      pc->ns = GNUNET_new(struct GNUNET_CRYPTO_EcdsaPrivateKey);
-      *pc->ns = ns;
-    }
+  {
+    pc->ns = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
+    *pc->ns = ns;
+  }
   if ((0 == (pc->options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY)) &&
       (GNUNET_YES != pc->all_done))
-    {
-      pc->dsh = GNUNET_DATASTORE_connect(h->cfg);
-      if (NULL == pc->dsh)
-        goto cleanup;
-    }
+  {
+    pc->dsh = GNUNET_DATASTORE_connect (h->cfg);
+    if (NULL == pc->dsh)
+      goto cleanup;
+  }
   if (NULL != fi_pos)
-    {
-      pc->fi_pos = find_file_position(pc->fi, fi_pos);
-      GNUNET_free(fi_pos);
-      fi_pos = NULL;
-      if (NULL == pc->fi_pos)
-        {
-          /* failed to find position for resuming, outch! Will start from root! */
-          GNUNET_break(0);
-          if (GNUNET_YES != pc->all_done)
-            pc->fi_pos = pc->fi;
-        }
-    }
-  GNUNET_free(fi_root);
+  {
+    pc->fi_pos = find_file_position (pc->fi, fi_pos);
+    GNUNET_free (fi_pos);
+    fi_pos = NULL;
+    if (NULL == pc->fi_pos)
+    {
+      /* failed to find position for resuming, outch! Will start from root! */
+      GNUNET_break (0);
+      if (GNUNET_YES != pc->all_done)
+        pc->fi_pos = pc->fi;
+    }
+  }
+  GNUNET_free (fi_root);
   fi_root = NULL;
   /* generate RESUME event(s) */
-  GNUNET_FS_file_information_inspect(pc->fi, &fip_signal_resume, pc);
+  GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_resume, pc);
 
   /* re-start publishing (if needed)... */
   if (GNUNET_YES != pc->all_done)
-    {
-      GNUNET_assert(NULL == pc->upload_task);
-      pc->upload_task =
-        GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                           &GNUNET_FS_publish_main_,
-                                           pc);
-    }
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failure while resuming publishing operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
-  pc->top = GNUNET_FS_make_top(h, &GNUNET_FS_publish_signal_suspend_, pc);
+  {
+    GNUNET_assert (NULL == pc->upload_task);
+    pc->upload_task =
+      GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                          &GNUNET_FS_publish_main_,
+                                          pc);
+  }
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failure while resuming publishing operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
+  pc->top = GNUNET_FS_make_top (h, &GNUNET_FS_publish_signal_suspend_, pc);
   return GNUNET_OK;
 cleanup:
-  GNUNET_free_non_null(pc->nid);
-  GNUNET_free_non_null(pc->nuid);
-  GNUNET_free_non_null(fi_root);
-  GNUNET_free_non_null(fi_pos);
-  if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failed to resume publishing operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+  GNUNET_free_non_null (pc->nid);
+  GNUNET_free_non_null (pc->nuid);
+  GNUNET_free_non_null (fi_root);
+  GNUNET_free_non_null (fi_pos);
+  if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to resume publishing operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   if (NULL != pc->fi)
-    GNUNET_FS_file_information_destroy(pc->fi, NULL, NULL);
-  if (0 != unlink(filename))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
-  GNUNET_free(pc->serialization);
-  GNUNET_free(pc);
+    GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
+  if (0 != unlink (filename))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
+  GNUNET_free (pc->serialization);
+  GNUNET_free (pc);
   return GNUNET_OK;
 }
 
@@ -1702,65 +1703,65 @@ cleanup:
  * @param pc the struct to sync
  */
 void
-GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc)
+GNUNET_FS_publish_sync_ (struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_BIO_WriteHandle *wh;
   int32_t have_ns;
 
   if (NULL == pc->serialization)
     pc->serialization =
-      make_serialization_file_name(pc->h, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH);
+      make_serialization_file_name (pc->h, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH);
   if (NULL == pc->serialization)
     return;
   if (NULL == pc->fi)
     return;
   if (NULL == pc->fi->serialization)
-    {
-      GNUNET_break(0);
-      return;
-    }
-  wh = get_write_handle(pc->h,
-                        GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
-                        pc->serialization);
+  {
+    GNUNET_break (0);
+    return;
+  }
+  wh = get_write_handle (pc->h,
+                         GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
+                         pc->serialization);
   if (NULL == wh)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   have_ns = (NULL != pc->ns) ? GNUNET_YES : GNUNET_NO;
-  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, pc->nid)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, pc->nuid)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, pc->options)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, pc->all_done)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, have_ns)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, pc->fi->serialization)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh,
-                                            (NULL == pc->fi_pos)
-                                            ? NULL
-                                            : pc->fi_pos->serialization)) ||
+  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, pc->nid)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, pc->nuid)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pc->options)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pc->all_done)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, have_ns)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, pc->fi->serialization)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh,
+                                             (NULL == pc->fi_pos)
+                                             ? NULL
+                                             : pc->fi_pos->serialization)) ||
       ((NULL != pc->ns) &&
        (GNUNET_OK !=
-        GNUNET_BIO_write(wh,
-                         pc->ns,
-                         sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)))))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    {
-      wh = NULL;
-      GNUNET_break(0);
-      goto cleanup;
-    }
+        GNUNET_BIO_write (wh,
+                          pc->ns,
+                          sizeof(struct GNUNET_CRYPTO_EcdsaPrivateKey)))))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
   return;
 cleanup:
   if (NULL != wh)
-    (void)GNUNET_BIO_write_close(wh);
-  GNUNET_FS_remove_sync_file_(pc->h,
-                              GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
-                              pc->serialization);
-  GNUNET_free(pc->serialization);
+    (void) GNUNET_BIO_write_close (wh);
+  GNUNET_FS_remove_sync_file_ (pc->h,
+                               GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
+                               pc->serialization);
+  GNUNET_free (pc->serialization);
   pc->serialization = NULL;
 }
 
@@ -1774,60 +1775,60 @@ cleanup:
  * @param uc the struct to sync
  */
 void
-GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
+GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc)
 {
   struct GNUNET_BIO_WriteHandle *wh;
   char *uris;
 
   if (NULL == uc->serialization)
     uc->serialization =
-      make_serialization_file_name(uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX);
+      make_serialization_file_name (uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX);
   if (NULL == uc->serialization)
     return;
-  wh = get_write_handle(uc->h,
-                        GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
-                        uc->serialization);
+  wh = get_write_handle (uc->h,
+                         GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
+                         uc->serialization);
   if (NULL == wh)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if (NULL != uc->ksk_uri)
-    uris = GNUNET_FS_uri_to_string(uc->ksk_uri);
+    uris = GNUNET_FS_uri_to_string (uc->ksk_uri);
   else
     uris = NULL;
-  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, uc->filename)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int64(wh, uc->file_size)) ||
-      (GNUNET_OK != write_start_time(wh, uc->start_time)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, (uint32_t)uc->state)) ||
+  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uc->filename)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int64 (wh, uc->file_size)) ||
+      (GNUNET_OK != write_start_time (wh, uc->start_time)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) uc->state)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_write(wh, &uc->chk, sizeof(struct ContentHashKey))) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, uris)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, (uint32_t)uc->ksk_offset)) ||
+       GNUNET_BIO_write (wh, &uc->chk, sizeof(struct ContentHashKey))) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) uc->ksk_offset)) ||
       ((uc->state == UNINDEX_STATE_FS_NOTIFY) &&
-       (GNUNET_OK != GNUNET_BIO_write(wh,
-                                      &uc->file_id,
-                                      sizeof(struct GNUNET_HashCode)))) ||
+       (GNUNET_OK != GNUNET_BIO_write (wh,
+                                       &uc->file_id,
+                                       sizeof(struct GNUNET_HashCode)))) ||
       ((uc->state == UNINDEX_STATE_ERROR) &&
-       (GNUNET_OK != GNUNET_BIO_write_string(wh, uc->emsg))))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    {
-      wh = NULL;
-      GNUNET_break(0);
-      goto cleanup;
-    }
+       (GNUNET_OK != GNUNET_BIO_write_string (wh, uc->emsg))))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
   return;
 cleanup:
   if (NULL != wh)
-    (void)GNUNET_BIO_write_close(wh);
-  GNUNET_FS_remove_sync_file_(uc->h,
-                              GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
-                              uc->serialization);
-  GNUNET_free(uc->serialization);
+    (void) GNUNET_BIO_write_close (wh);
+  GNUNET_FS_remove_sync_file_ (uc->h,
+                               GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
+                               uc->serialization);
+  GNUNET_free (uc->serialization);
   uc->serialization = NULL;
 }
 
@@ -1840,22 +1841,22 @@ cleanup:
  * @return #GNUNET_YES on success, #GNUNET_NO on error
  */
 static int
-write_download_request(struct GNUNET_BIO_WriteHandle *wh,
-                       struct DownloadRequest *dr)
+write_download_request (struct GNUNET_BIO_WriteHandle *wh,
+                        struct DownloadRequest *dr)
 {
   unsigned int i;
 
-  if ((GNUNET_OK != GNUNET_BIO_write_int32(wh, dr->state)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int64(wh, dr->offset)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, dr->num_children)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, dr->depth)))
+  if ((GNUNET_OK != GNUNET_BIO_write_int32 (wh, dr->state)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dr->offset)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, dr->num_children)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, dr->depth)))
     return GNUNET_NO;
   if ((BRS_CHK_SET == dr->state) &&
       (GNUNET_OK !=
-       GNUNET_BIO_write(wh, &dr->chk, sizeof(struct ContentHashKey))))
+       GNUNET_BIO_write (wh, &dr->chk, sizeof(struct ContentHashKey))))
     return GNUNET_NO;
   for (i = 0; i < dr->num_children; i++)
-    if (GNUNET_NO == write_download_request(wh, dr->children[i]))
+    if (GNUNET_NO == write_download_request (wh, dr->children[i]))
       return GNUNET_NO;
   return GNUNET_YES;
 }
@@ -1868,59 +1869,59 @@ write_download_request(struct GNUNET_BIO_WriteHandle *wh,
  * @return value the download request read from disk, NULL on error
  */
 static struct DownloadRequest *
-read_download_request(struct GNUNET_BIO_ReadHandle *rh)
+read_download_request (struct GNUNET_BIO_ReadHandle *rh)
 {
   struct DownloadRequest *dr;
   unsigned int i;
 
-  dr = GNUNET_new(struct DownloadRequest);
-  if ((GNUNET_OK != GNUNET_BIO_read_int32(rh, &dr->state)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int64(rh, &dr->offset)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &dr->num_children)) ||
+  dr = GNUNET_new (struct DownloadRequest);
+  if ((GNUNET_OK != GNUNET_BIO_read_int32 (rh, &dr->state)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dr->offset)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &dr->num_children)) ||
       (dr->num_children > CHK_PER_INODE) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &dr->depth)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &dr->depth)) ||
       ((0 == dr->depth) && (dr->num_children > 0)) ||
       ((dr->depth > 0) && (0 == dr->num_children)))
-    {
-      GNUNET_break(0);
-      dr->num_children = 0;
-      goto cleanup;
-    }
+  {
+    GNUNET_break (0);
+    dr->num_children = 0;
+    goto cleanup;
+  }
   if (dr->num_children > 0)
     dr->children =
-      GNUNET_malloc(dr->num_children * sizeof(struct DownloadRequest *));
+      GNUNET_malloc (dr->num_children * sizeof(struct DownloadRequest *));
   switch (dr->state)
-    {
-    case BRS_INIT:
-    case BRS_RECONSTRUCT_DOWN:
-    case BRS_RECONSTRUCT_META_UP:
-    case BRS_RECONSTRUCT_UP:
-      break;
+  {
+  case BRS_INIT:
+  case BRS_RECONSTRUCT_DOWN:
+  case BRS_RECONSTRUCT_META_UP:
+  case BRS_RECONSTRUCT_UP:
+    break;
+
+  case BRS_CHK_SET:
+    if (GNUNET_OK !=
+        GNUNET_BIO_read (rh, "chk", &dr->chk, sizeof(struct ContentHashKey)))
+      goto cleanup;
+    break;
 
-    case BRS_CHK_SET:
-      if (GNUNET_OK !=
-          GNUNET_BIO_read(rh, "chk", &dr->chk, sizeof(struct ContentHashKey)))
-        goto cleanup;
-      break;
+  case BRS_DOWNLOAD_DOWN:
+  case BRS_DOWNLOAD_UP:
+  case BRS_ERROR:
+    break;
 
-    case BRS_DOWNLOAD_DOWN:
-    case BRS_DOWNLOAD_UP:
-    case BRS_ERROR:
-      break;
-
-    default:
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  default:
+    GNUNET_break (0);
+    goto cleanup;
+  }
   for (i = 0; i < dr->num_children; i++)
-    {
-      if (NULL == (dr->children[i] = read_download_request(rh)))
-        goto cleanup;
-      dr->children[i]->parent = dr;
-    }
+  {
+    if (NULL == (dr->children[i] = read_download_request (rh)))
+      goto cleanup;
+    dr->children[i]->parent = dr;
+  }
   return dr;
 cleanup:
-  GNUNET_FS_free_download_request_(dr);
+  GNUNET_FS_free_download_request_ (dr);
   return NULL;
 }
 
@@ -1935,26 +1936,26 @@ cleanup:
  * @return the expanded file name, NULL for none
  */
 static char *
-get_download_sync_filename(struct GNUNET_FS_DownloadContext *dc,
-                           const char *uni,
-                           const char *ext)
+get_download_sync_filename (struct GNUNET_FS_DownloadContext *dc,
+                            const char *uni,
+                            const char *ext)
 {
   char *par;
   char *epar;
 
   if (dc->parent == NULL)
-    return get_serialization_file_name(dc->h,
-                                       (dc->search != NULL)
-                                       ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
-                                       : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
-                                       uni);
+    return get_serialization_file_name (dc->h,
+                                        (dc->search != NULL)
+                                        ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
+                                        : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
+                                        uni);
   if (NULL == dc->parent->serialization)
     return NULL;
-  par = get_download_sync_filename(dc->parent, dc->parent->serialization, "");
+  par = get_download_sync_filename (dc->parent, dc->parent->serialization, "");
   if (NULL == par)
     return NULL;
-  GNUNET_asprintf(&epar, "%s.dir%s%s%s", par, DIR_SEPARATOR_STR, uni, ext);
-  GNUNET_free(par);
+  GNUNET_asprintf (&epar, "%s.dir%s%s%s", par, DIR_SEPARATOR_STR, uni, ext);
+  GNUNET_free (par);
   return epar;
 }
 
@@ -1968,7 +1969,7 @@ get_download_sync_filename(struct GNUNET_FS_DownloadContext *dc,
  * @param dc the struct to sync
  */
 void
-GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
+GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc)
 {
   struct GNUNET_BIO_WriteHandle *wh;
   char *uris;
@@ -1978,87 +1979,87 @@ GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
   if (0 != (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
     return; /* we don't sync probes */
   if (NULL == dc->serialization)
+  {
+    dir = get_download_sync_filename (dc, "", "");
+    if (NULL == dir)
+      return;
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (dir))
     {
-      dir = get_download_sync_filename(dc, "", "");
-      if (NULL == dir)
-        return;
-      if (GNUNET_OK != GNUNET_DISK_directory_create_for_file(dir))
-        {
-          GNUNET_free(dir);
-          return;
-        }
-      fn = GNUNET_DISK_mktemp(dir);
-      GNUNET_free(dir);
-      if (NULL == fn)
-        return;
-      dc->serialization = get_serialization_short_name(fn);
+      GNUNET_free (dir);
+      return;
     }
+    fn = GNUNET_DISK_mktemp (dir);
+    GNUNET_free (dir);
+    if (NULL == fn)
+      return;
+    dc->serialization = get_serialization_short_name (fn);
+  }
   else
+  {
+    fn = get_download_sync_filename (dc, dc->serialization, "");
+    if (NULL == fn)
     {
-      fn = get_download_sync_filename(dc, dc->serialization, "");
-      if (NULL == fn)
-        {
-          GNUNET_free(dc->serialization);
-          dc->serialization = NULL;
-          GNUNET_free(fn);
-          return;
-        }
-    }
-  wh = GNUNET_BIO_write_open(fn);
-  if (NULL == wh)
-    {
-      GNUNET_free(dc->serialization);
+      GNUNET_free (dc->serialization);
       dc->serialization = NULL;
-      GNUNET_free(fn);
+      GNUNET_free (fn);
       return;
     }
-  GNUNET_assert((GNUNET_YES == GNUNET_FS_uri_test_chk(dc->uri)) ||
-                (GNUNET_YES == GNUNET_FS_uri_test_loc(dc->uri)));
-  uris = GNUNET_FS_uri_to_string(dc->uri);
-  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, uris)) ||
-      (GNUNET_OK != GNUNET_BIO_write_meta_data(wh, dc->meta)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, dc->emsg)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, dc->filename)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, dc->temp_filename)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int64(wh, dc->old_file_size)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int64(wh, dc->offset)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int64(wh, dc->length)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int64(wh, dc->completed)) ||
-      (GNUNET_OK != write_start_time(wh, dc->start_time)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, dc->anonymity)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, (uint32_t)dc->options)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, (uint32_t)dc->has_finished)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  }
+  wh = GNUNET_BIO_write_open (fn);
+  if (NULL == wh)
+  {
+    GNUNET_free (dc->serialization);
+    dc->serialization = NULL;
+    GNUNET_free (fn);
+    return;
+  }
+  GNUNET_assert ((GNUNET_YES == GNUNET_FS_uri_test_chk (dc->uri)) ||
+                 (GNUNET_YES == GNUNET_FS_uri_test_loc (dc->uri)));
+  uris = GNUNET_FS_uri_to_string (dc->uri);
+  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
+      (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, dc->meta)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, dc->emsg)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, dc->filename)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, dc->temp_filename)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dc->old_file_size)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dc->offset)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dc->length)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dc->completed)) ||
+      (GNUNET_OK != write_start_time (wh, dc->start_time)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, dc->anonymity)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) dc->options)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) dc->has_finished)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if (NULL == dc->emsg)
+  {
+    GNUNET_assert (dc->top_request != NULL);
+    if (GNUNET_YES != write_download_request (wh, dc->top_request))
     {
-      GNUNET_assert(dc->top_request != NULL);
-      if (GNUNET_YES != write_download_request(wh, dc->top_request))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-    }
-  GNUNET_free_non_null(uris);
-  uris = NULL;
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    {
-      wh = NULL;
-      GNUNET_break(0);
+      GNUNET_break (0);
       goto cleanup;
     }
-  GNUNET_free(fn);
+  }
+  GNUNET_free_non_null (uris);
+  uris = NULL;
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  GNUNET_free (fn);
   return;
 cleanup:
   if (NULL != wh)
-    (void)GNUNET_BIO_write_close(wh);
-  GNUNET_free_non_null(uris);
-  if (0 != unlink(fn))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
-  GNUNET_free(fn);
-  GNUNET_free(dc->serialization);
+    (void) GNUNET_BIO_write_close (wh);
+  GNUNET_free_non_null (uris);
+  if (0 != unlink (fn))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+  GNUNET_free (fn);
+  GNUNET_free (dc->serialization);
   dc->serialization = NULL;
 }
 
@@ -2072,7 +2073,7 @@ cleanup:
  * @param sr the struct to sync
  */
 void
-GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
+GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr)
 {
   struct GNUNET_BIO_WriteHandle *wh;
   char *uris;
@@ -2082,74 +2083,74 @@ GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
   uris = NULL;
   if (NULL == sr->serialization)
     sr->serialization =
-      make_serialization_file_name_in_dir(sr->h,
-                                          (sr->sc->psearch_result == NULL)
-                                          ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                          : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                          sr->sc->serialization);
+      make_serialization_file_name_in_dir (sr->h,
+                                           (sr->sc->psearch_result == NULL)
+                                           ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                                           : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                                           sr->sc->serialization);
   if (NULL == sr->serialization)
     return;
-  wh = get_write_handle_in_dir(sr->h,
-                               (sr->sc->psearch_result == NULL)
-                               ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                               : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                               sr->sc->serialization,
-                               sr->serialization);
+  wh = get_write_handle_in_dir (sr->h,
+                                (sr->sc->psearch_result == NULL)
+                                ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                                : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                                sr->sc->serialization,
+                                sr->serialization);
   if (NULL == wh)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  uris = GNUNET_FS_uri_to_string(sr->uri);
-  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, uris)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh,
-                                            sr->download != NULL
-                                            ? sr->download->serialization
-                                            : NULL)) ||
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  uris = GNUNET_FS_uri_to_string (sr->uri);
+  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh,
+                                             (sr->download != NULL)
+                                             ? sr->download->serialization
+                                             : NULL)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_write_string(wh,
-                               sr->update_search != NULL
-                               ? sr->update_search->serialization
-                               : NULL)) ||
-      (GNUNET_OK != GNUNET_BIO_write_meta_data(wh, sr->meta)) ||
+       GNUNET_BIO_write_string (wh,
+                                (sr->update_search != NULL)
+                                ? sr->update_search->serialization
+                                : NULL)) ||
+      (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, sr->meta)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_write(wh, &sr->key, sizeof(struct GNUNET_HashCode))) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, sr->mandatory_missing)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, sr->optional_support)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, sr->availability_success)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, sr->availability_trials)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+       GNUNET_BIO_write (wh, &sr->key, sizeof(struct GNUNET_HashCode))) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->mandatory_missing)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->optional_support)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->availability_success)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sr->availability_trials)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if ((NULL != sr->uri) && (GNUNET_FS_URI_KSK == sr->sc->uri->type) &&
       (GNUNET_OK !=
-       GNUNET_BIO_write(wh,
-                        sr->keyword_bitmap,
-                        (sr->sc->uri->data.ksk.keywordCount + 7) / 8)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    {
-      wh = NULL;
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  GNUNET_free_non_null(uris);
+       GNUNET_BIO_write (wh,
+                         sr->keyword_bitmap,
+                         (sr->sc->uri->data.ksk.keywordCount + 7) / 8)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  GNUNET_free_non_null (uris);
   return;
 cleanup:
-  GNUNET_free_non_null(uris);
+  GNUNET_free_non_null (uris);
   if (NULL != wh)
-    (void)GNUNET_BIO_write_close(wh);
-  remove_sync_file_in_dir(sr->h,
-                          (NULL == sr->sc->psearch_result)
-                          ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                          : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                          sr->sc->serialization,
-                          sr->serialization);
-  GNUNET_free(sr->serialization);
+    (void) GNUNET_BIO_write_close (wh);
+  remove_sync_file_in_dir (sr->h,
+                           (NULL == sr->sc->psearch_result)
+                           ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                           : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                           sr->sc->serialization,
+                           sr->serialization);
+  GNUNET_free (sr->serialization);
   sr->serialization = NULL;
 }
 
@@ -2163,7 +2164,7 @@ cleanup:
  * @param sc the struct to sync
  */
 void
-GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
+GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_BIO_WriteHandle *wh;
   char *uris;
@@ -2173,45 +2174,45 @@ GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
   category = (NULL == sc->psearch_result) ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
              : GNUNET_FS_SYNC_PATH_CHILD_SEARCH;
   if (NULL == sc->serialization)
-    sc->serialization = make_serialization_file_name(sc->h, category);
+    sc->serialization = make_serialization_file_name (sc->h, category);
   if (NULL == sc->serialization)
     return;
   uris = NULL;
-  wh = get_write_handle(sc->h, category, sc->serialization);
+  wh = get_write_handle (sc->h, category, sc->serialization);
   if (NULL == wh)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  GNUNET_assert((GNUNET_YES == GNUNET_FS_uri_test_ksk(sc->uri)) ||
-                (GNUNET_YES == GNUNET_FS_uri_test_sks(sc->uri)));
-  uris = GNUNET_FS_uri_to_string(sc->uri);
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  GNUNET_assert ((GNUNET_YES == GNUNET_FS_uri_test_ksk (sc->uri)) ||
+                 (GNUNET_YES == GNUNET_FS_uri_test_sks (sc->uri)));
+  uris = GNUNET_FS_uri_to_string (sc->uri);
   in_pause = (sc->task != NULL) ? 'r' : '\0';
-  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, uris)) ||
-      (GNUNET_OK != write_start_time(wh, sc->start_time)) ||
-      (GNUNET_OK != GNUNET_BIO_write_string(wh, sc->emsg)) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, (uint32_t)sc->options)) ||
-      (GNUNET_OK != GNUNET_BIO_write(wh, &in_pause, sizeof(in_pause))) ||
-      (GNUNET_OK != GNUNET_BIO_write_int32(wh, sc->anonymity)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  GNUNET_free(uris);
+  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
+      (GNUNET_OK != write_start_time (wh, sc->start_time)) ||
+      (GNUNET_OK != GNUNET_BIO_write_string (wh, sc->emsg)) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) sc->options)) ||
+      (GNUNET_OK != GNUNET_BIO_write (wh, &in_pause, sizeof(in_pause))) ||
+      (GNUNET_OK != GNUNET_BIO_write_int32 (wh, sc->anonymity)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  GNUNET_free (uris);
   uris = NULL;
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    {
-      wh = NULL;
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
   return;
 cleanup:
   if (NULL != wh)
-    (void)GNUNET_BIO_write_close(wh);
-  GNUNET_free_non_null(uris);
-  GNUNET_FS_remove_sync_file_(sc->h, category, sc->serialization);
-  GNUNET_free(sc->serialization);
+    (void) GNUNET_BIO_write_close (wh);
+  GNUNET_free_non_null (uris);
+  GNUNET_FS_remove_sync_file_ (sc->h, category, sc->serialization);
+  GNUNET_free (sc->serialization);
   sc->serialization = NULL;
 }
 
@@ -2225,7 +2226,7 @@ cleanup:
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-deserialize_unindex_file(void *cls, const char *filename)
+deserialize_unindex_file (void *cls, const char *filename)
 {
   struct GNUNET_FS_Handle *h = cls;
   struct GNUNET_BIO_ReadHandle *rh;
@@ -2235,155 +2236,155 @@ deserialize_unindex_file(void *cls, const char *filename)
   char *uris;
   uint32_t state;
 
-  uc = GNUNET_new(struct GNUNET_FS_UnindexContext);
+  uc = GNUNET_new (struct GNUNET_FS_UnindexContext);
   uc->h = h;
-  uc->serialization = get_serialization_short_name(filename);
-  rh = GNUNET_BIO_read_open(filename);
+  uc->serialization = get_serialization_short_name (filename);
+  rh = GNUNET_BIO_read_open (filename);
   if (NULL == rh)
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   uris = NULL;
   if ((GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "unindex-fn", &uc->filename, 10 * 1024)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int64(rh, &uc->file_size)) ||
-      (GNUNET_OK != read_start_time(rh, &uc->start_time)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &state)) ||
+       GNUNET_BIO_read_string (rh, "unindex-fn", &uc->filename, 10 * 1024)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &uc->file_size)) ||
+      (GNUNET_OK != read_start_time (rh, &uc->start_time)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &state)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read(rh, "uri", &uc->chk, sizeof(struct ContentHashKey))) ||
+       GNUNET_BIO_read (rh, "uri", &uc->chk, sizeof(struct ContentHashKey))) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "unindex-kskuri", &uris, 10 * 1024)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &uc->ksk_offset)))
-    {
-      GNUNET_free_non_null(uris);
-      GNUNET_break(0);
-      goto cleanup;
-    }
+       GNUNET_BIO_read_string (rh, "unindex-kskuri", &uris, 10 * 1024)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &uc->ksk_offset)))
+  {
+    GNUNET_free_non_null (uris);
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if (NULL != uris)
+  {
+    uc->ksk_uri = GNUNET_FS_uri_parse (uris, &emsg);
+    GNUNET_free (uris);
+    if (NULL == uc->ksk_uri)
     {
-      uc->ksk_uri = GNUNET_FS_uri_parse(uris, &emsg);
-      GNUNET_free(uris);
-      if (NULL == uc->ksk_uri)
-        {
-          GNUNET_break(0);
-          GNUNET_free_non_null(emsg);
-          goto cleanup;
-        }
+      GNUNET_break (0);
+      GNUNET_free_non_null (emsg);
+      goto cleanup;
     }
+  }
   if ((uc->ksk_offset > 0) &&
       ((NULL == uc->ksk_uri) ||
        (uc->ksk_offset > uc->ksk_uri->data.ksk.keywordCount)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  uc->state = (enum UnindexState) state;
+  switch (state)
+  {
+  case UNINDEX_STATE_HASHING:
+    break;
+
+  case UNINDEX_STATE_FS_NOTIFY:
+    if (GNUNET_OK != GNUNET_BIO_read (rh,
+                                      "unindex-hash",
+                                      &uc->file_id,
+                                      sizeof(struct GNUNET_HashCode)))
     {
-      GNUNET_break(0);
+      GNUNET_break (0);
       goto cleanup;
     }
-  uc->state = (enum UnindexState)state;
-  switch (state)
-    {
-    case UNINDEX_STATE_HASHING:
-      break;
-
-    case UNINDEX_STATE_FS_NOTIFY:
-      if (GNUNET_OK != GNUNET_BIO_read(rh,
-                                       "unindex-hash",
-                                       &uc->file_id,
-                                       sizeof(struct GNUNET_HashCode)))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      break;
+    break;
 
-    case UNINDEX_STATE_DS_REMOVE:
-    case UNINDEX_STATE_EXTRACT_KEYWORDS:
-    case UNINDEX_STATE_DS_REMOVE_KBLOCKS:
-      break;
+  case UNINDEX_STATE_DS_REMOVE:
+  case UNINDEX_STATE_EXTRACT_KEYWORDS:
+  case UNINDEX_STATE_DS_REMOVE_KBLOCKS:
+    break;
 
-    case UNINDEX_STATE_COMPLETE:
-      break;
+  case UNINDEX_STATE_COMPLETE:
+    break;
 
-    case UNINDEX_STATE_ERROR:
-      if (GNUNET_OK !=
-          GNUNET_BIO_read_string(rh, "unindex-emsg", &uc->emsg, 10 * 1024))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
-      break;
-
-    default:
-      GNUNET_break(0);
+  case UNINDEX_STATE_ERROR:
+    if (GNUNET_OK !=
+        GNUNET_BIO_read_string (rh, "unindex-emsg", &uc->emsg, 10 * 1024))
+    {
+      GNUNET_break (0);
       goto cleanup;
     }
-  uc->top = GNUNET_FS_make_top(h, &GNUNET_FS_unindex_signal_suspend_, uc);
+    break;
+
+  default:
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  uc->top = GNUNET_FS_make_top (h, &GNUNET_FS_unindex_signal_suspend_, uc);
   pi.status = GNUNET_FS_STATUS_UNINDEX_RESUME;
   pi.value.unindex.specifics.resume.message = uc->emsg;
-  GNUNET_FS_unindex_make_status_(&pi,
-                                 uc,
-                                 (uc->state == UNINDEX_STATE_COMPLETE)
-                                 ? uc->file_size
-                                 : 0);
+  GNUNET_FS_unindex_make_status_ (&pi,
+                                  uc,
+                                  (uc->state == UNINDEX_STATE_COMPLETE)
+                                  ? uc->file_size
+                                  : 0);
   switch (uc->state)
-    {
-    case UNINDEX_STATE_HASHING:
-      uc->fhc = GNUNET_CRYPTO_hash_file(GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                        uc->filename,
-                                        HASHING_BLOCKSIZE,
-                                        &GNUNET_FS_unindex_process_hash_,
-                                        uc);
-      break;
-
-    case UNINDEX_STATE_FS_NOTIFY:
-      uc->state = UNINDEX_STATE_HASHING;
-      GNUNET_FS_unindex_process_hash_(uc, &uc->file_id);
-      break;
-
-    case UNINDEX_STATE_DS_REMOVE:
-      GNUNET_FS_unindex_do_remove_(uc);
-      break;
-
-    case UNINDEX_STATE_EXTRACT_KEYWORDS:
-      GNUNET_FS_unindex_do_extract_keywords_(uc);
-      break;
-
-    case UNINDEX_STATE_DS_REMOVE_KBLOCKS:
-      GNUNET_FS_unindex_do_remove_kblocks_(uc);
-      break;
-
-    case UNINDEX_STATE_COMPLETE:
-    case UNINDEX_STATE_ERROR:
-      /* no need to resume any operation, we were done */
-      break;
-
-    default:
-      break;
-    }
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failure while resuming unindexing operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+  {
+  case UNINDEX_STATE_HASHING:
+    uc->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                       uc->filename,
+                                       HASHING_BLOCKSIZE,
+                                       &GNUNET_FS_unindex_process_hash_,
+                                       uc);
+    break;
+
+  case UNINDEX_STATE_FS_NOTIFY:
+    uc->state = UNINDEX_STATE_HASHING;
+    GNUNET_FS_unindex_process_hash_ (uc, &uc->file_id);
+    break;
+
+  case UNINDEX_STATE_DS_REMOVE:
+    GNUNET_FS_unindex_do_remove_ (uc);
+    break;
+
+  case UNINDEX_STATE_EXTRACT_KEYWORDS:
+    GNUNET_FS_unindex_do_extract_keywords_ (uc);
+    break;
+
+  case UNINDEX_STATE_DS_REMOVE_KBLOCKS:
+    GNUNET_FS_unindex_do_remove_kblocks_ (uc);
+    break;
+
+  case UNINDEX_STATE_COMPLETE:
+  case UNINDEX_STATE_ERROR:
+    /* no need to resume any operation, we were done */
+    break;
+
+  default:
+    break;
+  }
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failure while resuming unindexing operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   return GNUNET_OK;
 cleanup:
-  GNUNET_free_non_null(uc->filename);
-  if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failed to resume unindexing operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+  GNUNET_free_non_null (uc->filename);
+  if ((NULL != rh) && (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to resume unindexing operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   if (NULL != uc->serialization)
-    GNUNET_FS_remove_sync_file_(h,
-                                GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
-                                uc->serialization);
-  GNUNET_free_non_null(uc->serialization);
-  GNUNET_free(uc);
+    GNUNET_FS_remove_sync_file_ (h,
+                                 GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
+                                 uc->serialization);
+  GNUNET_free_non_null (uc->serialization);
+  GNUNET_free (uc);
   return GNUNET_OK;
 }
 
@@ -2398,11 +2399,11 @@ cleanup:
  * @param serialization name under which the search was serialized
  */
 static void
-deserialize_download(struct GNUNET_FS_Handle *h,
-                     struct GNUNET_BIO_ReadHandle *rh,
-                     struct GNUNET_FS_DownloadContext *parent,
-                     struct GNUNET_FS_SearchResult *search,
-                     const char *serialization);
+deserialize_download (struct GNUNET_FS_Handle *h,
+                      struct GNUNET_BIO_ReadHandle *rh,
+                      struct GNUNET_FS_DownloadContext *parent,
+                      struct GNUNET_FS_SearchResult *search,
+                      const char *serialization);
 
 
 /**
@@ -2414,10 +2415,10 @@ deserialize_download(struct GNUNET_FS_Handle *h,
  * @param serialization name under which the search was serialized
  */
 static struct GNUNET_FS_SearchContext *
-deserialize_search(struct GNUNET_FS_Handle *h,
-                   struct GNUNET_BIO_ReadHandle *rh,
-                   struct GNUNET_FS_SearchResult *psearch_result,
-                   const char *serialization);
+deserialize_search (struct GNUNET_FS_Handle *h,
+                    struct GNUNET_BIO_ReadHandle *rh,
+                    struct GNUNET_FS_SearchResult *psearch_result,
+                    const char *serialization);
 
 
 /**
@@ -2429,7 +2430,7 @@ deserialize_search(struct GNUNET_FS_Handle *h,
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-deserialize_search_result(void *cls, const char *filename)
+deserialize_search_result (void *cls, const char *filename)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   char *ser;
@@ -2441,133 +2442,133 @@ deserialize_search_result(void *cls, const char *filename)
   struct GNUNET_BIO_ReadHandle *drh;
   struct GNUNET_FS_SearchResult *sr;
 
-  ser = get_serialization_short_name(filename);
-  rh = GNUNET_BIO_read_open(filename);
+  ser = get_serialization_short_name (filename);
+  rh = GNUNET_BIO_read_open (filename);
   if (NULL == rh)
+  {
+    if (NULL != ser)
     {
-      if (NULL != ser)
-        {
-          remove_sync_file_in_dir(sc->h,
-                                  (NULL == sc->psearch_result)
-                                  ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                  : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                  sc->serialization,
-                                  ser);
-          GNUNET_free(ser);
-        }
-      return GNUNET_OK;
+      remove_sync_file_in_dir (sc->h,
+                               (NULL == sc->psearch_result)
+                               ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                               : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                               sc->serialization,
+                               ser);
+      GNUNET_free (ser);
     }
+    return GNUNET_OK;
+  }
   emsg = NULL;
   uris = NULL;
   download = NULL;
   update_srch = NULL;
-  sr = GNUNET_new(struct GNUNET_FS_SearchResult);
+  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
   sr->h = sc->h;
   sr->sc = sc;
   sr->serialization = ser;
   if ((GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "result-uri", &uris, 10 * 1024)) ||
-      (NULL == (sr->uri = GNUNET_FS_uri_parse(uris, &emsg))) ||
+       GNUNET_BIO_read_string (rh, "result-uri", &uris, 10 * 1024)) ||
+      (NULL == (sr->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "download-lnk", &download, 16)) ||
+       GNUNET_BIO_read_string (rh, "download-lnk", &download, 16)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "search-lnk", &update_srch, 16)) ||
-      (GNUNET_OK != GNUNET_BIO_read_meta_data(rh, "result-meta", &sr->meta)) ||
-      (GNUNET_OK != GNUNET_BIO_read(rh,
-                                    "result-key",
-                                    &sr->key,
-                                    sizeof(struct GNUNET_HashCode))) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &sr->mandatory_missing)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &sr->optional_support)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &sr->availability_success)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &sr->availability_trials)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
+       GNUNET_BIO_read_string (rh, "search-lnk", &update_srch, 16)) ||
+      (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "result-meta", &sr->meta)) ||
+      (GNUNET_OK != GNUNET_BIO_read (rh,
+                                     "result-key",
+                                     &sr->key,
+                                     sizeof(struct GNUNET_HashCode))) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->mandatory_missing)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->optional_support)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->availability_success)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sr->availability_trials)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if (GNUNET_FS_URI_KSK == sr->sc->uri->type)
-    {
-      sr->keyword_bitmap = GNUNET_malloc(
-        (sr->sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */
-      if (GNUNET_OK !=
-          GNUNET_BIO_read(rh,
-                          "keyword-bitmap",
-                          sr->keyword_bitmap,
-                          (sr->sc->uri->data.ksk.keywordCount + 7) / 8))
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
+  {
+    sr->keyword_bitmap = GNUNET_malloc (
+      (sr->sc->uri->data.ksk.keywordCount + 7) / 8);   /* round up, count bits */
+    if (GNUNET_OK !=
+        GNUNET_BIO_read (rh,
+                         "keyword-bitmap",
+                         sr->keyword_bitmap,
+                         (sr->sc->uri->data.ksk.keywordCount + 7) / 8))
+    {
+      GNUNET_break (0);
+      goto cleanup;
     }
-  GNUNET_free(uris);
+  }
+  GNUNET_free (uris);
   if (NULL != download)
-    {
-      drh = get_read_handle(sc->h, GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD, download);
-      if (NULL != drh)
-        {
-          deserialize_download(sc->h, drh, NULL, sr, download);
-          if (GNUNET_OK != GNUNET_BIO_read_close(drh, &emsg))
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                         _("Failed to resume sub-download `%s': %s\n"),
-                         download,
-                         emsg);
-              GNUNET_free(emsg);
-            }
-        }
-      GNUNET_free(download);
-    }
+  {
+    drh = get_read_handle (sc->h, GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD, download);
+    if (NULL != drh)
+    {
+      deserialize_download (sc->h, drh, NULL, sr, download);
+      if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _ ("Failed to resume sub-download `%s': %s\n"),
+                    download,
+                    emsg);
+        GNUNET_free (emsg);
+      }
+    }
+    GNUNET_free (download);
+  }
   if (NULL != update_srch)
-    {
-      drh =
-        get_read_handle(sc->h, GNUNET_FS_SYNC_PATH_CHILD_SEARCH, update_srch);
-      if (NULL != drh)
-        {
-          deserialize_search(sc->h, drh, sr, update_srch);
-          if (GNUNET_OK != GNUNET_BIO_read_close(drh, &emsg))
-            {
-              GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                         _("Failed to resume sub-search `%s': %s\n"),
-                         update_srch,
-                         emsg);
-              GNUNET_free(emsg);
-            }
-        }
-      GNUNET_free(update_srch);
-    }
-  GNUNET_break(GNUNET_YES == GNUNET_CONTAINER_multihashmap_put(
-                 sc->master_result_map,
-                 &sr->key,
-                 sr,
-                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failure while resuming search operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+  {
+    drh =
+      get_read_handle (sc->h, GNUNET_FS_SYNC_PATH_CHILD_SEARCH, update_srch);
+    if (NULL != drh)
+    {
+      deserialize_search (sc->h, drh, sr, update_srch);
+      if (GNUNET_OK != GNUNET_BIO_read_close (drh, &emsg))
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                    _ ("Failed to resume sub-search `%s': %s\n"),
+                    update_srch,
+                    emsg);
+        GNUNET_free (emsg);
+      }
+    }
+    GNUNET_free (update_srch);
+  }
+  GNUNET_break (GNUNET_YES == GNUNET_CONTAINER_multihashmap_put (
+                  sc->master_result_map,
+                  &sr->key,
+                  sr,
+                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failure while resuming search operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   return GNUNET_OK;
 cleanup:
-  GNUNET_free_non_null(download);
-  GNUNET_free_non_null(emsg);
-  GNUNET_free_non_null(uris);
-  GNUNET_free_non_null(update_srch);
+  GNUNET_free_non_null (download);
+  GNUNET_free_non_null (emsg);
+  GNUNET_free_non_null (uris);
+  GNUNET_free_non_null (update_srch);
   if (NULL != sr->uri)
-    GNUNET_FS_uri_destroy(sr->uri);
+    GNUNET_FS_uri_destroy (sr->uri);
   if (NULL != sr->meta)
-    GNUNET_CONTAINER_meta_data_destroy(sr->meta);
-  GNUNET_free(sr->serialization);
-  GNUNET_free(sr);
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failure while resuming search operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+    GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_free (sr->serialization);
+  GNUNET_free (sr);
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failure while resuming search operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   return GNUNET_OK;
 }
 
@@ -2581,7 +2582,7 @@ cleanup:
  * @param dc download to resume
  */
 static void
-signal_download_resume(struct GNUNET_FS_DownloadContext *dc)
+signal_download_resume (struct GNUNET_FS_DownloadContext *dc)
 {
   struct GNUNET_FS_DownloadContext *dcc;
   struct GNUNET_FS_ProgressInfo pi;
@@ -2589,13 +2590,13 @@ signal_download_resume(struct GNUNET_FS_DownloadContext *dc)
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_RESUME;
   pi.value.download.specifics.resume.meta = dc->meta;
   pi.value.download.specifics.resume.message = dc->emsg;
-  GNUNET_FS_download_make_status_(&pi, dc);
+  GNUNET_FS_download_make_status_ (&pi, dc);
   dcc = dc->child_head;
   while (NULL != dcc)
-    {
-      signal_download_resume(dcc);
-      dcc = dcc->next;
-    }
+  {
+    signal_download_resume (dcc);
+    dcc = dcc->next;
+  }
 }
 
 
@@ -2606,7 +2607,7 @@ signal_download_resume(struct GNUNET_FS_DownloadContext *dc)
  * @param sc search being resumed
  */
 static void
-signal_search_resume(struct GNUNET_FS_SearchContext *sc);
+signal_search_resume (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -2619,36 +2620,36 @@ signal_search_resume(struct GNUNET_FS_SearchContext *sc);
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-signal_result_resume(void *cls, const struct GNUNET_HashCode *key, void *value)
+signal_result_resume (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   struct GNUNET_FS_SearchResult *sr = value;
 
   if (0 == sr->mandatory_missing)
-    {
-      pi.status = GNUNET_FS_STATUS_SEARCH_RESUME_RESULT;
-      pi.value.search.specifics.resume_result.meta = sr->meta;
-      pi.value.search.specifics.resume_result.uri = sr->uri;
-      pi.value.search.specifics.resume_result.result = sr;
-      pi.value.search.specifics.resume_result.availability_rank =
-        2 * sr->availability_success - sr->availability_trials;
-      pi.value.search.specifics.resume_result.availability_certainty =
-        sr->availability_trials;
-      pi.value.search.specifics.resume_result.applicability_rank =
-        sr->optional_support;
-      sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
-    }
+  {
+    pi.status = GNUNET_FS_STATUS_SEARCH_RESUME_RESULT;
+    pi.value.search.specifics.resume_result.meta = sr->meta;
+    pi.value.search.specifics.resume_result.uri = sr->uri;
+    pi.value.search.specifics.resume_result.result = sr;
+    pi.value.search.specifics.resume_result.availability_rank =
+      2 * sr->availability_success - sr->availability_trials;
+    pi.value.search.specifics.resume_result.availability_certainty =
+      sr->availability_trials;
+    pi.value.search.specifics.resume_result.applicability_rank =
+      sr->optional_support;
+    sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
+  }
   if (NULL != sr->download)
-    {
-      signal_download_resume(sr->download);
-    }
+  {
+    signal_download_resume (sr->download);
+  }
   else
-    {
-      GNUNET_FS_search_start_probe_(sr);
-    }
+  {
+    GNUNET_FS_search_start_probe_ (sr);
+  }
   if (NULL != sr->update_search)
-    signal_search_resume(sr->update_search);
+    signal_search_resume (sr->update_search);
   return GNUNET_YES;
 }
 
@@ -2659,7 +2660,7 @@ signal_result_resume(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @param sc search context to free
  */
 static void
-free_search_context(struct GNUNET_FS_SearchContext *sc);
+free_search_context (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -2671,18 +2672,18 @@ free_search_context(struct GNUNET_FS_SearchContext *sc);
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-free_result(void *cls, const struct GNUNET_HashCode *key, void *value)
+free_result (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
   if (NULL != sr->update_search)
-    {
-      free_search_context(sr->update_search);
-      GNUNET_assert(NULL == sr->update_search);
-    }
-  GNUNET_CONTAINER_meta_data_destroy(sr->meta);
-  GNUNET_FS_uri_destroy(sr->uri);
-  GNUNET_free(sr);
+  {
+    free_search_context (sr->update_search);
+    GNUNET_assert (NULL == sr->update_search);
+  }
+  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_FS_uri_destroy (sr->uri);
+  GNUNET_free (sr);
   return GNUNET_YES;
 }
 
@@ -2693,33 +2694,33 @@ free_result(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @param sc search context to free
  */
 static void
-free_search_context(struct GNUNET_FS_SearchContext *sc)
+free_search_context (struct GNUNET_FS_SearchContext *sc)
 {
   if (NULL != sc->serialization)
-    {
-      GNUNET_FS_remove_sync_file_(sc->h,
-                                  (sc->psearch_result == NULL)
-                                  ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                  : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                  sc->serialization);
-      GNUNET_FS_remove_sync_dir_(sc->h,
+  {
+    GNUNET_FS_remove_sync_file_ (sc->h,
                                  (sc->psearch_result == NULL)
                                  ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
                                  : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
                                  sc->serialization);
-    }
-  GNUNET_free_non_null(sc->serialization);
-  GNUNET_free_non_null(sc->emsg);
+    GNUNET_FS_remove_sync_dir_ (sc->h,
+                                (sc->psearch_result == NULL)
+                                ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                                : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                                sc->serialization);
+  }
+  GNUNET_free_non_null (sc->serialization);
+  GNUNET_free_non_null (sc->emsg);
   if (NULL != sc->uri)
-    GNUNET_FS_uri_destroy(sc->uri);
+    GNUNET_FS_uri_destroy (sc->uri);
   if (NULL != sc->master_result_map)
-    {
-      GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                            &free_result,
-                                            sc);
-      GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map);
-    }
-  GNUNET_free(sc);
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                           &free_result,
+                                           sc);
+    GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
+  }
+  GNUNET_free (sc);
 }
 
 
@@ -2732,35 +2733,35 @@ free_search_context(struct GNUNET_FS_SearchContext *sc)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-deserialize_subdownload(void *cls, const char *filename)
+deserialize_subdownload (void *cls, const char *filename)
 {
   struct GNUNET_FS_DownloadContext *parent = cls;
   char *ser;
   char *emsg;
   struct GNUNET_BIO_ReadHandle *rh;
 
-  ser = get_serialization_short_name(filename);
-  rh = GNUNET_BIO_read_open(filename);
+  ser = get_serialization_short_name (filename);
+  rh = GNUNET_BIO_read_open (filename);
   if (NULL == rh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _(
-                   "Failed to resume sub-download `%s': could not open file `%s'\n"),
-                 ser,
-                 filename);
-      GNUNET_free(ser);
-      return GNUNET_OK;
-    }
-  deserialize_download(parent->h, rh, parent, NULL, ser);
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failed to resume sub-download `%s': %s\n"),
-                 ser,
-                 emsg);
-      GNUNET_free(emsg);
-    }
-  GNUNET_free(ser);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "Failed to resume sub-download `%s': could not open file `%s'\n"),
+                ser,
+                filename);
+    GNUNET_free (ser);
+    return GNUNET_OK;
+  }
+  deserialize_download (parent->h, rh, parent, NULL, ser);
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to resume sub-download `%s': %s\n"),
+                ser,
+                emsg);
+    GNUNET_free (emsg);
+  }
+  GNUNET_free (ser);
   return GNUNET_OK;
 }
 
@@ -2773,27 +2774,27 @@ deserialize_subdownload(void *cls, const char *filename)
  * @param dc context to free
  */
 static void
-free_download_context(struct GNUNET_FS_DownloadContext *dc)
+free_download_context (struct GNUNET_FS_DownloadContext *dc)
 {
   struct GNUNET_FS_DownloadContext *dcc;
 
   if (NULL != dc->meta)
-    GNUNET_CONTAINER_meta_data_destroy(dc->meta);
+    GNUNET_CONTAINER_meta_data_destroy (dc->meta);
   if (NULL != dc->uri)
-    GNUNET_FS_uri_destroy(dc->uri);
-  GNUNET_free_non_null(dc->temp_filename);
-  GNUNET_free_non_null(dc->emsg);
-  GNUNET_free_non_null(dc->filename);
-  GNUNET_free_non_null(dc->serialization);
+    GNUNET_FS_uri_destroy (dc->uri);
+  GNUNET_free_non_null (dc->temp_filename);
+  GNUNET_free_non_null (dc->emsg);
+  GNUNET_free_non_null (dc->filename);
+  GNUNET_free_non_null (dc->serialization);
   while (NULL != (dcc = dc->child_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(dc->child_head, dc->child_tail, dcc);
-      free_download_context(dcc);
-    }
-  GNUNET_FS_free_download_request_(dc->top_request);
+  {
+    GNUNET_CONTAINER_DLL_remove (dc->child_head, dc->child_tail, dcc);
+    free_download_context (dcc);
+  }
+  GNUNET_FS_free_download_request_ (dc->top_request);
   if (NULL != dc->active)
-    GNUNET_CONTAINER_multihashmap_destroy(dc->active);
-  GNUNET_free(dc);
+    GNUNET_CONTAINER_multihashmap_destroy (dc->active);
+  GNUNET_free (dc);
 }
 
 
@@ -2807,11 +2808,11 @@ free_download_context(struct GNUNET_FS_DownloadContext *dc)
  * @param serialization name under which the search was serialized
  */
 static void
-deserialize_download(struct GNUNET_FS_Handle *h,
-                     struct GNUNET_BIO_ReadHandle *rh,
-                     struct GNUNET_FS_DownloadContext *parent,
-                     struct GNUNET_FS_SearchResult *search,
-                     const char *serialization)
+deserialize_download (struct GNUNET_FS_Handle *h,
+                      struct GNUNET_BIO_ReadHandle *rh,
+                      struct GNUNET_FS_DownloadContext *parent,
+                      struct GNUNET_FS_SearchResult *search,
+                      const char *serialization)
 {
   struct GNUNET_FS_DownloadContext *dc;
   char *emsg;
@@ -2822,86 +2823,86 @@ deserialize_download(struct GNUNET_FS_Handle *h,
 
   uris = NULL;
   emsg = NULL;
-  dc = GNUNET_new(struct GNUNET_FS_DownloadContext);
+  dc = GNUNET_new (struct GNUNET_FS_DownloadContext);
   dc->parent = parent;
   dc->h = h;
-  dc->serialization = GNUNET_strdup(serialization);
+  dc->serialization = GNUNET_strdup (serialization);
   if ((GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "download-uri", &uris, 10 * 1024)) ||
-      (NULL == (dc->uri = GNUNET_FS_uri_parse(uris, &emsg))) ||
-      ((GNUNET_YES != GNUNET_FS_uri_test_chk(dc->uri)) &&
-       (GNUNET_YES != GNUNET_FS_uri_test_loc(dc->uri))) ||
+       GNUNET_BIO_read_string (rh, "download-uri", &uris, 10 * 1024)) ||
+      (NULL == (dc->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
+      ((GNUNET_YES != GNUNET_FS_uri_test_chk (dc->uri)) &&
+       (GNUNET_YES != GNUNET_FS_uri_test_loc (dc->uri))) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_meta_data(rh, "download-meta", &dc->meta)) ||
+       GNUNET_BIO_read_meta_data (rh, "download-meta", &dc->meta)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "download-emsg", &dc->emsg, 10 * 1024)) ||
+       GNUNET_BIO_read_string (rh, "download-emsg", &dc->emsg, 10 * 1024)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "download-fn", &dc->filename, 10 * 1024)) ||
-      (GNUNET_OK != GNUNET_BIO_read_string(rh,
-                                           "download-tfn",
-                                           &dc->temp_filename,
-                                           10 * 1024)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int64(rh, &dc->old_file_size)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int64(rh, &dc->offset)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int64(rh, &dc->length)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int64(rh, &dc->completed)) ||
-      (GNUNET_OK != read_start_time(rh, &dc->start_time)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &dc->anonymity)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &options)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &status)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  dc->options = (enum GNUNET_FS_DownloadOptions)options;
+       GNUNET_BIO_read_string (rh, "download-fn", &dc->filename, 10 * 1024)) ||
+      (GNUNET_OK != GNUNET_BIO_read_string (rh,
+                                            "download-tfn",
+                                            &dc->temp_filename,
+                                            10 * 1024)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dc->old_file_size)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dc->offset)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dc->length)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dc->completed)) ||
+      (GNUNET_OK != read_start_time (rh, &dc->start_time)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &dc->anonymity)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &options)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &status)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  dc->options = (enum GNUNET_FS_DownloadOptions) options;
   dc->active =
-    GNUNET_CONTAINER_multihashmap_create(1 + 2 * (dc->length / DBLOCK_SIZE),
-                                         GNUNET_NO);
-  dc->has_finished = (int)status;
+    GNUNET_CONTAINER_multihashmap_create (1 + 2 * (dc->length / DBLOCK_SIZE),
+                                          GNUNET_NO);
+  dc->has_finished = (int) status;
   dc->treedepth =
-    GNUNET_FS_compute_depth(GNUNET_FS_uri_chk_get_file_size(dc->uri));
-  if (GNUNET_FS_uri_test_loc(dc->uri))
-    GNUNET_assert(GNUNET_OK ==
-                  GNUNET_FS_uri_loc_get_peer_identity(dc->uri, &dc->target));
+    GNUNET_FS_compute_depth (GNUNET_FS_uri_chk_get_file_size (dc->uri));
+  if (GNUNET_FS_uri_test_loc (dc->uri))
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_FS_uri_loc_get_peer_identity (dc->uri, &dc->target));
   if (NULL == dc->emsg)
+  {
+    dc->top_request = read_download_request (rh);
+    if (NULL == dc->top_request)
     {
-      dc->top_request = read_download_request(rh);
-      if (NULL == dc->top_request)
-        {
-          GNUNET_break(0);
-          goto cleanup;
-        }
+      GNUNET_break (0);
+      goto cleanup;
     }
-  dn = get_download_sync_filename(dc, dc->serialization, ".dir");
+  }
+  dn = get_download_sync_filename (dc, dc->serialization, ".dir");
   if (NULL != dn)
-    {
-      if (GNUNET_YES == GNUNET_DISK_directory_test(dn, GNUNET_YES))
-        GNUNET_DISK_directory_scan(dn, &deserialize_subdownload, dc);
-      GNUNET_free(dn);
-    }
+  {
+    if (GNUNET_YES == GNUNET_DISK_directory_test (dn, GNUNET_YES))
+      GNUNET_DISK_directory_scan (dn, &deserialize_subdownload, dc);
+    GNUNET_free (dn);
+  }
   if (NULL != parent)
-    {
-      GNUNET_CONTAINER_DLL_insert(parent->child_head, parent->child_tail, dc);
-    }
+  {
+    GNUNET_CONTAINER_DLL_insert (parent->child_head, parent->child_tail, dc);
+  }
   if (NULL != search)
-    {
-      dc->search = search;
-      search->download = dc;
-    }
+  {
+    dc->search = search;
+    search->download = dc;
+  }
   if ((NULL == parent) && (NULL == search))
-    {
-      dc->top =
-        GNUNET_FS_make_top(dc->h, &GNUNET_FS_download_signal_suspend_, dc);
-      signal_download_resume(dc);
-    }
-  GNUNET_free(uris);
-  GNUNET_assert(NULL == dc->job_queue);
-  dc->task = GNUNET_SCHEDULER_add_now(&GNUNET_FS_download_start_task_, dc);
+  {
+    dc->top =
+      GNUNET_FS_make_top (dc->h, &GNUNET_FS_download_signal_suspend_, dc);
+    signal_download_resume (dc);
+  }
+  GNUNET_free (uris);
+  GNUNET_assert (NULL == dc->job_queue);
+  dc->task = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, dc);
   return;
 cleanup:
-  GNUNET_free_non_null(uris);
-  GNUNET_free_non_null(emsg);
-  free_download_context(dc);
+  GNUNET_free_non_null (uris);
+  GNUNET_free_non_null (emsg);
+  free_download_context (dc);
 }
 
 
@@ -2912,7 +2913,7 @@ cleanup:
  * @param sc search being resumed
  */
 static void
-signal_search_resume(struct GNUNET_FS_SearchContext *sc)
+signal_search_resume (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
@@ -2920,10 +2921,10 @@ signal_search_resume(struct GNUNET_FS_SearchContext *sc)
   pi.value.search.specifics.resume.message = sc->emsg;
   pi.value.search.specifics.resume.is_paused =
     (NULL == sc->mq) ? GNUNET_YES : GNUNET_NO;
-  sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
-  GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                        &signal_result_resume,
-                                        sc);
+  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
+  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                         &signal_result_resume,
+                                         sc);
 }
 
 
@@ -2936,10 +2937,10 @@ signal_search_resume(struct GNUNET_FS_SearchContext *sc)
  * @param serialization name under which the search was serialized
  */
 static struct GNUNET_FS_SearchContext *
-deserialize_search(struct GNUNET_FS_Handle *h,
-                   struct GNUNET_BIO_ReadHandle *rh,
-                   struct GNUNET_FS_SearchResult *psearch_result,
-                   const char *serialization)
+deserialize_search (struct GNUNET_FS_Handle *h,
+                    struct GNUNET_BIO_ReadHandle *rh,
+                    struct GNUNET_FS_SearchResult *psearch_result,
+                    const char *serialization)
 {
   struct GNUNET_FS_SearchContext *sc;
   char *emsg;
@@ -2949,64 +2950,64 @@ deserialize_search(struct GNUNET_FS_Handle *h,
   char in_pause;
 
   if ((NULL != psearch_result) && (NULL != psearch_result->update_search))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   uris = NULL;
   emsg = NULL;
-  sc = GNUNET_new(struct GNUNET_FS_SearchContext);
+  sc = GNUNET_new (struct GNUNET_FS_SearchContext);
   if (NULL != psearch_result)
-    {
-      sc->psearch_result = psearch_result;
-      psearch_result->update_search = sc;
-    }
+  {
+    sc->psearch_result = psearch_result;
+    psearch_result->update_search = sc;
+  }
   sc->h = h;
-  sc->serialization = GNUNET_strdup(serialization);
+  sc->serialization = GNUNET_strdup (serialization);
   if ((GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "search-uri", &uris, 10 * 1024)) ||
-      (NULL == (sc->uri = GNUNET_FS_uri_parse(uris, &emsg))) ||
-      ((GNUNET_YES != GNUNET_FS_uri_test_ksk(sc->uri)) &&
-       (GNUNET_YES != GNUNET_FS_uri_test_sks(sc->uri))) ||
-      (GNUNET_OK != read_start_time(rh, &sc->start_time)) ||
+       GNUNET_BIO_read_string (rh, "search-uri", &uris, 10 * 1024)) ||
+      (NULL == (sc->uri = GNUNET_FS_uri_parse (uris, &emsg))) ||
+      ((GNUNET_YES != GNUNET_FS_uri_test_ksk (sc->uri)) &&
+       (GNUNET_YES != GNUNET_FS_uri_test_sks (sc->uri))) ||
+      (GNUNET_OK != read_start_time (rh, &sc->start_time)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read_string(rh, "search-emsg", &sc->emsg, 10 * 1024)) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &options)) ||
+       GNUNET_BIO_read_string (rh, "search-emsg", &sc->emsg, 10 * 1024)) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &options)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_read(rh, "search-pause", &in_pause, sizeof(in_pause))) ||
-      (GNUNET_OK != GNUNET_BIO_read_int32(rh, &sc->anonymity)))
-    {
-      GNUNET_break(0);
-      goto cleanup;
-    }
-  sc->options = (enum GNUNET_FS_SearchOptions)options;
-  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create(16, GNUNET_NO);
-  dn = get_serialization_file_name_in_dir(h,
-                                          (NULL == sc->psearch_result)
-                                          ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                          : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                          sc->serialization,
-                                          "");
+       GNUNET_BIO_read (rh, "search-pause", &in_pause, sizeof(in_pause))) ||
+      (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &sc->anonymity)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  sc->options = (enum GNUNET_FS_SearchOptions) options;
+  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
+  dn = get_serialization_file_name_in_dir (h,
+                                           (NULL == sc->psearch_result)
+                                           ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                                           : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                                           sc->serialization,
+                                           "");
   if (NULL != dn)
-    {
-      if (GNUNET_YES == GNUNET_DISK_directory_test(dn, GNUNET_YES))
-        GNUNET_DISK_directory_scan(dn, &deserialize_search_result, sc);
-      GNUNET_free(dn);
-    }
+  {
+    if (GNUNET_YES == GNUNET_DISK_directory_test (dn, GNUNET_YES))
+      GNUNET_DISK_directory_scan (dn, &deserialize_search_result, sc);
+    GNUNET_free (dn);
+  }
   if (('\0' == in_pause) &&
-      (GNUNET_OK != GNUNET_FS_search_start_searching_(sc)))
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_WARNING,
-        _("Could not resume running search, will resume as paused search\n"));
-    }
-  signal_search_resume(sc);
-  GNUNET_free(uris);
+      (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc)))
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_WARNING,
+      _ ("Could not resume running search, will resume as paused search\n"));
+  }
+  signal_search_resume (sc);
+  GNUNET_free (uris);
   return sc;
 cleanup:
-  GNUNET_free_non_null(emsg);
-  free_search_context(sc);
-  GNUNET_free_non_null(uris);
+  GNUNET_free_non_null (emsg);
+  free_search_context (sc);
+  GNUNET_free_non_null (uris);
   return NULL;
 }
 
@@ -3020,7 +3021,7 @@ cleanup:
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-deserialize_search_file(void *cls, const char *filename)
+deserialize_search_file (void *cls, const char *filename)
 {
   struct GNUNET_FS_Handle *h = cls;
   char *ser;
@@ -3029,36 +3030,36 @@ deserialize_search_file(void *cls, const char *filename)
   struct GNUNET_FS_SearchContext *sc;
   struct stat buf;
 
-  if (0 != stat(filename, &buf))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "stat", filename);
-      return GNUNET_OK;
-    }
-  if (S_ISDIR(buf.st_mode))
+  if (0 != stat (filename, &buf))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+    return GNUNET_OK;
+  }
+  if (S_ISDIR (buf.st_mode))
     return GNUNET_OK; /* skip directories */
-  ser = get_serialization_short_name(filename);
-  rh = GNUNET_BIO_read_open(filename);
+  ser = get_serialization_short_name (filename);
+  rh = GNUNET_BIO_read_open (filename);
   if (NULL == rh)
+  {
+    if (NULL != ser)
     {
-      if (NULL != ser)
-        {
-          GNUNET_FS_remove_sync_file_(h, GNUNET_FS_SYNC_PATH_MASTER_SEARCH, ser);
-          GNUNET_free(ser);
-        }
-      return GNUNET_OK;
+      GNUNET_FS_remove_sync_file_ (h, GNUNET_FS_SYNC_PATH_MASTER_SEARCH, ser);
+      GNUNET_free (ser);
     }
-  sc = deserialize_search(h, rh, NULL, ser);
+    return GNUNET_OK;
+  }
+  sc = deserialize_search (h, rh, NULL, ser);
   if (NULL != sc)
-    sc->top = GNUNET_FS_make_top(h, &GNUNET_FS_search_signal_suspend_, sc);
-  GNUNET_free(ser);
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failure while resuming search operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+    sc->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, sc);
+  GNUNET_free (ser);
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failure while resuming search operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   return GNUNET_OK;
 }
 
@@ -3072,32 +3073,32 @@ deserialize_search_file(void *cls, const char *filename)
  * @return #GNUNET_OK (continue to iterate)
  */
 static int
-deserialize_download_file(void *cls, const char *filename)
+deserialize_download_file (void *cls, const char *filename)
 {
   struct GNUNET_FS_Handle *h = cls;
   char *ser;
   char *emsg;
   struct GNUNET_BIO_ReadHandle *rh;
 
-  ser = get_serialization_short_name(filename);
-  rh = GNUNET_BIO_read_open(filename);
+  ser = get_serialization_short_name (filename);
+  rh = GNUNET_BIO_read_open (filename);
   if (NULL == rh)
-    {
-      if (0 != unlink(filename))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
-      GNUNET_free(ser);
-      return GNUNET_OK;
-    }
-  deserialize_download(h, rh, NULL, NULL, ser);
-  GNUNET_free(ser);
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failure while resuming download operation `%s': %s\n"),
-                 filename,
-                 emsg);
-      GNUNET_free(emsg);
-    }
+  {
+    if (0 != unlink (filename))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
+    GNUNET_free (ser);
+    return GNUNET_OK;
+  }
+  deserialize_download (h, rh, NULL, NULL, ser);
+  GNUNET_free (ser);
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failure while resuming download operation `%s': %s\n"),
+                filename,
+                emsg);
+    GNUNET_free (emsg);
+  }
   return GNUNET_OK;
 }
 
@@ -3110,18 +3111,18 @@ deserialize_download_file(void *cls, const char *filename)
  * @param h the `struct GNUNET_FS_Handle *`
  */
 static void
-deserialization_master(const char *master_path,
-                       GNUNET_FileNameCallback proc,
-                       struct GNUNET_FS_Handle *h)
+deserialization_master (const char *master_path,
+                        GNUNET_FileNameCallback proc,
+                        struct GNUNET_FS_Handle *h)
 {
   char *dn;
 
-  dn = get_serialization_file_name(h, master_path, "");
+  dn = get_serialization_file_name (h, master_path, "");
   if (NULL == dn)
     return;
-  if (GNUNET_YES == GNUNET_DISK_directory_test(dn, GNUNET_YES))
-    GNUNET_DISK_directory_scan(dn, proc, h);
-  GNUNET_free(dn);
+  if (GNUNET_YES == GNUNET_DISK_directory_test (dn, GNUNET_YES))
+    GNUNET_DISK_directory_scan (dn, proc, h);
+  GNUNET_free (dn);
 }
 
 
@@ -3137,20 +3138,20 @@ deserialization_master(const char *master_path,
  * @return NULL on error
  */
 struct GNUNET_FS_Handle *
-GNUNET_FS_start(const struct GNUNET_CONFIGURATION_Handle *cfg,
-                const char *client_name,
-                GNUNET_FS_ProgressCallback upcb,
-                void *upcb_cls,
-                enum GNUNET_FS_Flags flags,
-                ...)
+GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
+                 const char *client_name,
+                 GNUNET_FS_ProgressCallback upcb,
+                 void *upcb_cls,
+                 enum GNUNET_FS_Flags flags,
+                 ...)
 {
   struct GNUNET_FS_Handle *ret;
   enum GNUNET_FS_OPTIONS opt;
   va_list ap;
 
-  ret = GNUNET_new(struct GNUNET_FS_Handle);
+  ret = GNUNET_new (struct GNUNET_FS_Handle);
   ret->cfg = cfg;
-  ret->client_name = GNUNET_strdup(client_name);
+  ret->client_name = GNUNET_strdup (client_name);
   ret->upcb = upcb;
   ret->upcb_cls = upcb_cls;
   ret->flags = flags;
@@ -3158,46 +3159,46 @@ GNUNET_FS_start(const struct GNUNET_CONFIGURATION_Handle *cfg,
   ret->max_parallel_requests = DEFAULT_MAX_PARALLEL_REQUESTS;
   ret->avg_block_latency =
     GNUNET_TIME_UNIT_MINUTES; /* conservative starting point */
-  va_start(ap, flags);
+  va_start (ap, flags);
   while (GNUNET_FS_OPTIONS_END !=
-         (opt = GNUNET_VA_ARG_ENUM(ap, GNUNET_FS_OPTIONS)))
+         (opt = GNUNET_VA_ARG_ENUM (ap, GNUNET_FS_OPTIONS)))
+  {
+    switch (opt)
     {
-      switch (opt)
-        {
-        case GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM:
-          ret->max_parallel_downloads = va_arg(ap, unsigned int);
+    case GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM:
+      ret->max_parallel_downloads = va_arg (ap, unsigned int);
 
-          break;
+      break;
 
-        case GNUNET_FS_OPTIONS_REQUEST_PARALLELISM:
-          ret->max_parallel_requests = va_arg(ap, unsigned int);
+    case GNUNET_FS_OPTIONS_REQUEST_PARALLELISM:
+      ret->max_parallel_requests = va_arg (ap, unsigned int);
 
-          break;
+      break;
 
-        default:
-          GNUNET_break(0);
-          GNUNET_free(ret->client_name);
-          GNUNET_free(ret);
-          va_end(ap);
-          return NULL;
-        }
+    default:
+      GNUNET_break (0);
+      GNUNET_free (ret->client_name);
+      GNUNET_free (ret);
+      va_end (ap);
+      return NULL;
     }
-  va_end(ap);
+  }
+  va_end (ap);
   if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & flags))
-    {
-      deserialization_master(GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
-                             &deserialize_publish_file,
-                             ret);
-      deserialization_master(GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
-                             &deserialize_search_file,
-                             ret);
-      deserialization_master(GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
-                             &deserialize_download_file,
-                             ret);
-      deserialization_master(GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
-                             &deserialize_unindex_file,
-                             ret);
-    }
+  {
+    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
+                            &deserialize_publish_file,
+                            ret);
+    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
+                            &deserialize_search_file,
+                            ret);
+    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
+                            &deserialize_download_file,
+                            ret);
+    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
+                            &deserialize_unindex_file,
+                            ret);
+  }
   return ret;
 }
 
@@ -3212,14 +3213,14 @@ GNUNET_FS_start(const struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param h handle that was returned from #GNUNET_FS_start()
  */
 void
-GNUNET_FS_stop(struct GNUNET_FS_Handle *h)
+GNUNET_FS_stop (struct GNUNET_FS_Handle *h)
 {
   while (NULL != h->top_head)
-    h->top_head->ssf(h->top_head->ssf_cls);
+    h->top_head->ssf (h->top_head->ssf_cls);
   if (NULL != h->queue_job)
-    GNUNET_SCHEDULER_cancel(h->queue_job);
-  GNUNET_free(h->client_name);
-  GNUNET_free(h);
+    GNUNET_SCHEDULER_cancel (h->queue_job);
+  GNUNET_free (h->client_name);
+  GNUNET_free (h);
 }
 
 
diff --git a/src/fs/fs_api.h b/src/fs/fs_api.h
index dcc487eb1..f7eb40b42 100644
--- a/src/fs/fs_api.h
+++ b/src/fs/fs_api.h
@@ -90,7 +90,8 @@
  * @brief complete information needed
  * to download a file.
  */
-struct FileIdentifier {
+struct FileIdentifier
+{
   /**
    * Total size of the file in bytes. (network byte order (!))
    */
@@ -107,7 +108,8 @@ struct FileIdentifier {
  * Information about a file and its location
  * (peer claiming to share the file).
  */
-struct Location {
+struct Location
+{
   /**
    * Information about the shared file.
    */
@@ -133,7 +135,8 @@ struct Location {
 /**
  * Types of URIs.
  */
-enum GNUNET_FS_UriType {
+enum GNUNET_FS_UriType
+{
   /**
    * Content-hash-key (simple file).
    */
@@ -159,14 +162,17 @@ enum GNUNET_FS_UriType {
 /**
  * A Universal Resource Identifier (URI), opaque.
  */
-struct GNUNET_FS_Uri {
+struct GNUNET_FS_Uri
+{
   /**
    * Type of the URI.
    */
   enum GNUNET_FS_UriType type;
 
-  union {
-    struct {
+  union
+  {
+    struct
+    {
       /**
        * Keywords start with a '+' if they are mandatory (in which
        * case the '+' is NOT part of the keyword) and with a simple
@@ -184,7 +190,8 @@ struct GNUNET_FS_Uri {
       unsigned int keywordCount;
     } ksk;
 
-    struct {
+    struct
+    {
       /**
        * Identifier of the namespace.
        */
@@ -216,7 +223,8 @@ struct GNUNET_FS_Uri {
  * Information for a file or directory that is
  * about to be published.
  */
-struct GNUNET_FS_FileInformation {
+struct GNUNET_FS_FileInformation
+{
   /**
    * Files in a directory are kept as a linked list.
    */
@@ -295,11 +303,13 @@ struct GNUNET_FS_FileInformation {
   /**
    * Data describing either the file or the directory.
    */
-  union {
+  union
+  {
     /**
      * Data for a file.
      */
-    struct {
+    struct
+    {
       /**
        * Function that can be used to read the data for the file.
        */
@@ -343,7 +353,8 @@ struct GNUNET_FS_FileInformation {
     /**
      * Data for a directory.
      */
-    struct {
+    struct
+    {
       /**
        * Linked list of entries in the directory.
        */
@@ -388,7 +399,8 @@ struct GNUNET_FS_FileInformation {
 /**
  * Priorities for the queue.
  */
-enum GNUNET_FS_QueuePriority {
+enum GNUNET_FS_QueuePriority
+{
   /**
    * This is a probe (low priority).
    */
@@ -404,7 +416,8 @@ enum GNUNET_FS_QueuePriority {
 /**
  * Entry in the job queue.
  */
-struct GNUNET_FS_QueueEntry {
+struct GNUNET_FS_QueueEntry
+{
   /**
    * This is a linked list.
    */
@@ -481,7 +494,8 @@ struct GNUNET_FS_QueueEntry {
 /**
  * Information we store for each search result.
  */
-struct GNUNET_FS_SearchResult {
+struct GNUNET_FS_SearchResult
+{
   /**
    * File-sharing context this result belongs to.
    */
@@ -556,7 +570,7 @@ struct GNUNET_FS_SearchResult {
    * complete on time (and that will need to be cancelled if we clean
    * up the search result before then).
    */
-  struct GNUNET_SCHEDULER_Task * probe_cancel_task;
+  struct GNUNET_SCHEDULER_Task *probe_cancel_task;
 
   /**
    * When did the current probe become active?
@@ -611,12 +625,12 @@ struct GNUNET_FS_SearchResult {
  * @return queue handle
  */
 struct GNUNET_FS_QueueEntry *
-GNUNET_FS_queue_(struct GNUNET_FS_Handle *h,
-                 GNUNET_SCHEDULER_TaskCallback start,
-                 GNUNET_SCHEDULER_TaskCallback stop,
-                 void *cls,
-                 unsigned int blocks,
-                 enum GNUNET_FS_QueuePriority priority);
+GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
+                  GNUNET_SCHEDULER_TaskCallback start,
+                  GNUNET_SCHEDULER_TaskCallback stop,
+                  void *cls,
+                  unsigned int blocks,
+                  enum GNUNET_FS_QueuePriority priority);
 
 
 /**
@@ -625,7 +639,7 @@ GNUNET_FS_queue_(struct GNUNET_FS_Handle *h,
  * @param qe handle for the job
  */
 void
-GNUNET_FS_dequeue_(struct GNUNET_FS_QueueEntry *qe);
+GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qe);
 
 
 /**
@@ -645,11 +659,11 @@ GNUNET_FS_dequeue_(struct GNUNET_FS_QueueEntry *qe);
  * @return number of bytes written, usually "max", 0 on error
  */
 size_t
-GNUNET_FS_data_reader_file_(void *cls,
-                            uint64_t offset,
-                            size_t max,
-                            void *buf,
-                            char **emsg);
+GNUNET_FS_data_reader_file_ (void *cls,
+                             uint64_t offset,
+                             size_t max,
+                             void *buf,
+                             char **emsg);
 
 
 /**
@@ -659,7 +673,7 @@ GNUNET_FS_data_reader_file_(void *cls,
  * @return closure to use
  */
 void *
-GNUNET_FS_make_file_reader_context_(const char *filename);
+GNUNET_FS_make_file_reader_context_ (const char *filename);
 
 
 
@@ -680,11 +694,11 @@ GNUNET_FS_make_file_reader_context_(const char *filename);
  * @return number of bytes written, usually @a max, 0 on error
  */
 size_t
-GNUNET_FS_data_reader_copy_(void *cls,
-                            uint64_t offset,
-                            size_t max,
-                            void *buf,
-                            char **emsg);
+GNUNET_FS_data_reader_copy_ (void *cls,
+                             uint64_t offset,
+                             size_t max,
+                             void *buf,
+                             char **emsg);
 
 
 /**
@@ -703,8 +717,8 @@ GNUNET_FS_data_reader_copy_(void *cls,
  *         field in the `struct GNUNET_FS_ProgressInfo`.
  */
 void *
-GNUNET_FS_search_probe_progress_(void *cls,
-                                 const struct GNUNET_FS_ProgressInfo *info);
+GNUNET_FS_search_probe_progress_ (void *cls,
+                                  const struct GNUNET_FS_ProgressInfo *info);
 
 
 /**
@@ -713,7 +727,7 @@ GNUNET_FS_search_probe_progress_(void *cls,
  * @param cls `struct GNUNET_FS_PublishContext` identifies the upload
  */
 void
-GNUNET_FS_publish_main_(void *cls);
+GNUNET_FS_publish_main_ (void *cls);
 
 
 /**
@@ -724,8 +738,8 @@ GNUNET_FS_publish_main_(void *cls);
  * @param file_id computed hash, NULL on error
  */
 void
-GNUNET_FS_unindex_process_hash_(void *cls,
-                                const struct GNUNET_HashCode *file_id);
+GNUNET_FS_unindex_process_hash_ (void *cls,
+                                 const struct GNUNET_HashCode *file_id);
 
 
 /**
@@ -734,7 +748,7 @@ GNUNET_FS_unindex_process_hash_(void *cls,
  * @param uc context for the unindex operation.
  */
 void
-GNUNET_FS_unindex_do_extract_keywords_(struct GNUNET_FS_UnindexContext *uc);
+GNUNET_FS_unindex_do_extract_keywords_ (struct GNUNET_FS_UnindexContext *uc);
 
 
 /**
@@ -743,7 +757,7 @@ GNUNET_FS_unindex_do_extract_keywords_(struct GNUNET_FS_UnindexContext *uc);
  * @param uc context for the unindex operation.
  */
 void
-GNUNET_FS_unindex_do_remove_kblocks_(struct GNUNET_FS_UnindexContext *uc);
+GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc);
 
 
 /**
@@ -757,10 +771,10 @@ GNUNET_FS_unindex_do_remove_kblocks_(struct GNUNET_FS_UnindexContext *uc);
  * @return value returned from callback
  */
 void *
-GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                               struct GNUNET_FS_PublishContext *pc,
-                               const struct GNUNET_FS_FileInformation *p,
-                               uint64_t offset);
+GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                struct GNUNET_FS_PublishContext *pc,
+                                const struct GNUNET_FS_FileInformation *p,
+                                uint64_t offset);
 
 
 /**
@@ -771,8 +785,8 @@ GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi,
  * @param dc overall download context
  */
 void
-GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                                struct GNUNET_FS_DownloadContext *dc);
+GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                 struct GNUNET_FS_DownloadContext *dc);
 
 
 /**
@@ -782,7 +796,7 @@ GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi,
  * @param cls the 'struct GNUNET_FS_DownloadContext'
  */
 void
-GNUNET_FS_download_start_task_(void *cls);
+GNUNET_FS_download_start_task_ (void *cls);
 
 
 
@@ -795,9 +809,9 @@ GNUNET_FS_download_start_task_(void *cls);
  * @param offset where we are in the file (for progress)
  */
 void
-GNUNET_FS_unindex_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                               struct GNUNET_FS_UnindexContext *uc,
-                               uint64_t offset);
+GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                struct GNUNET_FS_UnindexContext *uc,
+                                uint64_t offset);
 
 /**
  * Fill in all of the generic fields for a search event and
@@ -809,9 +823,9 @@ GNUNET_FS_unindex_make_status_(struct GNUNET_FS_ProgressInfo *pi,
  * @return value returned by the callback
  */
 void *
-GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                              struct GNUNET_FS_Handle *h,
-                              struct GNUNET_FS_SearchContext *sc);
+GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                               struct GNUNET_FS_Handle *h,
+                               struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -820,7 +834,7 @@ GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi,
  * @param uc context for the unindex operation.
  */
 void
-GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc);
+GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc);
 
 /**
  * Build the request and actually initiate the search using the
@@ -830,7 +844,7 @@ GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc);
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
 int
-GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc);
+GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc);
 
 /**
  * Start the downloading process (by entering the queue).
@@ -838,7 +852,7 @@ GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc);
  * @param dc our download context
  */
 void
-GNUNET_FS_download_start_downloading_(struct GNUNET_FS_DownloadContext *dc);
+GNUNET_FS_download_start_downloading_ (struct GNUNET_FS_DownloadContext *dc);
 
 
 /**
@@ -847,7 +861,7 @@ GNUNET_FS_download_start_downloading_(struct GNUNET_FS_DownloadContext *dc);
  * @param sr the search result
  */
 void
-GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr);
+GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr);
 
 
 /**
@@ -858,9 +872,9 @@ GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr);
  * @param ent entity identifier
  */
 void
-GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h,
-                            const char *ext,
-                            const char *ent);
+GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
+                             const char *ext,
+                             const char *ent);
 
 
 /**
@@ -871,9 +885,9 @@ GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h,
  * @param uni unique name of parent
  */
 void
-GNUNET_FS_remove_sync_dir_(struct GNUNET_FS_Handle *h,
-                           const char *ext,
-                           const char *uni);
+GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
+                            const char *ext,
+                            const char *uni);
 
 
 /**
@@ -885,7 +899,7 @@ GNUNET_FS_remove_sync_dir_(struct GNUNET_FS_Handle *h,
  * @param fi the struct to sync
  */
 void
-GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *f);
+GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *f);
 
 
 /**
@@ -897,7 +911,7 @@ GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *f);
  * @param pc the struct to sync
  */
 void
-GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc);
+GNUNET_FS_publish_sync_ (struct GNUNET_FS_PublishContext *pc);
 
 
 /**
@@ -909,7 +923,7 @@ GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc);
  * @param uc the struct to sync
  */
 void
-GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc);
+GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc);
 
 
 /**
@@ -921,7 +935,7 @@ GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc);
  * @param sc the struct to sync
  */
 void
-GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc);
+GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -933,7 +947,7 @@ GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc);
  * @param sr the struct to sync
  */
 void
-GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr);
+GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr);
 
 
 /**
@@ -945,7 +959,7 @@ GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr);
  * @param dc the struct to sync
  */
 void
-GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc);
+GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc);
 
 
 /**
@@ -955,7 +969,7 @@ GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc);
  * @param cls the `struct GNUNET_FS_PublishContext` to signal for
  */
 void
-GNUNET_FS_publish_signal_suspend_(void *cls);
+GNUNET_FS_publish_signal_suspend_ (void *cls);
 
 
 /**
@@ -965,7 +979,7 @@ GNUNET_FS_publish_signal_suspend_(void *cls);
  * @param cls the 'struct GNUNET_FS_SearchContext' to signal for
  */
 void
-GNUNET_FS_search_signal_suspend_(void *cls);
+GNUNET_FS_search_signal_suspend_ (void *cls);
 
 
 /**
@@ -975,7 +989,7 @@ GNUNET_FS_search_signal_suspend_(void *cls);
  * @param cls the `struct GNUNET_FS_DownloadContext` to signal for
  */
 void
-GNUNET_FS_download_signal_suspend_(void *cls);
+GNUNET_FS_download_signal_suspend_ (void *cls);
 
 
 /**
@@ -985,7 +999,7 @@ GNUNET_FS_download_signal_suspend_(void *cls);
  * @param cls the `struct GNUNET_FS_UnindexContext` to signal for
  */
 void
-GNUNET_FS_unindex_signal_suspend_(void *cls);
+GNUNET_FS_unindex_signal_suspend_ (void *cls);
 
 
 /**
@@ -1001,7 +1015,8 @@ typedef void (*SuspendSignalFunction) (void *cls);
  * We track all of the top-level activities of FS
  * so that we can signal 'suspend' on shutdown.
  */
-struct TopLevelActivity {
+struct TopLevelActivity
+{
   /**
    * This is a doubly-linked list.
    */
@@ -1033,9 +1048,9 @@ struct TopLevelActivity {
  * @return fresh top-level activity handle
  */
 struct TopLevelActivity *
-GNUNET_FS_make_top(struct GNUNET_FS_Handle *h,
-                   SuspendSignalFunction ssf,
-                   void *ssf_cls);
+GNUNET_FS_make_top (struct GNUNET_FS_Handle *h,
+                    SuspendSignalFunction ssf,
+                    void *ssf_cls);
 
 
 /**
@@ -1045,15 +1060,16 @@ GNUNET_FS_make_top(struct GNUNET_FS_Handle *h,
  * @param top top level activity entry
  */
 void
-GNUNET_FS_end_top(struct GNUNET_FS_Handle *h,
-                  struct TopLevelActivity *top);
+GNUNET_FS_end_top (struct GNUNET_FS_Handle *h,
+                   struct TopLevelActivity *top);
 
 
 
 /**
  * Master context for most FS operations.
  */
-struct GNUNET_FS_Handle {
+struct GNUNET_FS_Handle
+{
   /**
    * Configuration to use.
    */
@@ -1118,13 +1134,13 @@ struct GNUNET_FS_Handle {
    * Task that processes the jobs in the running and pending queues
    * (and moves jobs around as needed).
    */
-  struct GNUNET_SCHEDULER_Task * queue_job;
+  struct GNUNET_SCHEDULER_Task *queue_job;
 
   /**
    * Task we use to report periodically to the application that
    * certain search probes (from @e probes_head) are still running.
    */
-  struct GNUNET_SCHEDULER_Task * probe_ping_task;
+  struct GNUNET_SCHEDULER_Task *probe_ping_task;
 
   /**
    * Average time we take for a single request to be satisfied.
@@ -1162,7 +1178,8 @@ struct GNUNET_FS_Handle {
 /**
  * Handle for controlling a publication process.
  */
-struct GNUNET_FS_PublishContext {
+struct GNUNET_FS_PublishContext
+{
   /**
    * Handle to the global fs context.
    */
@@ -1241,7 +1258,7 @@ struct GNUNET_FS_PublishContext {
    * ID of the task performing the upload. NO_TASK if the upload has
    * completed.
    */
-  struct GNUNET_SCHEDULER_Task * upload_task;
+  struct GNUNET_SCHEDULER_Task *upload_task;
 
   /**
    * Storage space to reserve for the operation.
@@ -1288,7 +1305,8 @@ struct GNUNET_FS_PublishContext {
 /**
  * Phases of unindex processing (state machine).
  */
-enum UnindexState {
+enum UnindexState
+{
   /**
    * We're currently hashing the file.
    */
@@ -1331,7 +1349,8 @@ enum UnindexState {
 /**
  * Handle for controlling an unindexing operation.
  */
-struct GNUNET_FS_UnindexContext {
+struct GNUNET_FS_UnindexContext
+{
   /**
    * The content hash key of the last block we processed, will in the
    * end be set to the CHK from the URI.  Used to remove the KBlocks.
@@ -1451,7 +1470,8 @@ struct GNUNET_FS_UnindexContext {
 /**
  * Information we keep for each keyword in a keyword search.
  */
-struct SearchRequestEntry {
+struct SearchRequestEntry
+{
   /**
    * Hash of the public key, also known as the query.
    */
@@ -1489,7 +1509,8 @@ struct SearchRequestEntry {
 /**
  * Handle for controlling a search.
  */
-struct GNUNET_FS_SearchContext {
+struct GNUNET_FS_SearchContext
+{
   /**
    * Handle to the global FS context.
    */
@@ -1585,7 +1606,8 @@ struct GNUNET_FS_SearchContext {
  * order of progression is linear through the states, alternatives
  * are documented in the comments.
  */
-enum BlockRequestState {
+enum BlockRequestState
+{
   /**
    * Initial state, block has only been allocated (since it is
    * relevant to the overall download request).
@@ -1652,7 +1674,8 @@ enum BlockRequestState {
 /**
  * Information about an active download request.
  */
-struct DownloadRequest {
+struct DownloadRequest
+{
   /**
    * Parent in the CHK-tree.
    */
@@ -1704,7 +1727,7 @@ struct DownloadRequest {
  * @param dr request to free
  */
 void
-GNUNET_FS_free_download_request_(struct DownloadRequest *dr);
+GNUNET_FS_free_download_request_ (struct DownloadRequest *dr);
 
 
 /**
@@ -1713,13 +1736,14 @@ GNUNET_FS_free_download_request_(struct DownloadRequest *dr);
  * @param sr result to start pinging for.
  */
 void
-GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr);
+GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr);
 
 
 /**
  * Context for controlling a download.
  */
-struct GNUNET_FS_DownloadContext {
+struct GNUNET_FS_DownloadContext
+{
   /**
    * Global FS context.
    */
diff --git a/src/fs/fs_directory.c b/src/fs/fs_directory.c
index ae7727cf0..5e1e0af5e 100644
--- a/src/fs/fs_directory.c
+++ b/src/fs/fs_directory.c
@@ -51,18 +51,21 @@
  *  we have no mime-type information (treat as #GNUNET_NO)
  */
 int
-GNUNET_FS_meta_data_test_for_directory(const struct GNUNET_CONTAINER_MetaData *md)
+GNUNET_FS_meta_data_test_for_directory (const struct
+                                        GNUNET_CONTAINER_MetaData *md)
 {
   char *mime;
   int ret;
 
   if (NULL == md)
     return GNUNET_SYSERR;
-  mime = GNUNET_CONTAINER_meta_data_get_by_type(md, EXTRACTOR_METATYPE_MIMETYPE);
+  mime = GNUNET_CONTAINER_meta_data_get_by_type (md,
+                                                 EXTRACTOR_METATYPE_MIMETYPE);
   if (NULL == mime)
     return GNUNET_SYSERR;
-  ret = (0 == strcasecmp(mime, GNUNET_FS_DIRECTORY_MIME)) ? GNUNET_YES : GNUNET_NO;
-  GNUNET_free(mime);
+  ret = (0 == strcasecmp (mime, GNUNET_FS_DIRECTORY_MIME)) ? GNUNET_YES :
+        GNUNET_NO;
+  GNUNET_free (mime);
   return ret;
 }
 
@@ -74,30 +77,31 @@ GNUNET_FS_meta_data_test_for_directory(const struct GNUNET_CONTAINER_MetaData *m
  * @param md metadata to add mimetype to
  */
 void
-GNUNET_FS_meta_data_make_directory(struct GNUNET_CONTAINER_MetaData *md)
+GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md)
 {
   char *mime;
 
   mime =
-    GNUNET_CONTAINER_meta_data_get_by_type(md, EXTRACTOR_METATYPE_MIMETYPE);
+    GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
   if (mime != NULL)
-    {
-      GNUNET_break(0 == strcmp(mime, GNUNET_FS_DIRECTORY_MIME));
-      GNUNET_free(mime);
-      return;
-    }
-  GNUNET_CONTAINER_meta_data_insert(md, "<gnunet>",
-                                    EXTRACTOR_METATYPE_MIMETYPE,
-                                    EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                    GNUNET_FS_DIRECTORY_MIME,
-                                    strlen(GNUNET_FS_DIRECTORY_MIME) + 1);
+  {
+    GNUNET_break (0 == strcmp (mime, GNUNET_FS_DIRECTORY_MIME));
+    GNUNET_free (mime);
+    return;
+  }
+  GNUNET_CONTAINER_meta_data_insert (md, "<gnunet>",
+                                     EXTRACTOR_METATYPE_MIMETYPE,
+                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                     GNUNET_FS_DIRECTORY_MIME,
+                                     strlen (GNUNET_FS_DIRECTORY_MIME) + 1);
 }
 
 
 /**
  * Closure for 'find_full_data'.
  */
-struct GetFullDataClosure {
+struct GetFullDataClosure
+{
   /**
    * Extracted binary meta data.
    */
@@ -128,22 +132,22 @@ struct GetFullDataClosure {
  * @return 0 to continue extracting, 1 to abort
  */
 static int
-find_full_data(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)
+find_full_data (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 GetFullDataClosure *gfdc = cls;
 
   if (type == EXTRACTOR_METATYPE_GNUNET_FULL_DATA)
+  {
+    gfdc->size = data_len;
+    if (data_len > 0)
     {
-      gfdc->size = data_len;
-      if (data_len > 0)
-        {
-          gfdc->data = GNUNET_malloc(data_len);
-          GNUNET_memcpy(gfdc->data, data, data_len);
-        }
-      return 1;
+      gfdc->data = GNUNET_malloc (data_len);
+      GNUNET_memcpy (gfdc->data, data, data_len);
     }
+    return 1;
+  }
   return 0;
 }
 
@@ -174,11 +178,11 @@ find_full_data(void *cls, const char *plugin_name,
  *         #GNUNET_SYSERR if @a data does not represent a directory
  */
 int
-GNUNET_FS_directory_list_contents(size_t size,
-                                  const void *data,
-                                  uint64_t offset,
-                                  GNUNET_FS_DirectoryEntryProcessor dep,
-                                  void *dep_cls)
+GNUNET_FS_directory_list_contents (size_t size,
+                                   const void *data,
+                                   uint64_t offset,
+                                   GNUNET_FS_DirectoryEntryProcessor dep,
+                                   void *dep_cls)
 {
   struct GetFullDataClosure full_data;
   const char *cdata = data;
@@ -193,130 +197,131 @@ GNUNET_FS_directory_list_contents(size_t size,
 
   if ((offset == 0) &&
       ((size < 8 + sizeof(uint32_t)) ||
-       (0 != memcmp(cdata,
-                    GNUNET_FS_DIRECTORY_MAGIC,
-                    8))))
+       (0 != memcmp (cdata,
+                     GNUNET_FS_DIRECTORY_MAGIC,
+                     8))))
     return GNUNET_SYSERR;
   pos = offset;
   if (offset == 0)
+  {
+    GNUNET_memcpy (&mdSize,
+                   &cdata[8],
+                   sizeof(uint32_t));
+    mdSize = ntohl (mdSize);
+    if (mdSize > size - 8 - sizeof(uint32_t))
     {
-      GNUNET_memcpy(&mdSize,
-                    &cdata[8],
-                    sizeof(uint32_t));
-      mdSize = ntohl(mdSize);
-      if (mdSize > size - 8 - sizeof(uint32_t))
-        {
-          /* invalid size */
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                     _("MAGIC mismatch.  This is not a GNUnet directory.\n"));
-          return GNUNET_SYSERR;
-        }
-      md = GNUNET_CONTAINER_meta_data_deserialize(&cdata[8 + sizeof(uint32_t)],
-                                                  mdSize);
-      if (md == NULL)
-        {
-          GNUNET_break(0);
-          return GNUNET_SYSERR; /* malformed ! */
-        }
-      dep(dep_cls,
-          NULL,
-          NULL,
-          md,
-          0,
-          NULL);
-      GNUNET_CONTAINER_meta_data_destroy(md);
-      pos = 8 + sizeof(uint32_t) + mdSize;
+      /* invalid size */
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _ ("MAGIC mismatch.  This is not a GNUnet directory.\n"));
+      return GNUNET_SYSERR;
+    }
+    md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[8 + sizeof(uint32_t)],
+                                                 mdSize);
+    if (md == NULL)
+    {
+      GNUNET_break (0);
+      return GNUNET_SYSERR;     /* malformed ! */
     }
+    dep (dep_cls,
+         NULL,
+         NULL,
+         md,
+         0,
+         NULL);
+    GNUNET_CONTAINER_meta_data_destroy (md);
+    pos = 8 + sizeof(uint32_t) + mdSize;
+  }
   while (pos < size)
+  {
+    /* find end of URI */
+    if (cdata[pos] == '\0')
     {
-      /* find end of URI */
-      if (cdata[pos] == '\0')
-        {
-          /* URI is never empty, must be end of block,
-           * skip to next alignment */
-          align = ((pos / DBLOCK_SIZE) + 1) * DBLOCK_SIZE;
-          if (align == pos)
-            {
-              /* if we were already aligned, still skip a block! */
-              align += DBLOCK_SIZE;
-            }
-          pos = align;
-          if (pos >= size)
-            {
-              /* malformed - or partial download... */
-              break;
-            }
-        }
-      epos = pos;
-      while ((epos < size) && (cdata[epos] != '\0'))
-        epos++;
-      if (epos >= size)
-        return GNUNET_NO;       /* malformed - or partial download */
-
-      uri = GNUNET_FS_uri_parse(&cdata[pos], &emsg);
-      pos = epos + 1;
-      if (NULL == uri)
-        {
-          GNUNET_free(emsg);
-          pos--;                /* go back to '\0' to force going to next alignment */
-          continue;
-        }
-      if (GNUNET_FS_uri_test_ksk(uri))
-        {
-          GNUNET_FS_uri_destroy(uri);
-          GNUNET_break(0);
-          return GNUNET_NO;     /* illegal in directory! */
-        }
+      /* URI is never empty, must be end of block,
+       * skip to next alignment */
+      align = ((pos / DBLOCK_SIZE) + 1) * DBLOCK_SIZE;
+      if (align == pos)
+      {
+        /* if we were already aligned, still skip a block! */
+        align += DBLOCK_SIZE;
+      }
+      pos = align;
+      if (pos >= size)
+      {
+        /* malformed - or partial download... */
+        break;
+      }
+    }
+    epos = pos;
+    while ((epos < size) && (cdata[epos] != '\0'))
+      epos++;
+    if (epos >= size)
+      return GNUNET_NO;         /* malformed - or partial download */
+
+    uri = GNUNET_FS_uri_parse (&cdata[pos], &emsg);
+    pos = epos + 1;
+    if (NULL == uri)
+    {
+      GNUNET_free (emsg);
+      pos--;                    /* go back to '\0' to force going to next alignment */
+      continue;
+    }
+    if (GNUNET_FS_uri_test_ksk (uri))
+    {
+      GNUNET_FS_uri_destroy (uri);
+      GNUNET_break (0);
+      return GNUNET_NO;         /* illegal in directory! */
+    }
 
-      GNUNET_memcpy(&mdSize,
-                    &cdata[pos],
-                    sizeof(uint32_t));
-      mdSize = ntohl(mdSize);
-      pos += sizeof(uint32_t);
-      if (pos + mdSize > size)
-        {
-          GNUNET_FS_uri_destroy(uri);
-          return GNUNET_NO;     /* malformed - or partial download */
-        }
+    GNUNET_memcpy (&mdSize,
+                   &cdata[pos],
+                   sizeof(uint32_t));
+    mdSize = ntohl (mdSize);
+    pos += sizeof(uint32_t);
+    if (pos + mdSize > size)
+    {
+      GNUNET_FS_uri_destroy (uri);
+      return GNUNET_NO;         /* malformed - or partial download */
+    }
 
-      md = GNUNET_CONTAINER_meta_data_deserialize(&cdata[pos],
-                                                  mdSize);
-      if (NULL == md)
-        {
-          GNUNET_FS_uri_destroy(uri);
-          GNUNET_break(0);
-          return GNUNET_NO;     /* malformed ! */
-        }
-      pos += mdSize;
-      filename =
-        GNUNET_CONTAINER_meta_data_get_by_type(md,
-                                               EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
-      full_data.size = 0;
-      full_data.data = NULL;
-      GNUNET_CONTAINER_meta_data_iterate(md,
-                                         &find_full_data,
-                                         &full_data);
-      if (NULL != dep)
-        {
-          dep(dep_cls,
-              filename,
-              uri,
-              md,
-              full_data.size,
-              full_data.data);
-        }
-      GNUNET_free_non_null(full_data.data);
-      GNUNET_free_non_null(filename);
-      GNUNET_CONTAINER_meta_data_destroy(md);
-      GNUNET_FS_uri_destroy(uri);
+    md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[pos],
+                                                 mdSize);
+    if (NULL == md)
+    {
+      GNUNET_FS_uri_destroy (uri);
+      GNUNET_break (0);
+      return GNUNET_NO;         /* malformed ! */
+    }
+    pos += mdSize;
+    filename =
+      GNUNET_CONTAINER_meta_data_get_by_type (md,
+                                              EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+    full_data.size = 0;
+    full_data.data = NULL;
+    GNUNET_CONTAINER_meta_data_iterate (md,
+                                        &find_full_data,
+                                        &full_data);
+    if (NULL != dep)
+    {
+      dep (dep_cls,
+           filename,
+           uri,
+           md,
+           full_data.size,
+           full_data.data);
     }
+    GNUNET_free_non_null (full_data.data);
+    GNUNET_free_non_null (filename);
+    GNUNET_CONTAINER_meta_data_destroy (md);
+    GNUNET_FS_uri_destroy (uri);
+  }
   return GNUNET_OK;
 }
 
 /**
  * Entries in the directory (builder).
  */
-struct BuilderEntry {
+struct BuilderEntry
+{
   /**
    * This is a linked list.
    */
@@ -331,7 +336,8 @@ struct BuilderEntry {
 /**
  * Internal state of a directory builder.
  */
-struct GNUNET_FS_DirectoryBuilder {
+struct GNUNET_FS_DirectoryBuilder
+{
   /**
    * Meta-data for the directory itself.
    */
@@ -355,17 +361,17 @@ struct GNUNET_FS_DirectoryBuilder {
  * @param mdir metadata for the directory
  */
 struct GNUNET_FS_DirectoryBuilder *
-GNUNET_FS_directory_builder_create(const struct GNUNET_CONTAINER_MetaData
-                                   *mdir)
+GNUNET_FS_directory_builder_create (const struct GNUNET_CONTAINER_MetaData
+                                    *mdir)
 {
   struct GNUNET_FS_DirectoryBuilder *ret;
 
-  ret = GNUNET_new(struct GNUNET_FS_DirectoryBuilder);
+  ret = GNUNET_new (struct GNUNET_FS_DirectoryBuilder);
   if (mdir != NULL)
-    ret->meta = GNUNET_CONTAINER_meta_data_duplicate(mdir);
+    ret->meta = GNUNET_CONTAINER_meta_data_duplicate (mdir);
   else
-    ret->meta = GNUNET_CONTAINER_meta_data_create();
-  GNUNET_FS_meta_data_make_directory(ret->meta);
+    ret->meta = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_FS_meta_data_make_directory (ret->meta);
   return ret;
 }
 
@@ -381,10 +387,10 @@ GNUNET_FS_directory_builder_create(const struct GNUNET_CONTAINER_MetaData
  *        by the uri which must be of type LOC or CHK
  */
 void
-GNUNET_FS_directory_builder_add(struct GNUNET_FS_DirectoryBuilder *bld,
-                                const struct GNUNET_FS_Uri *uri,
-                                const struct GNUNET_CONTAINER_MetaData *md,
-                                const void *data)
+GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld,
+                                 const struct GNUNET_FS_Uri *uri,
+                                 const struct GNUNET_CONTAINER_MetaData *md,
+                                 const void *data)
 {
   struct GNUNET_FS_Uri *curi;
   struct BuilderEntry *e;
@@ -400,70 +406,70 @@ GNUNET_FS_directory_builder_add(struct GNUNET_FS_DirectoryBuilder *bld,
   struct GNUNET_CONTAINER_MetaData *meta;
   const struct GNUNET_CONTAINER_MetaData *meta_use;
 
-  GNUNET_assert(!GNUNET_FS_uri_test_ksk(uri));
+  GNUNET_assert (! GNUNET_FS_uri_test_ksk (uri));
   if (NULL != data)
+  {
+    GNUNET_assert (! GNUNET_FS_uri_test_sks (uri));
+    if (GNUNET_FS_uri_test_chk (uri))
     {
-      GNUNET_assert(!GNUNET_FS_uri_test_sks(uri));
-      if (GNUNET_FS_uri_test_chk(uri))
-        {
-          fsize = GNUNET_FS_uri_chk_get_file_size(uri);
-        }
-      else
-        {
-          curi = GNUNET_FS_uri_loc_get_uri(uri);
-          GNUNET_assert(NULL != curi);
-          fsize = GNUNET_FS_uri_chk_get_file_size(curi);
-          GNUNET_FS_uri_destroy(curi);
-        }
+      fsize = GNUNET_FS_uri_chk_get_file_size (uri);
     }
-  else
+    else
     {
-      fsize = 0;                /* not given */
+      curi = GNUNET_FS_uri_loc_get_uri (uri);
+      GNUNET_assert (NULL != curi);
+      fsize = GNUNET_FS_uri_chk_get_file_size (curi);
+      GNUNET_FS_uri_destroy (curi);
     }
+  }
+  else
+  {
+    fsize = 0;                  /* not given */
+  }
   if (fsize > MAX_INLINE_SIZE)
     fsize = 0;                  /* too large */
-  uris = GNUNET_FS_uri_to_string(uri);
-  slen = strlen(uris) + 1;
-  mds = GNUNET_CONTAINER_meta_data_get_serialized_size(md);
+  uris = GNUNET_FS_uri_to_string (uri);
+  slen = strlen (uris) + 1;
+  mds = GNUNET_CONTAINER_meta_data_get_serialized_size (md);
   meta_use = md;
   meta = NULL;
   if (fsize > 0)
+  {
+    meta = GNUNET_CONTAINER_meta_data_duplicate (md);
+    GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>",
+                                       EXTRACTOR_METATYPE_GNUNET_FULL_DATA,
+                                       EXTRACTOR_METAFORMAT_BINARY, NULL, data,
+                                       fsize);
+    mdxs = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
+    if ((slen + sizeof(uint32_t) + mdxs - 1) / DBLOCK_SIZE ==
+        (slen + sizeof(uint32_t) + mds - 1) / DBLOCK_SIZE)
     {
-      meta = GNUNET_CONTAINER_meta_data_duplicate(md);
-      GNUNET_CONTAINER_meta_data_insert(meta, "<gnunet>",
-                                        EXTRACTOR_METATYPE_GNUNET_FULL_DATA,
-                                        EXTRACTOR_METAFORMAT_BINARY, NULL, data,
-                                        fsize);
-      mdxs = GNUNET_CONTAINER_meta_data_get_serialized_size(meta);
-      if ((slen + sizeof(uint32_t) + mdxs - 1) / DBLOCK_SIZE ==
-          (slen + sizeof(uint32_t) + mds - 1) / DBLOCK_SIZE)
-        {
-          /* adding full data would not cause us to cross
-           * additional blocks, so add it! */
-          meta_use = meta;
-          mds = mdxs;
-        }
+      /* adding full data would not cause us to cross
+       * additional blocks, so add it! */
+      meta_use = meta;
+      mds = mdxs;
     }
+  }
 
   if (mds > GNUNET_MAX_MALLOC_CHECKED / 2)
     mds = GNUNET_MAX_MALLOC_CHECKED / 2;
-  e = GNUNET_malloc(sizeof(struct BuilderEntry) + slen + mds +
-                    sizeof(uint32_t));
-  ser = (char *)&e[1];
-  GNUNET_memcpy(ser, uris, slen);
-  GNUNET_free(uris);
+  e = GNUNET_malloc (sizeof(struct BuilderEntry) + slen + mds
+                     + sizeof(uint32_t));
+  ser = (char *) &e[1];
+  GNUNET_memcpy (ser, uris, slen);
+  GNUNET_free (uris);
   sptr = &ser[slen + sizeof(uint32_t)];
   ret =
-    GNUNET_CONTAINER_meta_data_serialize(meta_use, &sptr, mds,
-                                         GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+    GNUNET_CONTAINER_meta_data_serialize (meta_use, &sptr, mds,
+                                          GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (NULL != meta)
-    GNUNET_CONTAINER_meta_data_destroy(meta);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
   if (ret == -1)
     mds = 0;
   else
     mds = ret;
-  big = htonl(mds);
-  GNUNET_memcpy(&ser[slen], &big, sizeof(uint32_t));
+  big = htonl (mds);
+  GNUNET_memcpy (&ser[slen], &big, sizeof(uint32_t));
   e->len = slen + sizeof(uint32_t) + mds;
   e->next = bld->head;
   bld->head = e;
@@ -477,7 +483,7 @@ GNUNET_FS_directory_builder_add(struct GNUNET_FS_DirectoryBuilder *bld,
  * after alignment to the DBLOCK_SIZE.
  */
 static size_t
-do_align(size_t start_position, size_t end_position)
+do_align (size_t start_position, size_t end_position)
 {
   size_t align;
 
@@ -498,8 +504,8 @@ do_align(size_t start_position, size_t end_position)
  * @param perm the permutation of the blocks (updated)
  */
 static void
-block_align(size_t start, unsigned int count, const size_t * sizes,
-            unsigned int *perm)
+block_align (size_t start, unsigned int count, const size_t *sizes,
+             unsigned int *perm)
 {
   unsigned int i;
   unsigned int j;
@@ -513,46 +519,46 @@ block_align(size_t start, unsigned int count, const size_t * sizes,
 
   cpos = start;
   for (i = 0; i < count; i++)
+  {
+    start = cpos;
+    badness = 0x7FFFFFFF;
+    best = -1;
+    for (j = i; j < count; j++)
     {
-      start = cpos;
-      badness = 0x7FFFFFFF;
-      best = -1;
-      for (j = i; j < count; j++)
+      cval = perm[j];
+      cend = cpos + sizes[cval];
+      if (cpos % DBLOCK_SIZE == 0)
+      {
+        /* prefer placing the largest blocks first */
+        cbad = -(cend % DBLOCK_SIZE);
+      }
+      else
+      {
+        if (cpos / DBLOCK_SIZE == cend / DBLOCK_SIZE)
+        {
+          /* Data fits into the same block! Prefer small left-overs! */
+          cbad = DBLOCK_SIZE - cend % DBLOCK_SIZE;
+        }
+        else
         {
-          cval = perm[j];
-          cend = cpos + sizes[cval];
-          if (cpos % DBLOCK_SIZE == 0)
-            {
-              /* prefer placing the largest blocks first */
-              cbad = -(cend % DBLOCK_SIZE);
-            }
-          else
-            {
-              if (cpos / DBLOCK_SIZE == cend / DBLOCK_SIZE)
-                {
-                  /* Data fits into the same block! Prefer small left-overs! */
-                  cbad = DBLOCK_SIZE - cend % DBLOCK_SIZE;
-                }
-              else
-                {
-                  /* Would have to waste space to re-align, add big factor, this
-                   * case is a real loss (proportional to space wasted)! */
-                  cbad = DBLOCK_SIZE * (DBLOCK_SIZE - cpos % DBLOCK_SIZE);
-                }
-            }
-          if (cbad < badness)
-            {
-              best = j;
-              badness = cbad;
-            }
+          /* Would have to waste space to re-align, add big factor, this
+           * case is a real loss (proportional to space wasted)! */
+          cbad = DBLOCK_SIZE * (DBLOCK_SIZE - cpos % DBLOCK_SIZE);
         }
-      GNUNET_assert(best != -1);
-      tmp = perm[i];
-      perm[i] = perm[best];
-      perm[best] = tmp;
-      cpos += sizes[perm[i]];
-      cpos = do_align(start, cpos);
+      }
+      if (cbad < badness)
+      {
+        best = j;
+        badness = cbad;
+      }
     }
+    GNUNET_assert (best != -1);
+    tmp = perm[i];
+    perm[i] = perm[best];
+    perm[best] = tmp;
+    cpos += sizes[perm[i]];
+    cpos = do_align (start, cpos);
+  }
 }
 
 
@@ -567,9 +573,9 @@ block_align(size_t start, unsigned int count, const size_t * sizes,
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_FS_directory_builder_finish(struct GNUNET_FS_DirectoryBuilder *bld,
-                                   size_t * rsize,
-                                   void **rdata)
+GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
+                                    size_t *rsize,
+                                    void **rdata)
 {
   char *data;
   char *sptr;
@@ -585,82 +591,82 @@ GNUNET_FS_directory_builder_finish(struct GNUNET_FS_DirectoryBuilder *bld,
   ssize_t ret;
   uint32_t big;
 
-  size = strlen(GNUNET_DIRECTORY_MAGIC) + sizeof(uint32_t);
-  size += GNUNET_CONTAINER_meta_data_get_serialized_size(bld->meta);
+  size = strlen (GNUNET_DIRECTORY_MAGIC) + sizeof(uint32_t);
+  size += GNUNET_CONTAINER_meta_data_get_serialized_size (bld->meta);
   sizes = NULL;
   perm = NULL;
   bes = NULL;
   if (0 < bld->count)
+  {
+    sizes = GNUNET_new_array (bld->count,
+                              size_t);
+    perm = GNUNET_new_array (bld->count,
+                             unsigned int);
+    bes = GNUNET_new_array (bld->count,
+                            struct BuilderEntry *);
+    pos = bld->head;
+    for (i = 0; i < bld->count; i++)
     {
-      sizes = GNUNET_new_array(bld->count,
-                               size_t);
-      perm = GNUNET_new_array(bld->count,
-                              unsigned int);
-      bes = GNUNET_new_array(bld->count,
-                             struct BuilderEntry *);
-      pos = bld->head;
-      for (i = 0; i < bld->count; i++)
-        {
-          perm[i] = i;
-          bes[i] = pos;
-          sizes[i] = pos->len;
-          pos = pos->next;
-        }
-      block_align(size, bld->count, sizes, perm);
-      /* compute final size with alignment */
-      for (i = 0; i < bld->count; i++)
-        {
-          psize = size;
-          size += sizes[perm[i]];
-          size = do_align(psize, size);
-        }
+      perm[i] = i;
+      bes[i] = pos;
+      sizes[i] = pos->len;
+      pos = pos->next;
     }
-  *rsize = size;
-  data = GNUNET_malloc_large(size);
-  if (data == NULL)
+    block_align (size, bld->count, sizes, perm);
+    /* compute final size with alignment */
+    for (i = 0; i < bld->count; i++)
     {
-      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR,
-                          "malloc");
-      *rsize = 0;
-      *rdata = NULL;
-      GNUNET_free_non_null(sizes);
-      GNUNET_free_non_null(perm);
-      GNUNET_free_non_null(bes);
-      return GNUNET_SYSERR;
+      psize = size;
+      size += sizes[perm[i]];
+      size = do_align (psize, size);
     }
+  }
+  *rsize = size;
+  data = GNUNET_malloc_large (size);
+  if (data == NULL)
+  {
+    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+                         "malloc");
+    *rsize = 0;
+    *rdata = NULL;
+    GNUNET_free_non_null (sizes);
+    GNUNET_free_non_null (perm);
+    GNUNET_free_non_null (bes);
+    return GNUNET_SYSERR;
+  }
   *rdata = data;
-  GNUNET_memcpy(data,
-                GNUNET_DIRECTORY_MAGIC,
-                strlen(GNUNET_DIRECTORY_MAGIC));
-  off = strlen(GNUNET_DIRECTORY_MAGIC);
+  GNUNET_memcpy (data,
+                 GNUNET_DIRECTORY_MAGIC,
+                 strlen (GNUNET_DIRECTORY_MAGIC));
+  off = strlen (GNUNET_DIRECTORY_MAGIC);
 
   sptr = &data[off + sizeof(uint32_t)];
   ret =
-    GNUNET_CONTAINER_meta_data_serialize(bld->meta,
-                                         &sptr,
-                                         size - off - sizeof(uint32_t),
-                                         GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
-  GNUNET_assert(ret != -1);
-  big = htonl(ret);
-  GNUNET_memcpy(&data[off],
-                &big,
-                sizeof(uint32_t));
+    GNUNET_CONTAINER_meta_data_serialize (bld->meta,
+                                          &sptr,
+                                          size - off - sizeof(uint32_t),
+                                          GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
+  GNUNET_assert (ret != -1);
+  big = htonl (ret);
+  GNUNET_memcpy (&data[off],
+                 &big,
+                 sizeof(uint32_t));
   off += sizeof(uint32_t) + ret;
   for (j = 0; j < bld->count; j++)
-    {
-      i = perm[j];
-      psize = off;
-      off += sizes[i];
-      off = do_align(psize, off);
-      GNUNET_memcpy(&data[off - sizes[i]], &(bes[i])[1], sizes[i]);
-      GNUNET_free(bes[i]);
-    }
-  GNUNET_free_non_null(sizes);
-  GNUNET_free_non_null(perm);
-  GNUNET_free_non_null(bes);
-  GNUNET_assert(off == size);
-  GNUNET_CONTAINER_meta_data_destroy(bld->meta);
-  GNUNET_free(bld);
+  {
+    i = perm[j];
+    psize = off;
+    off += sizes[i];
+    off = do_align (psize, off);
+    GNUNET_memcpy (&data[off - sizes[i]], &(bes[i])[1], sizes[i]);
+    GNUNET_free (bes[i]);
+  }
+  GNUNET_free_non_null (sizes);
+  GNUNET_free_non_null (perm);
+  GNUNET_free_non_null (bes);
+  GNUNET_assert (off == size);
+  GNUNET_CONTAINER_meta_data_destroy (bld->meta);
+  GNUNET_free (bld);
   return GNUNET_OK;
 }
 
diff --git a/src/fs/fs_dirmetascan.c b/src/fs/fs_dirmetascan.c
index 9202de5ab..11efa053b 100644
--- a/src/fs/fs_dirmetascan.c
+++ b/src/fs/fs_dirmetascan.c
@@ -35,7 +35,8 @@
  * An opaque structure a pointer to which is returned to the
  * caller to be used to control the scanner.
  */
-struct GNUNET_FS_DirScanner {
+struct GNUNET_FS_DirScanner
+{
   /**
    * Helper process.
    */
@@ -94,20 +95,20 @@ struct GNUNET_FS_DirScanner {
  * @param ds directory scanner structure
  */
 void
-GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
+GNUNET_FS_directory_scan_abort (struct GNUNET_FS_DirScanner *ds)
 {
   /* terminate helper */
   if (NULL != ds->helper)
-    GNUNET_HELPER_stop(ds->helper, GNUNET_NO);
+    GNUNET_HELPER_stop (ds->helper, GNUNET_NO);
 
   /* free resources */
   if (NULL != ds->toplevel)
-    GNUNET_FS_share_tree_free(ds->toplevel);
+    GNUNET_FS_share_tree_free (ds->toplevel);
   if (NULL != ds->stop_task)
-    GNUNET_SCHEDULER_cancel(ds->stop_task);
-  GNUNET_free_non_null(ds->ex_arg);
-  GNUNET_free(ds->filename_expanded);
-  GNUNET_free(ds);
+    GNUNET_SCHEDULER_cancel (ds->stop_task);
+  GNUNET_free_non_null (ds->ex_arg);
+  GNUNET_free (ds->filename_expanded);
+  GNUNET_free (ds);
 }
 
 
@@ -120,16 +121,16 @@ GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
  * @return the results of the scan (a directory tree)
  */
 struct GNUNET_FS_ShareTreeItem *
-GNUNET_FS_directory_scan_get_result(struct GNUNET_FS_DirScanner *ds)
+GNUNET_FS_directory_scan_get_result (struct GNUNET_FS_DirScanner *ds)
 {
   struct GNUNET_FS_ShareTreeItem *result;
 
   /* check that we're actually done */
-  GNUNET_assert(NULL == ds->helper);
+  GNUNET_assert (NULL == ds->helper);
   /* preserve result */
   result = ds->toplevel;
   ds->toplevel = NULL;
-  GNUNET_FS_directory_scan_abort(ds);
+  GNUNET_FS_directory_scan_abort (ds);
   return result;
 }
 
@@ -142,35 +143,35 @@ GNUNET_FS_directory_scan_get_result(struct GNUNET_FS_DirScanner *ds)
  * @return next file, NULL for none
  */
 static struct GNUNET_FS_ShareTreeItem *
-advance(struct GNUNET_FS_ShareTreeItem *pos)
+advance (struct GNUNET_FS_ShareTreeItem *pos)
 {
   int moved;
 
-  GNUNET_assert(NULL != pos);
+  GNUNET_assert (NULL != pos);
   moved = 0; /* must not terminate, even on file, otherwise "normal" */
   while ((pos->is_directory == GNUNET_YES) || (0 == moved))
+  {
+    if ((moved != -1) && (NULL != pos->children_head))
     {
-      if ((moved != -1) && (NULL != pos->children_head))
-        {
-          pos = pos->children_head;
-          moved = 1; /* can terminate if file */
-          continue;
-        }
-      if (NULL != pos->next)
-        {
-          pos = pos->next;
-          moved = 1; /* can terminate if file */
-          continue;
-        }
-      if (NULL != pos->parent)
-        {
-          pos = pos->parent;
-          moved = -1; /* force move to 'next' or 'parent' */
-          continue;
-        }
-      /* no more options, end of traversal */
-      return NULL;
+      pos = pos->children_head;
+      moved = 1;     /* can terminate if file */
+      continue;
+    }
+    if (NULL != pos->next)
+    {
+      pos = pos->next;
+      moved = 1;     /* can terminate if file */
+      continue;
+    }
+    if (NULL != pos->parent)
+    {
+      pos = pos->parent;
+      moved = -1;     /* force move to 'next' or 'parent' */
+      continue;
     }
+    /* no more options, end of traversal */
+    return NULL;
+  }
   return pos;
 }
 
@@ -184,30 +185,30 @@ advance(struct GNUNET_FS_ShareTreeItem *pos)
  * @return new entry that was just created
  */
 static struct GNUNET_FS_ShareTreeItem *
-expand_tree(struct GNUNET_FS_ShareTreeItem *parent,
-            const char *filename,
-            int is_directory)
+expand_tree (struct GNUNET_FS_ShareTreeItem *parent,
+             const char *filename,
+             int is_directory)
 {
   struct GNUNET_FS_ShareTreeItem *chld;
   size_t slen;
 
-  chld = GNUNET_new(struct GNUNET_FS_ShareTreeItem);
+  chld = GNUNET_new (struct GNUNET_FS_ShareTreeItem);
   chld->parent = parent;
-  chld->filename = GNUNET_strdup(filename);
-  GNUNET_asprintf(&chld->short_filename,
-                  "%s%s",
-                  GNUNET_STRINGS_get_short_name(filename),
-                  is_directory == GNUNET_YES ? "/" : "");
+  chld->filename = GNUNET_strdup (filename);
+  GNUNET_asprintf (&chld->short_filename,
+                   "%s%s",
+                   GNUNET_STRINGS_get_short_name (filename),
+                   is_directory == GNUNET_YES ? "/" : "");
   /* make sure we do not end with '//' */
-  slen = strlen(chld->short_filename);
+  slen = strlen (chld->short_filename);
   if ((slen >= 2) && (chld->short_filename[slen - 1] == '/') &&
       (chld->short_filename[slen - 2] == '/'))
     chld->short_filename[slen - 1] = '\0';
   chld->is_directory = is_directory;
   if (NULL != parent)
-    GNUNET_CONTAINER_DLL_insert(parent->children_head,
-                                parent->children_tail,
-                                chld);
+    GNUNET_CONTAINER_DLL_insert (parent->children_head,
+                                 parent->children_tail,
+                                 chld);
   return chld;
 }
 
@@ -218,20 +219,20 @@ expand_tree(struct GNUNET_FS_ShareTreeItem *parent,
  * @param cls the 'struct GNUNET_FS_DirScanner'
  */
 static void
-finish_scan(void *cls)
+finish_scan (void *cls)
 {
   struct GNUNET_FS_DirScanner *ds = cls;
 
   ds->stop_task = NULL;
   if (NULL != ds->helper)
-    {
-      GNUNET_HELPER_stop(ds->helper, GNUNET_NO);
-      ds->helper = NULL;
-    }
-  ds->progress_callback(ds->progress_callback_cls,
-                        NULL,
-                        GNUNET_SYSERR,
-                        GNUNET_FS_DIRSCANNER_FINISHED);
+  {
+    GNUNET_HELPER_stop (ds->helper, GNUNET_NO);
+    ds->helper = NULL;
+  }
+  ds->progress_callback (ds->progress_callback_cls,
+                         NULL,
+                         GNUNET_SYSERR,
+                         GNUNET_FS_DIRSCANNER_FINISHED);
 }
 
 
@@ -246,175 +247,177 @@ finish_scan(void *cls)
  *    #GNUNET_SYSERR to stop further processing with error
  */
 static int
-process_helper_msgs(void *cls, const struct GNUNET_MessageHeader *msg)
+process_helper_msgs (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_DirScanner *ds = cls;
   const char *filename;
   size_t left;
 
 #if 0
-  fprintf(stderr,
-          "DMS parses %u-byte message of type %u\n",
-          (unsigned int)ntohs(msg->size),
-          (unsigned int)ntohs(msg->type));
+  fprintf (stderr,
+           "DMS parses %u-byte message of type %u\n",
+           (unsigned int) ntohs (msg->size),
+           (unsigned int) ntohs (msg->type));
 #endif
-  left = ntohs(msg->size) - sizeof(struct GNUNET_MessageHeader);
-  filename = (const char *)&msg[1];
-  switch (ntohs(msg->type))
+  left = ntohs (msg->size) - sizeof(struct GNUNET_MessageHeader);
+  filename = (const char *) &msg[1];
+  switch (ntohs (msg->type))
+  {
+  case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_FILE:
+    if (filename[left - 1] != '\0')
     {
-    case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_FILE:
-      if (filename[left - 1] != '\0')
-        {
-          GNUNET_break(0);
-          break;
-        }
-      ds->progress_callback(ds->progress_callback_cls,
-                            filename,
-                            GNUNET_NO,
-                            GNUNET_FS_DIRSCANNER_FILE_START);
-      if (NULL == ds->toplevel)
-        {
-          ds->toplevel = expand_tree(ds->pos, filename, GNUNET_NO);
-        }
-      else
-        {
-          GNUNET_assert(NULL != ds->pos);
-          (void)expand_tree(ds->pos, filename, GNUNET_NO);
-        }
-      return GNUNET_OK;
-
-    case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_DIRECTORY:
-      if (filename[left - 1] != '\0')
-        {
-          GNUNET_break(0);
-          break;
-        }
-      if (0 == strcmp("..", filename))
-        {
-          if (NULL == ds->pos)
-            {
-              GNUNET_break(0);
-              break;
-            }
-          ds->pos = ds->pos->parent;
-          return GNUNET_OK;
-        }
-      ds->progress_callback(ds->progress_callback_cls,
-                            filename,
-                            GNUNET_YES,
-                            GNUNET_FS_DIRSCANNER_FILE_START);
-      ds->pos = expand_tree(ds->pos, filename, GNUNET_YES);
-      if (NULL == ds->toplevel)
-        ds->toplevel = ds->pos;
-      return GNUNET_OK;
-
-    case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_ERROR:
+      GNUNET_break (0);
       break;
+    }
+    ds->progress_callback (ds->progress_callback_cls,
+                           filename,
+                           GNUNET_NO,
+                           GNUNET_FS_DIRSCANNER_FILE_START);
+    if (NULL == ds->toplevel)
+    {
+      ds->toplevel = expand_tree (ds->pos, filename, GNUNET_NO);
+    }
+    else
+    {
+      GNUNET_assert (NULL != ds->pos);
+      (void) expand_tree (ds->pos, filename, GNUNET_NO);
+    }
+    return GNUNET_OK;
 
-    case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_SKIP_FILE:
-      if ('\0' != filename[left - 1])
-        break;
-      ds->progress_callback(ds->progress_callback_cls,
-                            filename,
-                            GNUNET_SYSERR,
-                            GNUNET_FS_DIRSCANNER_FILE_IGNORED);
-      return GNUNET_OK;
-
-    case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_COUNTING_DONE:
-      if (0 != left)
-        {
-          GNUNET_break(0);
-          break;
-        }
-      if (NULL == ds->toplevel)
+  case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_DIRECTORY:
+    if (filename[left - 1] != '\0')
+    {
+      GNUNET_break (0);
+      break;
+    }
+    if (0 == strcmp ("..", filename))
+    {
+      if (NULL == ds->pos)
+      {
+        GNUNET_break (0);
         break;
-      ds->progress_callback(ds->progress_callback_cls,
-                            NULL,
-                            GNUNET_SYSERR,
-                            GNUNET_FS_DIRSCANNER_ALL_COUNTED);
-      ds->pos = ds->toplevel;
-      if (GNUNET_YES == ds->pos->is_directory)
-        ds->pos = advance(ds->pos);
+      }
+      ds->pos = ds->pos->parent;
       return GNUNET_OK;
-
-    case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA: {
+    }
+    ds->progress_callback (ds->progress_callback_cls,
+                           filename,
+                           GNUNET_YES,
+                           GNUNET_FS_DIRSCANNER_FILE_START);
+    ds->pos = expand_tree (ds->pos, filename, GNUNET_YES);
+    if (NULL == ds->toplevel)
+      ds->toplevel = ds->pos;
+    return GNUNET_OK;
+
+  case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_ERROR:
+    break;
+
+  case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_SKIP_FILE:
+    if ('\0' != filename[left - 1])
+      break;
+    ds->progress_callback (ds->progress_callback_cls,
+                           filename,
+                           GNUNET_SYSERR,
+                           GNUNET_FS_DIRSCANNER_FILE_IGNORED);
+    return GNUNET_OK;
+
+  case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_COUNTING_DONE:
+    if (0 != left)
+    {
+      GNUNET_break (0);
+      break;
+    }
+    if (NULL == ds->toplevel)
+      break;
+    ds->progress_callback (ds->progress_callback_cls,
+                           NULL,
+                           GNUNET_SYSERR,
+                           GNUNET_FS_DIRSCANNER_ALL_COUNTED);
+    ds->pos = ds->toplevel;
+    if (GNUNET_YES == ds->pos->is_directory)
+      ds->pos = advance (ds->pos);
+    return GNUNET_OK;
+
+  case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA: {
       size_t nlen;
       const char *end;
 
       if (NULL == ds->pos)
-        {
-          GNUNET_break(0);
-          break;
-        }
-      end = memchr(filename, 0, left);
+      {
+        GNUNET_break (0);
+        break;
+      }
+      end = memchr (filename, 0, left);
       if (NULL == end)
-        {
-          GNUNET_break(0);
-          break;
-        }
+      {
+        GNUNET_break (0);
+        break;
+      }
       end++;
       nlen = end - filename;
       left -= nlen;
-      if (0 != strcmp(filename, ds->pos->filename))
-        {
-          GNUNET_break(0);
-          break;
-        }
-      ds->progress_callback(ds->progress_callback_cls,
-                            filename,
-                            GNUNET_YES,
-                            GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED);
+      if (0 != strcmp (filename, ds->pos->filename))
+      {
+        GNUNET_break (0);
+        break;
+      }
+      ds->progress_callback (ds->progress_callback_cls,
+                             filename,
+                             GNUNET_YES,
+                             GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED);
       if (0 < left)
+      {
+        ds->pos->meta = GNUNET_CONTAINER_meta_data_deserialize (end, left);
+        if (NULL == ds->pos->meta)
         {
-          ds->pos->meta = GNUNET_CONTAINER_meta_data_deserialize(end, left);
-          if (NULL == ds->pos->meta)
-            {
-              GNUNET_break(0);
-              break;
-            }
-          /* having full filenames is too dangerous; always make sure we clean them up */
-          GNUNET_CONTAINER_meta_data_delete(ds->pos->meta,
-                                            EXTRACTOR_METATYPE_FILENAME,
-                                            NULL,
-                                            0);
-          /* instead, put in our 'safer' original filename */
-          GNUNET_CONTAINER_meta_data_insert(ds->pos->meta,
-                                            "<libgnunetfs>",
-                                            EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                            EXTRACTOR_METAFORMAT_UTF8,
-                                            "text/plain",
-                                            ds->pos->short_filename,
-                                            strlen(ds->pos->short_filename) + 1);
-        }
-      ds->pos->ksk_uri = GNUNET_FS_uri_ksk_create_from_meta_data(ds->pos->meta);
-      ds->pos = advance(ds->pos);
-      return GNUNET_OK;
-    }
-
-    case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_FINISHED:
-      if (NULL != ds->pos)
-        {
-          GNUNET_break(0);
-          break;
-        }
-      if (0 != left)
-        {
-          GNUNET_break(0);
+          GNUNET_break (0);
           break;
         }
-      if (NULL == ds->toplevel)
-        break;
-      ds->stop_task = GNUNET_SCHEDULER_add_now(&finish_scan, ds);
+        /* having full filenames is too dangerous; always make sure we clean them up */
+        GNUNET_CONTAINER_meta_data_delete (ds->pos->meta,
+                                           EXTRACTOR_METATYPE_FILENAME,
+                                           NULL,
+                                           0);
+        /* instead, put in our 'safer' original filename */
+        GNUNET_CONTAINER_meta_data_insert (ds->pos->meta,
+                                           "<libgnunetfs>",
+                                           EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                                           EXTRACTOR_METAFORMAT_UTF8,
+                                           "text/plain",
+                                           ds->pos->short_filename,
+                                           strlen (ds->pos->short_filename)
+                                           + 1);
+      }
+      ds->pos->ksk_uri = GNUNET_FS_uri_ksk_create_from_meta_data (
+        ds->pos->meta);
+      ds->pos = advance (ds->pos);
       return GNUNET_OK;
+    }
 
-    default:
-      GNUNET_break(0);
+  case GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_FINISHED:
+    if (NULL != ds->pos)
+    {
+      GNUNET_break (0);
+      break;
+    }
+    if (0 != left)
+    {
+      GNUNET_break (0);
       break;
     }
-  ds->progress_callback(ds->progress_callback_cls,
-                        NULL,
-                        GNUNET_SYSERR,
-                        GNUNET_FS_DIRSCANNER_INTERNAL_ERROR);
+    if (NULL == ds->toplevel)
+      break;
+    ds->stop_task = GNUNET_SCHEDULER_add_now (&finish_scan, ds);
+    return GNUNET_OK;
+
+  default:
+    GNUNET_break (0);
+    break;
+  }
+  ds->progress_callback (ds->progress_callback_cls,
+                         NULL,
+                         GNUNET_SYSERR,
+                         GNUNET_FS_DIRSCANNER_INTERNAL_ERROR);
   return GNUNET_OK;
 }
 
@@ -425,17 +428,17 @@ process_helper_msgs(void *cls, const struct GNUNET_MessageHeader *msg)
  * @param cls the 'struct GNUNET_FS_DirScanner' callback.
  */
 static void
-helper_died_cb(void *cls)
+helper_died_cb (void *cls)
 {
   struct GNUNET_FS_DirScanner *ds = cls;
 
   ds->helper = NULL;
   if (NULL != ds->stop_task)
     return; /* normal death, was finished */
-  ds->progress_callback(ds->progress_callback_cls,
-                        NULL,
-                        GNUNET_SYSERR,
-                        GNUNET_FS_DIRSCANNER_INTERNAL_ERROR);
+  ds->progress_callback (ds->progress_callback_cls,
+                         NULL,
+                         GNUNET_SYSERR,
+                         GNUNET_FS_DIRSCANNER_INTERNAL_ERROR);
 }
 
 
@@ -451,48 +454,48 @@ helper_died_cb(void *cls)
  * @return directory scanner object to be used for controlling the scanner
  */
 struct GNUNET_FS_DirScanner *
-GNUNET_FS_directory_scan_start(const char *filename,
-                               int disable_extractor,
-                               const char *ex,
-                               GNUNET_FS_DirScannerProgressCallback cb,
-                               void *cb_cls)
+GNUNET_FS_directory_scan_start (const char *filename,
+                                int disable_extractor,
+                                const char *ex,
+                                GNUNET_FS_DirScannerProgressCallback cb,
+                                void *cb_cls)
 {
   struct stat sbuf;
   char *filename_expanded;
   struct GNUNET_FS_DirScanner *ds;
 
-  if (0 != stat(filename, &sbuf))
+  if (0 != stat (filename, &sbuf))
     return NULL;
-  filename_expanded = GNUNET_STRINGS_filename_expand(filename);
+  filename_expanded = GNUNET_STRINGS_filename_expand (filename);
   if (NULL == filename_expanded)
     return NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Starting to scan directory `%s'\n",
-             filename_expanded);
-  ds = GNUNET_new(struct GNUNET_FS_DirScanner);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting to scan directory `%s'\n",
+              filename_expanded);
+  ds = GNUNET_new (struct GNUNET_FS_DirScanner);
   ds->progress_callback = cb;
   ds->progress_callback_cls = cb_cls;
   ds->filename_expanded = filename_expanded;
   if (disable_extractor)
-    ds->ex_arg = GNUNET_strdup("-");
+    ds->ex_arg = GNUNET_strdup ("-");
   else
-    ds->ex_arg = (NULL != ex) ? GNUNET_strdup(ex) : NULL;
+    ds->ex_arg = (NULL != ex) ? GNUNET_strdup (ex) : NULL;
   ds->args[0] = "gnunet-helper-fs-publish";
   ds->args[1] = ds->filename_expanded;
   ds->args[2] = ds->ex_arg;
   ds->args[3] = NULL;
-  ds->helper = GNUNET_HELPER_start(GNUNET_NO,
-                                   "gnunet-helper-fs-publish",
-                                   ds->args,
-                                   &process_helper_msgs,
-                                   &helper_died_cb,
-                                   ds);
+  ds->helper = GNUNET_HELPER_start (GNUNET_NO,
+                                    "gnunet-helper-fs-publish",
+                                    ds->args,
+                                    &process_helper_msgs,
+                                    &helper_died_cb,
+                                    ds);
   if (NULL == ds->helper)
-    {
-      GNUNET_free(filename_expanded);
-      GNUNET_free(ds);
-      return NULL;
-    }
+  {
+    GNUNET_free (filename_expanded);
+    GNUNET_free (ds);
+    return NULL;
+  }
   return ds;
 }
 
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index de70c53a8..e7ea87e50 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -34,16 +34,16 @@
  * use to try to do a recursive download.
  */
 static int
-is_recursive_download(struct GNUNET_FS_DownloadContext *dc)
+is_recursive_download (struct GNUNET_FS_DownloadContext *dc)
 {
   return (0 != (dc->options & GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE)) &&
-         ((GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(dc->meta)) ||
+         ((GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (dc->meta)) ||
           ((NULL == dc->meta) &&
            ((NULL == dc->filename) ||
-            ((strlen(dc->filename) >= strlen(GNUNET_FS_DIRECTORY_EXT)) &&
-             (NULL != strstr(dc->filename + strlen(dc->filename) -
-                             strlen(GNUNET_FS_DIRECTORY_EXT),
-                             GNUNET_FS_DIRECTORY_EXT))))));
+            ((strlen (dc->filename) >= strlen (GNUNET_FS_DIRECTORY_EXT)) &&
+             (NULL != strstr (dc->filename + strlen (dc->filename)
+                              - strlen (GNUNET_FS_DIRECTORY_EXT),
+                              GNUNET_FS_DIRECTORY_EXT))))));
 }
 
 
@@ -64,7 +64,7 @@ is_recursive_download(struct GNUNET_FS_DownloadContext *dc)
  *         with the range for any other block
  */
 static uint64_t
-compute_disk_offset(uint64_t fsize, uint64_t off, unsigned int depth)
+compute_disk_offset (uint64_t fsize, uint64_t off, unsigned int depth)
 {
   unsigned int i;
   uint64_t lsize; /* what is the size of all IBlocks for depth "i"? */
@@ -78,16 +78,16 @@ compute_disk_offset(uint64_t fsize, uint64_t off, unsigned int depth)
   loff = ((fsize + DBLOCK_SIZE - 1) / DBLOCK_SIZE) * DBLOCK_SIZE;
   lsize =
     ((fsize + DBLOCK_SIZE - 1) / DBLOCK_SIZE) * sizeof(struct ContentHashKey);
-  GNUNET_assert(0 == (off % DBLOCK_SIZE));
+  GNUNET_assert (0 == (off % DBLOCK_SIZE));
   ioff = (off / DBLOCK_SIZE);
   for (i = 1; i < depth; i++)
-    {
-      loff += lsize;
-      lsize = (lsize + CHK_PER_INODE - 1) / CHK_PER_INODE;
-      GNUNET_assert(lsize > 0);
-      GNUNET_assert(0 == (ioff % CHK_PER_INODE));
-      ioff /= CHK_PER_INODE;
-    }
+  {
+    loff += lsize;
+    lsize = (lsize + CHK_PER_INODE - 1) / CHK_PER_INODE;
+    GNUNET_assert (lsize > 0);
+    GNUNET_assert (0 == (ioff % CHK_PER_INODE));
+    ioff /= CHK_PER_INODE;
+  }
   return loff + ioff * sizeof(struct ContentHashKey);
 }
 
@@ -100,8 +100,8 @@ compute_disk_offset(uint64_t fsize, uint64_t off, unsigned int depth)
  * @param dc overall download context
  */
 void
-GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                                struct GNUNET_FS_DownloadContext *dc)
+GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                 struct GNUNET_FS_DownloadContext *dc)
 {
   pi->value.download.dc = dc;
   pi->value.download.cctx = dc->client_info;
@@ -114,24 +114,25 @@ GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi,
   pi->value.download.size = dc->length;
   /* FIXME: Fix duration calculation to account for pauses */
   pi->value.download.duration =
-    GNUNET_TIME_absolute_get_duration(dc->start_time);
+    GNUNET_TIME_absolute_get_duration (dc->start_time);
   pi->value.download.completed = dc->completed;
   pi->value.download.anonymity = dc->anonymity;
   pi->value.download.eta =
-    GNUNET_TIME_calculate_eta(dc->start_time, dc->completed, dc->length);
+    GNUNET_TIME_calculate_eta (dc->start_time, dc->completed, dc->length);
   pi->value.download.is_active = (NULL == dc->mq) ? GNUNET_NO : GNUNET_YES;
   pi->fsh = dc->h;
   if (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
-    dc->client_info = dc->h->upcb(dc->h->upcb_cls, pi);
+    dc->client_info = dc->h->upcb (dc->h->upcb_cls, pi);
   else
-    dc->client_info = GNUNET_FS_search_probe_progress_(NULL, pi);
+    dc->client_info = GNUNET_FS_search_probe_progress_ (NULL, pi);
 }
 
 
 /**
  * Closure for iterator processing results.
  */
-struct ProcessResultClosure {
+struct ProcessResultClosure
+{
   /**
    * Hash of data.
    */
@@ -189,9 +190,9 @@ struct ProcessResultClosure {
  * @return #GNUNET_YES (we should continue to iterate); unless serious error
  */
 static int
-process_result_with_request(void *cls,
-                            const struct GNUNET_HashCode *key,
-                            void *value);
+process_result_with_request (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             void *value);
 
 
 /**
@@ -208,12 +209,12 @@ process_result_with_request(void *cls,
  * @return GNUNET_OK on success
  */
 static int
-encrypt_existing_match(struct GNUNET_FS_DownloadContext *dc,
-                       const struct ContentHashKey *chk,
-                       struct DownloadRequest *dr,
-                       const char *block,
-                       size_t len,
-                       int do_store)
+encrypt_existing_match (struct GNUNET_FS_DownloadContext *dc,
+                        const struct ContentHashKey *chk,
+                        struct DownloadRequest *dr,
+                        const char *block,
+                        size_t len,
+                        int do_store)
 {
   struct ProcessResultClosure prc;
   char enc[len];
@@ -221,24 +222,24 @@ encrypt_existing_match(struct GNUNET_FS_DownloadContext *dc,
   struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
   struct GNUNET_HashCode query;
 
-  GNUNET_CRYPTO_hash_to_aes_key(&chk->key, &sk, &iv);
-  if (-1 == GNUNET_CRYPTO_symmetric_encrypt(block, len, &sk, &iv, enc))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_CRYPTO_hash(enc, len, &query);
-  if (0 != memcmp(&query, &chk->query, sizeof(struct GNUNET_HashCode)))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_log(
+  GNUNET_CRYPTO_hash_to_aes_key (&chk->key, &sk, &iv);
+  if (-1 == GNUNET_CRYPTO_symmetric_encrypt (block, len, &sk, &iv, enc))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_CRYPTO_hash (enc, len, &query);
+  if (0 != memcmp (&query, &chk->query, sizeof(struct GNUNET_HashCode)))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "Matching %u byte block for `%s' at offset %llu already present, no need for download!\n",
-    (unsigned int)len,
+    (unsigned int) len,
     dc->filename,
-    (unsigned long long)dr->offset);
+    (unsigned long long) dr->offset);
   /* already got it! */
   prc.dc = dc;
   prc.data = enc;
@@ -248,7 +249,7 @@ encrypt_existing_match(struct GNUNET_FS_DownloadContext *dc,
   prc.query = chk->query;
   prc.do_store = do_store;
   prc.last_transmission = GNUNET_TIME_UNIT_FOREVER_ABS;
-  process_result_with_request(&prc, &chk->key, dr);
+  process_result_with_request (&prc, &chk->key, dr);
   return GNUNET_OK;
 }
 
@@ -261,7 +262,7 @@ encrypt_existing_match(struct GNUNET_FS_DownloadContext *dc,
  * @param dc download context that is having trouble
  */
 static void
-try_reconnect(struct GNUNET_FS_DownloadContext *dc);
+try_reconnect (struct GNUNET_FS_DownloadContext *dc);
 
 
 /**
@@ -276,12 +277,12 @@ try_reconnect(struct GNUNET_FS_DownloadContext *dc);
  * @param data contents of the file (or NULL if they were not inlined)
  */
 static void
-trigger_recursive_download(void *cls,
-                           const char *filename,
-                           const struct GNUNET_FS_Uri *uri,
-                           const struct GNUNET_CONTAINER_MetaData *meta,
-                           size_t length,
-                           const void *data);
+trigger_recursive_download (void *cls,
+                            const char *filename,
+                            const struct GNUNET_FS_Uri *uri,
+                            const struct GNUNET_CONTAINER_MetaData *meta,
+                            size_t length,
+                            const void *data);
 
 
 /**
@@ -291,7 +292,7 @@ trigger_recursive_download(void *cls,
  * @param dc context of download that just completed
  */
 static void
-full_recursive_download(struct GNUNET_FS_DownloadContext *dc)
+full_recursive_download (struct GNUNET_FS_DownloadContext *dc)
 {
   size_t size;
   uint64_t size64;
@@ -299,64 +300,64 @@ full_recursive_download(struct GNUNET_FS_DownloadContext *dc)
   struct GNUNET_DISK_FileHandle *h;
   struct GNUNET_DISK_MapHandle *m;
 
-  size64 = GNUNET_FS_uri_chk_get_file_size(dc->uri);
-  size = (size_t)size64;
-  if (size64 != (uint64_t)size)
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_ERROR,
-        _(
-          "Recursive downloads of directories larger than 4 GB are not supported on 32-bit systems\n"));
-      return;
-    }
+  size64 = GNUNET_FS_uri_chk_get_file_size (dc->uri);
+  size = (size_t) size64;
+  if (size64 != (uint64_t) size)
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_ERROR,
+      _ (
+        "Recursive downloads of directories larger than 4 GB are not supported on 32-bit systems\n"));
+    return;
+  }
   if (NULL != dc->filename)
-    {
-      h = GNUNET_DISK_file_open(dc->filename,
-                                GNUNET_DISK_OPEN_READ,
-                                GNUNET_DISK_PERM_NONE);
-    }
+  {
+    h = GNUNET_DISK_file_open (dc->filename,
+                               GNUNET_DISK_OPEN_READ,
+                               GNUNET_DISK_PERM_NONE);
+  }
   else
-    {
-      GNUNET_assert(NULL != dc->temp_filename);
-      h = GNUNET_DISK_file_open(dc->temp_filename,
-                                GNUNET_DISK_OPEN_READ,
-                                GNUNET_DISK_PERM_NONE);
-    }
+  {
+    GNUNET_assert (NULL != dc->temp_filename);
+    h = GNUNET_DISK_file_open (dc->temp_filename,
+                               GNUNET_DISK_OPEN_READ,
+                               GNUNET_DISK_PERM_NONE);
+  }
   if (NULL == h)
     return; /* oops */
-  data = GNUNET_DISK_file_map(h, &m, GNUNET_DISK_MAP_TYPE_READ, size);
+  data = GNUNET_DISK_file_map (h, &m, GNUNET_DISK_MAP_TYPE_READ, size);
   if (NULL == data)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Directory too large for system address space\n"));
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Directory too large for system address space\n"));
+  }
   else
-    {
-      if (GNUNET_OK !=
-          GNUNET_FS_directory_list_contents(size,
-                                            data,
-                                            0,
-                                            &trigger_recursive_download,
-                                            dc))
-        {
-          GNUNET_log(
-            GNUNET_ERROR_TYPE_WARNING,
-            _(
-              "Failed to access full directroy contents of `%s' for recursive download\n"),
-            dc->filename);
-        }
-      GNUNET_DISK_file_unmap(m);
-    }
-  GNUNET_DISK_file_close(h);
+  {
+    if (GNUNET_OK !=
+        GNUNET_FS_directory_list_contents (size,
+                                           data,
+                                           0,
+                                           &trigger_recursive_download,
+                                           dc))
+    {
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_WARNING,
+        _ (
+          "Failed to access full directroy contents of `%s' for recursive download\n"),
+        dc->filename);
+    }
+    GNUNET_DISK_file_unmap (m);
+  }
+  GNUNET_DISK_file_close (h);
   if (NULL == dc->filename)
-    {
-      if (0 != unlink(dc->temp_filename))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                                 "unlink",
-                                 dc->temp_filename);
-      GNUNET_free(dc->temp_filename);
-      dc->temp_filename = NULL;
-    }
+  {
+    if (0 != unlink (dc->temp_filename))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                "unlink",
+                                dc->temp_filename);
+    GNUNET_free (dc->temp_filename);
+    dc->temp_filename = NULL;
+  }
 }
 
 
@@ -371,48 +372,48 @@ full_recursive_download(struct GNUNET_FS_DownloadContext *dc)
  * @param dc download to check for completion of children
  */
 static void
-check_completed(struct GNUNET_FS_DownloadContext *dc)
+check_completed (struct GNUNET_FS_DownloadContext *dc)
 {
   struct GNUNET_FS_ProgressInfo pi;
   struct GNUNET_FS_DownloadContext *pos;
 
   /* first, check if we need to download children */
-  if (is_recursive_download(dc))
-    full_recursive_download(dc);
+  if (is_recursive_download (dc))
+    full_recursive_download (dc);
   /* then, check if children are done already */
   for (pos = dc->child_head; NULL != pos; pos = pos->next)
-    {
-      if ((NULL == pos->emsg) && (pos->completed < pos->length))
-        return; /* not done yet */
-      if ((NULL != pos->child_head) && (pos->has_finished != GNUNET_YES))
-        return; /* not transitively done yet */
-    }
+  {
+    if ((NULL == pos->emsg) && (pos->completed < pos->length))
+      return;   /* not done yet */
+    if ((NULL != pos->child_head) && (pos->has_finished != GNUNET_YES))
+      return;   /* not transitively done yet */
+  }
   /* All of our children are done, so mark this download done */
   dc->has_finished = GNUNET_YES;
   if (NULL != dc->job_queue)
-    {
-      GNUNET_FS_dequeue_(dc->job_queue);
-      dc->job_queue = NULL;
-    }
+  {
+    GNUNET_FS_dequeue_ (dc->job_queue);
+    dc->job_queue = NULL;
+  }
   if (NULL != dc->task)
-    {
-      GNUNET_SCHEDULER_cancel(dc->task);
-      dc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (dc->task);
+    dc->task = NULL;
+  }
   if (NULL != dc->rfh)
-    {
-      GNUNET_break(GNUNET_OK == GNUNET_DISK_file_close(dc->rfh));
-      dc->rfh = NULL;
-    }
-  GNUNET_FS_download_sync_(dc);
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (dc->rfh));
+    dc->rfh = NULL;
+  }
+  GNUNET_FS_download_sync_ (dc);
 
   /* signal completion */
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_COMPLETED;
-  GNUNET_FS_download_make_status_(&pi, dc);
+  GNUNET_FS_download_make_status_ (&pi, dc);
 
   /* let parent know */
   if (NULL != dc->parent)
-    check_completed(dc->parent);
+    check_completed (dc->parent);
 }
 
 
@@ -427,10 +428,10 @@ check_completed(struct GNUNET_FS_DownloadContext *dc)
  * @param data_len number of bytes in data
  */
 static void
-try_match_block(struct GNUNET_FS_DownloadContext *dc,
-                struct DownloadRequest *dr,
-                const char *data,
-                size_t data_len)
+try_match_block (struct GNUNET_FS_DownloadContext *dc,
+                 struct DownloadRequest *dr,
+                 const char *data,
+                 size_t data_len)
 {
   struct GNUNET_FS_ProgressInfo pi;
   unsigned int i;
@@ -452,130 +453,130 @@ try_match_block(struct GNUNET_FS_DownloadContext *dc,
   if (BRS_DOWNLOAD_UP == dr->state)
     return;
   if (dr->depth > 0)
-    {
-      if ((dc->offset > 0) ||
-          (dc->length < GNUNET_ntohll(dc->uri->data.chk.file_length)))
-        {
-          /* NOTE: this test is not tight, but should suffice; the issue
-             here is that 'dr->num_children' may inherently only specify a
-             smaller range than what is in the original file;
-             thus, reconstruction of (some) inner blocks will fail.
-             FIXME: we might eventually want to write a tighter test to
-             maximize the circumstances under which we do succeed with
-             IBlock reconstruction. (need good tests though). */
-          return;
-        }
-      complete = GNUNET_YES;
-      for (i = 0; i < dr->num_children; i++)
-        {
-          drc = dr->children[i];
-          try_match_block(dc, drc, data, data_len);
-          if (drc->state != BRS_RECONSTRUCT_META_UP)
-            complete = GNUNET_NO;
-          else
-            chks[i] = drc->chk;
-        }
-      if (GNUNET_YES != complete)
-        return;
-      data = (const char *)chks;
-      dlen = dr->num_children * sizeof(struct ContentHashKey);
+  {
+    if ((dc->offset > 0) ||
+        (dc->length < GNUNET_ntohll (dc->uri->data.chk.file_length)))
+    {
+      /* NOTE: this test is not tight, but should suffice; the issue
+         here is that 'dr->num_children' may inherently only specify a
+         smaller range than what is in the original file;
+         thus, reconstruction of (some) inner blocks will fail.
+         FIXME: we might eventually want to write a tighter test to
+         maximize the circumstances under which we do succeed with
+         IBlock reconstruction. (need good tests though). */
+      return;
     }
-  else
+    complete = GNUNET_YES;
+    for (i = 0; i < dr->num_children; i++)
     {
-      if (dr->offset > data_len)
-        return; /* oops */
-      dlen = GNUNET_MIN(data_len - dr->offset, DBLOCK_SIZE);
+      drc = dr->children[i];
+      try_match_block (dc, drc, data, data_len);
+      if (drc->state != BRS_RECONSTRUCT_META_UP)
+        complete = GNUNET_NO;
+      else
+        chks[i] = drc->chk;
     }
-  GNUNET_CRYPTO_hash(&data[dr->offset], dlen, &in_chk.key);
-  GNUNET_CRYPTO_hash_to_aes_key(&in_chk.key, &sk, &iv);
-  if (-1 ==
-      GNUNET_CRYPTO_symmetric_encrypt(&data[dr->offset], dlen, &sk, &iv, enc))
-    {
-      GNUNET_break(0);
+    if (GNUNET_YES != complete)
       return;
-    }
-  GNUNET_CRYPTO_hash(enc, dlen, &in_chk.query);
+    data = (const char *) chks;
+    dlen = dr->num_children * sizeof(struct ContentHashKey);
+  }
+  else
+  {
+    if (dr->offset > data_len)
+      return;   /* oops */
+    dlen = GNUNET_MIN (data_len - dr->offset, DBLOCK_SIZE);
+  }
+  GNUNET_CRYPTO_hash (&data[dr->offset], dlen, &in_chk.key);
+  GNUNET_CRYPTO_hash_to_aes_key (&in_chk.key, &sk, &iv);
+  if (-1 ==
+      GNUNET_CRYPTO_symmetric_encrypt (&data[dr->offset], dlen, &sk, &iv, enc))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_CRYPTO_hash (enc, dlen, &in_chk.query);
   switch (dr->state)
-    {
-    case BRS_INIT:
-      dr->chk = in_chk;
-      dr->state = BRS_RECONSTRUCT_META_UP;
-      break;
-
-    case BRS_CHK_SET:
-      if (0 != memcmp(&in_chk, &dr->chk, sizeof(struct ContentHashKey)))
-        {
-          /* other peer provided bogus meta data */
-          GNUNET_break_op(0);
-          break;
-        }
-      /* write block to disk */
-      fn = (NULL != dc->filename) ? dc->filename : dc->temp_filename;
-      if (NULL != fn)
-        {
-          fh = GNUNET_DISK_file_open(fn,
-                                     GNUNET_DISK_OPEN_READWRITE |
-                                     GNUNET_DISK_OPEN_CREATE |
-                                     GNUNET_DISK_OPEN_TRUNCATE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE |
-                                     GNUNET_DISK_PERM_GROUP_READ |
-                                     GNUNET_DISK_PERM_OTHER_READ);
-          if (NULL == fh)
-            {
-              GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "open", fn);
-              GNUNET_asprintf(&dc->emsg,
-                              _("Failed to open file `%s' for writing"),
-                              fn);
-              GNUNET_DISK_file_close(fh);
-              dr->state = BRS_ERROR;
-              pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
-              pi.value.download.specifics.error.message = dc->emsg;
-              GNUNET_FS_download_make_status_(&pi, dc);
-              return;
-            }
-          if (data_len != GNUNET_DISK_file_write(fh, odata, odata_len))
-            {
-              GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "write", fn);
-              GNUNET_asprintf(&dc->emsg,
-                              _("Failed to open file `%s' for writing"),
-                              fn);
-              GNUNET_DISK_file_close(fh);
-              dr->state = BRS_ERROR;
-              pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
-              pi.value.download.specifics.error.message = dc->emsg;
-              GNUNET_FS_download_make_status_(&pi, dc);
-              return;
-            }
-          GNUNET_DISK_file_close(fh);
-        }
-      /* signal success */
-      dr->state = BRS_DOWNLOAD_UP;
-      dc->completed = dc->length;
-      GNUNET_FS_download_sync_(dc);
-      pi.status = GNUNET_FS_STATUS_DOWNLOAD_PROGRESS;
-      pi.value.download.specifics.progress.data = data;
-      pi.value.download.specifics.progress.offset = 0;
-      pi.value.download.specifics.progress.data_len = dlen;
-      pi.value.download.specifics.progress.depth = 0;
-      pi.value.download.specifics.progress.respect_offered = 0;
-      pi.value.download.specifics.progress.block_download_duration =
-        GNUNET_TIME_UNIT_ZERO;
-      GNUNET_FS_download_make_status_(&pi, dc);
-      if ((NULL != dc->filename) &&
-          (0 != truncate(dc->filename,
-                         GNUNET_ntohll(dc->uri->data.chk.file_length))))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                                 "truncate",
-                                 dc->filename);
-      check_completed(dc);
-      break;
+  {
+  case BRS_INIT:
+    dr->chk = in_chk;
+    dr->state = BRS_RECONSTRUCT_META_UP;
+    break;
 
-    default:
-      /* how did we get here? */
-      GNUNET_break(0);
+  case BRS_CHK_SET:
+    if (0 != memcmp (&in_chk, &dr->chk, sizeof(struct ContentHashKey)))
+    {
+      /* other peer provided bogus meta data */
+      GNUNET_break_op (0);
       break;
     }
+    /* write block to disk */
+    fn = (NULL != dc->filename) ? dc->filename : dc->temp_filename;
+    if (NULL != fn)
+    {
+      fh = GNUNET_DISK_file_open (fn,
+                                  GNUNET_DISK_OPEN_READWRITE
+                                  | GNUNET_DISK_OPEN_CREATE
+                                  | GNUNET_DISK_OPEN_TRUNCATE,
+                                  GNUNET_DISK_PERM_USER_READ
+                                  | GNUNET_DISK_PERM_USER_WRITE
+                                  | GNUNET_DISK_PERM_GROUP_READ
+                                  | GNUNET_DISK_PERM_OTHER_READ);
+      if (NULL == fh)
+      {
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", fn);
+        GNUNET_asprintf (&dc->emsg,
+                         _ ("Failed to open file `%s' for writing"),
+                         fn);
+        GNUNET_DISK_file_close (fh);
+        dr->state = BRS_ERROR;
+        pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
+        pi.value.download.specifics.error.message = dc->emsg;
+        GNUNET_FS_download_make_status_ (&pi, dc);
+        return;
+      }
+      if (data_len != GNUNET_DISK_file_write (fh, odata, odata_len))
+      {
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "write", fn);
+        GNUNET_asprintf (&dc->emsg,
+                         _ ("Failed to open file `%s' for writing"),
+                         fn);
+        GNUNET_DISK_file_close (fh);
+        dr->state = BRS_ERROR;
+        pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
+        pi.value.download.specifics.error.message = dc->emsg;
+        GNUNET_FS_download_make_status_ (&pi, dc);
+        return;
+      }
+      GNUNET_DISK_file_close (fh);
+    }
+    /* signal success */
+    dr->state = BRS_DOWNLOAD_UP;
+    dc->completed = dc->length;
+    GNUNET_FS_download_sync_ (dc);
+    pi.status = GNUNET_FS_STATUS_DOWNLOAD_PROGRESS;
+    pi.value.download.specifics.progress.data = data;
+    pi.value.download.specifics.progress.offset = 0;
+    pi.value.download.specifics.progress.data_len = dlen;
+    pi.value.download.specifics.progress.depth = 0;
+    pi.value.download.specifics.progress.respect_offered = 0;
+    pi.value.download.specifics.progress.block_download_duration =
+      GNUNET_TIME_UNIT_ZERO;
+    GNUNET_FS_download_make_status_ (&pi, dc);
+    if ((NULL != dc->filename) &&
+        (0 != truncate (dc->filename,
+                        GNUNET_ntohll (dc->uri->data.chk.file_length))))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                "truncate",
+                                dc->filename);
+    check_completed (dc);
+    break;
+
+  default:
+    /* how did we get here? */
+    GNUNET_break (0);
+    break;
+  }
 }
 
 
@@ -598,27 +599,27 @@ try_match_block(struct GNUNET_FS_DownloadContext *dc,
  * @return 0 to continue extracting, 1 to abort
  */
 static int
-match_full_data(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)
+match_full_data (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_FS_DownloadContext *dc = cls;
 
   if (EXTRACTOR_METATYPE_GNUNET_FULL_DATA != type)
     return 0;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Found %u bytes of FD!\n",
-             (unsigned int)data_len);
-  if (GNUNET_FS_uri_chk_get_file_size(dc->uri) != data_len)
-    {
-      GNUNET_break_op(0);
-      return 1; /* bogus meta data */
-    }
-  try_match_block(dc, dc->top_request, data, data_len);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Found %u bytes of FD!\n",
+              (unsigned int) data_len);
+  if (GNUNET_FS_uri_chk_get_file_size (dc->uri) != data_len)
+  {
+    GNUNET_break_op (0);
+    return 1;   /* bogus meta data */
+  }
+  try_match_block (dc, dc->top_request, data, data_len);
   return 1;
 }
 
@@ -630,20 +631,20 @@ match_full_data(void *cls,
  * @param dr download request that is done
  */
 static void
-propagate_up(struct DownloadRequest *dr)
+propagate_up (struct DownloadRequest *dr)
 {
   unsigned int i;
 
   do
-    {
-      dr->state = BRS_DOWNLOAD_UP;
-      dr = dr->parent;
-      if (NULL == dr)
+  {
+    dr->state = BRS_DOWNLOAD_UP;
+    dr = dr->parent;
+    if (NULL == dr)
+      break;
+    for (i = 0; i < dr->num_children; i++)
+      if (dr->children[i]->state != BRS_DOWNLOAD_UP)
         break;
-      for (i = 0; i < dr->num_children; i++)
-        if (dr->children[i]->state != BRS_DOWNLOAD_UP)
-          break;
-    }
+  }
   while (i == dr->num_children);
 }
 
@@ -659,8 +660,8 @@ propagate_up(struct DownloadRequest *dr)
  * @param dr block to reconstruct
  */
 static void
-try_top_down_reconstruction(struct GNUNET_FS_DownloadContext *dc,
-                            struct DownloadRequest *dr)
+try_top_down_reconstruction (struct GNUNET_FS_DownloadContext *dc,
+                             struct DownloadRequest *dr)
 {
   uint64_t off;
   char block[DBLOCK_SIZE];
@@ -673,64 +674,64 @@ try_top_down_reconstruction(struct GNUNET_FS_DownloadContext *dc,
   const struct ContentHashKey *chks;
   int up_done;
 
-  GNUNET_assert(NULL != dc->rfh);
-  GNUNET_assert(BRS_CHK_SET == dr->state);
-  total = GNUNET_FS_uri_chk_get_file_size(dc->uri);
-  GNUNET_assert(dr->depth < dc->treedepth);
-  len = GNUNET_FS_tree_calculate_block_size(total, dr->offset, dr->depth);
-  GNUNET_assert(len <= DBLOCK_SIZE);
-  off = compute_disk_offset(total, dr->offset, dr->depth);
+  GNUNET_assert (NULL != dc->rfh);
+  GNUNET_assert (BRS_CHK_SET == dr->state);
+  total = GNUNET_FS_uri_chk_get_file_size (dc->uri);
+  GNUNET_assert (dr->depth < dc->treedepth);
+  len = GNUNET_FS_tree_calculate_block_size (total, dr->offset, dr->depth);
+  GNUNET_assert (len <= DBLOCK_SIZE);
+  off = compute_disk_offset (total, dr->offset, dr->depth);
   if (dc->old_file_size < off + len)
     return; /* failure */
-  if (off != GNUNET_DISK_file_seek(dc->rfh, off, GNUNET_DISK_SEEK_SET))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "seek", dc->filename);
-      return; /* failure */
-    }
-  if (len != GNUNET_DISK_file_read(dc->rfh, block, len))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "read", dc->filename);
-      return; /* failure */
-    }
-  GNUNET_CRYPTO_hash(block, len, &key);
-  if (0 != memcmp(&key, &dr->chk.key, sizeof(struct GNUNET_HashCode)))
+  if (off != GNUNET_DISK_file_seek (dc->rfh, off, GNUNET_DISK_SEEK_SET))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "seek", dc->filename);
+    return;   /* failure */
+  }
+  if (len != GNUNET_DISK_file_read (dc->rfh, block, len))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "read", dc->filename);
+    return;   /* failure */
+  }
+  GNUNET_CRYPTO_hash (block, len, &key);
+  if (0 != memcmp (&key, &dr->chk.key, sizeof(struct GNUNET_HashCode)))
     return; /* mismatch */
   if (GNUNET_OK !=
-      encrypt_existing_match(dc, &dr->chk, dr, block, len, GNUNET_NO))
+      encrypt_existing_match (dc, &dr->chk, dr, block, len, GNUNET_NO))
+  {
+    /* hash matches but encrypted block does not, really bad */
+    dr->state = BRS_ERROR;
+    /* propagate up */
+    while (NULL != dr->parent)
     {
-      /* hash matches but encrypted block does not, really bad */
+      dr = dr->parent;
       dr->state = BRS_ERROR;
-      /* propagate up */
-      while (NULL != dr->parent)
-        {
-          dr = dr->parent;
-          dr->state = BRS_ERROR;
-        }
-      return;
     }
+    return;
+  }
   /* block matches */
   dr->state = BRS_DOWNLOAD_DOWN;
 
   /* set CHKs for children */
   up_done = GNUNET_YES;
-  chks = (const struct ContentHashKey *)block;
+  chks = (const struct ContentHashKey *) block;
   for (i = 0; i < dr->num_children; i++)
-    {
-      drc = dr->children[i];
-      GNUNET_assert(drc->offset >= dr->offset);
-      child_block_size = GNUNET_FS_tree_compute_tree_size(drc->depth);
-      GNUNET_assert(0 == (drc->offset - dr->offset) % child_block_size);
-      if (BRS_INIT == drc->state)
-        {
-          drc->state = BRS_CHK_SET;
-          drc->chk = chks[drc->chk_idx];
-          try_top_down_reconstruction(dc, drc);
-        }
-      if (BRS_DOWNLOAD_UP != drc->state)
-        up_done = GNUNET_NO; /* children not all done */
-    }
+  {
+    drc = dr->children[i];
+    GNUNET_assert (drc->offset >= dr->offset);
+    child_block_size = GNUNET_FS_tree_compute_tree_size (drc->depth);
+    GNUNET_assert (0 == (drc->offset - dr->offset) % child_block_size);
+    if (BRS_INIT == drc->state)
+    {
+      drc->state = BRS_CHK_SET;
+      drc->chk = chks[drc->chk_idx];
+      try_top_down_reconstruction (dc, drc);
+    }
+    if (BRS_DOWNLOAD_UP != drc->state)
+      up_done = GNUNET_NO;   /* children not all done */
+  }
   if (GNUNET_YES == up_done)
-    propagate_up(dr);  /* children all done (or no children...) */
+    propagate_up (dr); /* children all done (or no children...) */
 }
 
 
@@ -743,26 +744,26 @@ try_top_down_reconstruction(struct GNUNET_FS_DownloadContext *dc,
  * @return #GNUNET_OK
  */
 static int
-retry_entry(void *cls, const struct GNUNET_HashCode *key, void *entry)
+retry_entry (void *cls, const struct GNUNET_HashCode *key, void *entry)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct DownloadRequest *dr = entry;
   struct SearchMessage *sm;
   struct GNUNET_MQ_Envelope *env;
 
-  env = GNUNET_MQ_msg(sm, GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
+  env = GNUNET_MQ_msg (sm, GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
   if (0 != (dc->options & GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY))
-    sm->options = htonl(GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY);
+    sm->options = htonl (GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY);
   else
-    sm->options = htonl(GNUNET_FS_SEARCH_OPTION_NONE);
+    sm->options = htonl (GNUNET_FS_SEARCH_OPTION_NONE);
   if (0 == dr->depth)
-    sm->type = htonl(GNUNET_BLOCK_TYPE_FS_DBLOCK);
+    sm->type = htonl (GNUNET_BLOCK_TYPE_FS_DBLOCK);
   else
-    sm->type = htonl(GNUNET_BLOCK_TYPE_FS_IBLOCK);
-  sm->anonymity_level = htonl(dc->anonymity);
+    sm->type = htonl (GNUNET_BLOCK_TYPE_FS_IBLOCK);
+  sm->anonymity_level = htonl (dc->anonymity);
   sm->target = dc->target;
   sm->query = dr->chk.query;
-  GNUNET_MQ_send(dc->mq, env);
+  GNUNET_MQ_send (dc->mq, env);
   return GNUNET_OK;
 }
 
@@ -774,62 +775,62 @@ retry_entry(void *cls, const struct GNUNET_HashCode *key, void *entry)
  * @param dr request to schedule
  */
 static void
-schedule_block_download(struct GNUNET_FS_DownloadContext *dc,
-                        struct DownloadRequest *dr)
+schedule_block_download (struct GNUNET_FS_DownloadContext *dc,
+                         struct DownloadRequest *dr)
 {
   unsigned int i;
 
   switch (dr->state)
-    {
-    case BRS_INIT:
-      GNUNET_assert(0);
-      break;
-
-    case BRS_RECONSTRUCT_DOWN:
-      GNUNET_assert(0);
-      break;
-
-    case BRS_RECONSTRUCT_META_UP:
-      GNUNET_assert(0);
-      break;
-
-    case BRS_RECONSTRUCT_UP:
-      GNUNET_assert(0);
-      break;
-
-    case BRS_CHK_SET:
-      /* normal case, start download */
-      break;
-
-    case BRS_DOWNLOAD_DOWN:
-      for (i = 0; i < dr->num_children; i++)
-        schedule_block_download(dc, dr->children[i]);
-      return;
+  {
+  case BRS_INIT:
+    GNUNET_assert (0);
+    break;
+
+  case BRS_RECONSTRUCT_DOWN:
+    GNUNET_assert (0);
+    break;
+
+  case BRS_RECONSTRUCT_META_UP:
+    GNUNET_assert (0);
+    break;
+
+  case BRS_RECONSTRUCT_UP:
+    GNUNET_assert (0);
+    break;
+
+  case BRS_CHK_SET:
+    /* normal case, start download */
+    break;
+
+  case BRS_DOWNLOAD_DOWN:
+    for (i = 0; i < dr->num_children; i++)
+      schedule_block_download (dc, dr->children[i]);
+    return;
 
-    case BRS_DOWNLOAD_UP:
-      /* We're done! */
-      return;
+  case BRS_DOWNLOAD_UP:
+    /* We're done! */
+    return;
 
-    case BRS_ERROR:
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Scheduling download at offset %llu and depth %u for `%s'\n",
-             (unsigned long long)dr->offset,
-             dr->depth,
-             GNUNET_h2s(&dr->chk.query));
-  if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains_value(dc->active,
-                                                                &dr->chk.query,
-                                                                dr))
+  case BRS_ERROR:
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Scheduling download at offset %llu and depth %u for `%s'\n",
+              (unsigned long long) dr->offset,
+              dr->depth,
+              GNUNET_h2s (&dr->chk.query));
+  if (GNUNET_NO != GNUNET_CONTAINER_multihashmap_contains_value (dc->active,
+                                                                 &dr->chk.query,
+                                                                 dr))
     return; /* already active */
-  GNUNET_CONTAINER_multihashmap_put(dc->active,
-                                    &dr->chk.query,
-                                    dr,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_CONTAINER_multihashmap_put (dc->active,
+                                     &dr->chk.query,
+                                     dr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   if (NULL == dc->mq)
     return; /* download not active */
-  retry_entry(dc, &dr->chk.query, dr);
+  retry_entry (dc, &dr->chk.query, dr);
 }
 
 
@@ -847,12 +848,12 @@ schedule_block_download(struct GNUNET_FS_DownloadContext *dc,
  * @param data contents of the file (or NULL if they were not inlined)
  */
 static void
-trigger_recursive_download(void *cls,
-                           const char *filename,
-                           const struct GNUNET_FS_Uri *uri,
-                           const struct GNUNET_CONTAINER_MetaData *meta,
-                           size_t length,
-                           const void *data)
+trigger_recursive_download (void *cls,
+                            const char *filename,
+                            const struct GNUNET_FS_Uri *uri,
+                            const struct GNUNET_CONTAINER_MetaData *meta,
+                            size_t length,
+                            const void *data)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_DownloadContext *cpos;
@@ -869,121 +870,121 @@ trigger_recursive_download(void *cls,
     return; /* entry for the directory itself */
   cpos = dc->child_head;
   while (NULL != cpos)
-    {
-      if ((GNUNET_FS_uri_test_equal(uri, cpos->uri)) ||
-          ((NULL != filename) && (0 == strcmp(cpos->filename, filename))))
-        break;
-      cpos = cpos->next;
-    }
+  {
+    if ((GNUNET_FS_uri_test_equal (uri, cpos->uri)) ||
+        ((NULL != filename) && (0 == strcmp (cpos->filename, filename))))
+      break;
+    cpos = cpos->next;
+  }
   if (NULL != cpos)
     return; /* already exists */
   fn = NULL;
   if (NULL == filename)
-    {
-      fn = GNUNET_FS_meta_data_suggest_filename(meta);
-      if (NULL == fn)
-        {
-          us = GNUNET_FS_uri_to_string(uri);
-          fn = GNUNET_strdup(&us[strlen(GNUNET_FS_URI_CHK_PREFIX)]);
-          GNUNET_free(us);
-        }
-      else if ('.' == fn[0])
-        {
-          ext = fn;
-          us = GNUNET_FS_uri_to_string(uri);
-          GNUNET_asprintf(&fn,
-                          "%s%s",
-                          &us[strlen(GNUNET_FS_URI_CHK_PREFIX)],
-                          ext);
-          GNUNET_free(ext);
-          GNUNET_free(us);
-        }
-      /* change '\' to '/' (this should have happened
-       * during insertion, but malicious peers may
-       * not have done this) */
-      while (NULL != (pos = strstr(fn, "\\")))
-        *pos = '/';
-      /* remove '../' everywhere (again, well-behaved
-       * peers don't do this, but don't trust that
-       * we did not get something nasty) */
-      while (NULL != (pos = strstr(fn, "../")))
-        {
-          pos[0] = '_';
-          pos[1] = '_';
-          pos[2] = '_';
-        }
-      filename = fn;
-    }
+  {
+    fn = GNUNET_FS_meta_data_suggest_filename (meta);
+    if (NULL == fn)
+    {
+      us = GNUNET_FS_uri_to_string (uri);
+      fn = GNUNET_strdup (&us[strlen (GNUNET_FS_URI_CHK_PREFIX)]);
+      GNUNET_free (us);
+    }
+    else if ('.' == fn[0])
+    {
+      ext = fn;
+      us = GNUNET_FS_uri_to_string (uri);
+      GNUNET_asprintf (&fn,
+                       "%s%s",
+                       &us[strlen (GNUNET_FS_URI_CHK_PREFIX)],
+                       ext);
+      GNUNET_free (ext);
+      GNUNET_free (us);
+    }
+    /* change '\' to '/' (this should have happened
+     * during insertion, but malicious peers may
+     * not have done this) */
+    while (NULL != (pos = strstr (fn, "\\")))
+      *pos = '/';
+    /* remove '../' everywhere (again, well-behaved
+     * peers don't do this, but don't trust that
+     * we did not get something nasty) */
+    while (NULL != (pos = strstr (fn, "../")))
+    {
+      pos[0] = '_';
+      pos[1] = '_';
+      pos[2] = '_';
+    }
+    filename = fn;
+  }
   if (NULL == dc->filename)
-    {
-      full_name = NULL;
-    }
+  {
+    full_name = NULL;
+  }
   else
-    {
-      dn = GNUNET_strdup(dc->filename);
-      GNUNET_break(
-        (strlen(dn) >= strlen(GNUNET_FS_DIRECTORY_EXT)) &&
-        (NULL != strstr(dn + strlen(dn) - strlen(GNUNET_FS_DIRECTORY_EXT),
-                        GNUNET_FS_DIRECTORY_EXT)));
-      sfn = GNUNET_strdup(filename);
-      while ((strlen(sfn) > 0) && ('/' == filename[strlen(sfn) - 1]))
-        sfn[strlen(sfn) - 1] = '\0';
-      if ((strlen(dn) >= strlen(GNUNET_FS_DIRECTORY_EXT)) &&
-          (NULL != strstr(dn + strlen(dn) - strlen(GNUNET_FS_DIRECTORY_EXT),
-                          GNUNET_FS_DIRECTORY_EXT)))
-        dn[strlen(dn) - strlen(GNUNET_FS_DIRECTORY_EXT)] = '\0';
-      if ((GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(meta)) &&
-          ((strlen(filename) < strlen(GNUNET_FS_DIRECTORY_EXT)) ||
-           (NULL == strstr(filename + strlen(filename) -
-                           strlen(GNUNET_FS_DIRECTORY_EXT),
-                           GNUNET_FS_DIRECTORY_EXT))))
-        {
-          GNUNET_asprintf(&full_name,
-                          "%s%s%s%s",
-                          dn,
-                          DIR_SEPARATOR_STR,
-                          sfn,
-                          GNUNET_FS_DIRECTORY_EXT);
-        }
-      else
-        {
-          GNUNET_asprintf(&full_name, "%s%s%s", dn, DIR_SEPARATOR_STR, sfn);
-        }
-      GNUNET_free(sfn);
-      GNUNET_free(dn);
-    }
+  {
+    dn = GNUNET_strdup (dc->filename);
+    GNUNET_break (
+      (strlen (dn) >= strlen (GNUNET_FS_DIRECTORY_EXT)) &&
+      (NULL != strstr (dn + strlen (dn) - strlen (GNUNET_FS_DIRECTORY_EXT),
+                       GNUNET_FS_DIRECTORY_EXT)));
+    sfn = GNUNET_strdup (filename);
+    while ((strlen (sfn) > 0) && ('/' == filename[strlen (sfn) - 1]))
+      sfn[strlen (sfn) - 1] = '\0';
+    if ((strlen (dn) >= strlen (GNUNET_FS_DIRECTORY_EXT)) &&
+        (NULL != strstr (dn + strlen (dn) - strlen (GNUNET_FS_DIRECTORY_EXT),
+                         GNUNET_FS_DIRECTORY_EXT)))
+      dn[strlen (dn) - strlen (GNUNET_FS_DIRECTORY_EXT)] = '\0';
+    if ((GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (meta)) &&
+        ((strlen (filename) < strlen (GNUNET_FS_DIRECTORY_EXT)) ||
+         (NULL == strstr (filename + strlen (filename)
+                          - strlen (GNUNET_FS_DIRECTORY_EXT),
+                          GNUNET_FS_DIRECTORY_EXT))))
+    {
+      GNUNET_asprintf (&full_name,
+                       "%s%s%s%s",
+                       dn,
+                       DIR_SEPARATOR_STR,
+                       sfn,
+                       GNUNET_FS_DIRECTORY_EXT);
+    }
+    else
+    {
+      GNUNET_asprintf (&full_name, "%s%s%s", dn, DIR_SEPARATOR_STR, sfn);
+    }
+    GNUNET_free (sfn);
+    GNUNET_free (dn);
+  }
   if ((NULL != full_name) &&
-      (GNUNET_OK != GNUNET_DISK_directory_create_for_file(full_name)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _(
-                   "Failed to create directory for recursive download of `%s'\n"),
-                 full_name);
-      GNUNET_free(full_name);
-      GNUNET_free_non_null(fn);
-      return;
-    }
+      (GNUNET_OK != GNUNET_DISK_directory_create_for_file (full_name)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ (
+                  "Failed to create directory for recursive download of `%s'\n"),
+                full_name);
+    GNUNET_free (full_name);
+    GNUNET_free_non_null (fn);
+    return;
+  }
 
   temp_name = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Triggering recursive download of size %llu with %u bytes MD\n",
-             (unsigned long long)GNUNET_FS_uri_chk_get_file_size(uri),
-             (unsigned int)GNUNET_CONTAINER_meta_data_get_serialized_size(
-               meta));
-  GNUNET_FS_download_start(dc->h,
-                           uri,
-                           meta,
-                           full_name,
-                           temp_name,
-                           0,
-                           GNUNET_FS_uri_chk_get_file_size(uri),
-                           dc->anonymity,
-                           dc->options,
-                           NULL,
-                           dc);
-  GNUNET_free_non_null(full_name);
-  GNUNET_free_non_null(temp_name);
-  GNUNET_free_non_null(fn);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Triggering recursive download of size %llu with %u bytes MD\n",
+              (unsigned long long) GNUNET_FS_uri_chk_get_file_size (uri),
+              (unsigned int) GNUNET_CONTAINER_meta_data_get_serialized_size (
+                meta));
+  GNUNET_FS_download_start (dc->h,
+                            uri,
+                            meta,
+                            full_name,
+                            temp_name,
+                            0,
+                            GNUNET_FS_uri_chk_get_file_size (uri),
+                            dc->anonymity,
+                            dc->options,
+                            NULL,
+                            dc);
+  GNUNET_free_non_null (full_name);
+  GNUNET_free_non_null (temp_name);
+  GNUNET_free_non_null (fn);
 }
 
 
@@ -993,14 +994,14 @@ trigger_recursive_download(void *cls,
  * @param dr request to free
  */
 void
-GNUNET_FS_free_download_request_(struct DownloadRequest *dr)
+GNUNET_FS_free_download_request_ (struct DownloadRequest *dr)
 {
   if (NULL == dr)
     return;
   for (unsigned int i = 0; i < dr->num_children; i++)
-    GNUNET_FS_free_download_request_(dr->children[i]);
-  GNUNET_free_non_null(dr->children);
-  GNUNET_free(dr);
+    GNUNET_FS_free_download_request_ (dr->children[i]);
+  GNUNET_free_non_null (dr->children);
+  GNUNET_free (dr);
 }
 
 
@@ -1014,9 +1015,9 @@ GNUNET_FS_free_download_request_(struct DownloadRequest *dr)
  * @return #GNUNET_YES (we should continue to iterate); unless serious error
  */
 static int
-process_result_with_request(void *cls,
-                            const struct GNUNET_HashCode *key,
-                            void *value)
+process_result_with_request (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             void *value)
 {
   struct ProcessResultClosure *prc = cls;
   struct DownloadRequest *dr = value;
@@ -1033,132 +1034,132 @@ process_result_with_request(void *cls,
   int i;
   struct ContentHashKey *chkarr;
 
-  GNUNET_log(
+  GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "Received %u byte block `%s' matching pending request at depth %u and offset %llu/%llu\n",
-    (unsigned int)prc->size,
-    GNUNET_h2s(key),
+    (unsigned int) prc->size,
+    GNUNET_h2s (key),
     dr->depth,
-    (unsigned long long)dr->offset,
-    (unsigned long long)GNUNET_ntohll(dc->uri->data.chk.file_length));
-  bs = GNUNET_FS_tree_calculate_block_size(GNUNET_ntohll(
-                                             dc->uri->data.chk.file_length),
-                                           dr->offset,
-                                           dr->depth);
+    (unsigned long long) dr->offset,
+    (unsigned long long) GNUNET_ntohll (dc->uri->data.chk.file_length));
+  bs = GNUNET_FS_tree_calculate_block_size (GNUNET_ntohll (
+                                              dc->uri->data.chk.file_length),
+                                            dr->offset,
+                                            dr->depth);
   if (prc->size != bs)
+  {
+    GNUNET_asprintf (
+      &dc->emsg,
+      _ (
+        "Internal error or bogus download URI (expected %u bytes at depth %u and offset %llu/%llu, got %u bytes)"),
+      bs,
+      dr->depth,
+      (unsigned long long) dr->offset,
+      (unsigned long long) GNUNET_ntohll (dc->uri->data.chk.file_length),
+      prc->size);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "%s\n", dc->emsg);
+    while (NULL != dr->parent)
     {
-      GNUNET_asprintf(
-        &dc->emsg,
-        _(
-          "Internal error or bogus download URI (expected %u bytes at depth %u and offset %llu/%llu, got %u bytes)"),
-        bs,
-        dr->depth,
-        (unsigned long long)dr->offset,
-        (unsigned long long)GNUNET_ntohll(dc->uri->data.chk.file_length),
-        prc->size);
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "%s\n", dc->emsg);
-      while (NULL != dr->parent)
-        {
-          dr->state = BRS_ERROR;
-          dr = dr->parent;
-        }
       dr->state = BRS_ERROR;
-      goto signal_error;
+      dr = dr->parent;
     }
+    dr->state = BRS_ERROR;
+    goto signal_error;
+  }
 
-  (void)GNUNET_CONTAINER_multihashmap_remove(dc->active, &prc->query, dr);
-  GNUNET_CRYPTO_hash_to_aes_key(&dr->chk.key, &skey, &iv);
+  (void) GNUNET_CONTAINER_multihashmap_remove (dc->active, &prc->query, dr);
+  GNUNET_CRYPTO_hash_to_aes_key (&dr->chk.key, &skey, &iv);
   if (-1 ==
-      GNUNET_CRYPTO_symmetric_decrypt(prc->data, prc->size, &skey, &iv, pt))
-    {
-      GNUNET_break(0);
-      dc->emsg = GNUNET_strdup(_("internal error decrypting content"));
-      goto signal_error;
-    }
-  off = compute_disk_offset(GNUNET_ntohll(dc->uri->data.chk.file_length),
-                            dr->offset,
-                            dr->depth);
+      GNUNET_CRYPTO_symmetric_decrypt (prc->data, prc->size, &skey, &iv, pt))
+  {
+    GNUNET_break (0);
+    dc->emsg = GNUNET_strdup (_ ("internal error decrypting content"));
+    goto signal_error;
+  }
+  off = compute_disk_offset (GNUNET_ntohll (dc->uri->data.chk.file_length),
+                             dr->offset,
+                             dr->depth);
   /* save to disk */
   if ((GNUNET_YES == prc->do_store) &&
-      ((NULL != dc->filename) || (is_recursive_download(dc))) &&
+      ((NULL != dc->filename) || (is_recursive_download (dc))) &&
       ((dr->depth == dc->treedepth) ||
        (0 == (dc->options & GNUNET_FS_DOWNLOAD_NO_TEMPORARIES))))
+  {
+    fh = GNUNET_DISK_file_open (NULL != dc->filename ? dc->filename
+                                : dc->temp_filename,
+                                GNUNET_DISK_OPEN_READWRITE
+                                | GNUNET_DISK_OPEN_CREATE,
+                                GNUNET_DISK_PERM_USER_READ
+                                | GNUNET_DISK_PERM_USER_WRITE
+                                | GNUNET_DISK_PERM_GROUP_READ
+                                | GNUNET_DISK_PERM_OTHER_READ);
+    if (NULL == fh)
+    {
+      GNUNET_asprintf (&dc->emsg,
+                       _ ("Download failed: could not open file `%s': %s"),
+                       dc->filename,
+                       strerror (errno));
+      goto signal_error;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Saving decrypted block to disk at offset %llu\n",
+                (unsigned long long) off);
+    if ((off != GNUNET_DISK_file_seek (fh, off, GNUNET_DISK_SEEK_SET)))
     {
-      fh = GNUNET_DISK_file_open(NULL != dc->filename ? dc->filename
-                                 : dc->temp_filename,
-                                 GNUNET_DISK_OPEN_READWRITE |
-                                 GNUNET_DISK_OPEN_CREATE,
-                                 GNUNET_DISK_PERM_USER_READ |
-                                 GNUNET_DISK_PERM_USER_WRITE |
-                                 GNUNET_DISK_PERM_GROUP_READ |
-                                 GNUNET_DISK_PERM_OTHER_READ);
-      if (NULL == fh)
-        {
-          GNUNET_asprintf(&dc->emsg,
-                          _("Download failed: could not open file `%s': %s"),
-                          dc->filename,
-                          strerror(errno));
-          goto signal_error;
-        }
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Saving decrypted block to disk at offset %llu\n",
-                 (unsigned long long)off);
-      if ((off != GNUNET_DISK_file_seek(fh, off, GNUNET_DISK_SEEK_SET)))
-        {
-          GNUNET_asprintf(&dc->emsg,
-                          _("Failed to seek to offset %llu in file `%s': %s"),
-                          (unsigned long long)off,
-                          dc->filename,
-                          strerror(errno));
-          goto signal_error;
-        }
-      if (prc->size != GNUNET_DISK_file_write(fh, pt, prc->size))
-        {
-          GNUNET_asprintf(
-            &dc->emsg,
-            _("Failed to write block of %u bytes at offset %llu in file `%s': %s"),
-            (unsigned int)prc->size,
-            (unsigned long long)off,
-            dc->filename,
-            strerror(errno));
-          goto signal_error;
-        }
-      GNUNET_break(GNUNET_OK == GNUNET_DISK_file_close(fh));
-      fh = NULL;
+      GNUNET_asprintf (&dc->emsg,
+                       _ ("Failed to seek to offset %llu in file `%s': %s"),
+                       (unsigned long long) off,
+                       dc->filename,
+                       strerror (errno));
+      goto signal_error;
     }
-
-  if (0 == dr->depth)
+    if (prc->size != GNUNET_DISK_file_write (fh, pt, prc->size))
     {
-      /* DBLOCK, update progress and try recursion if applicable */
-      app = prc->size;
-      if (dr->offset < dc->offset)
-        {
-          /* starting offset begins in the middle of pt,
-           * do not count first bytes as progress */
-          GNUNET_assert(app > (dc->offset - dr->offset));
-          app -= (dc->offset - dr->offset);
-        }
-      if (dr->offset + prc->size > dc->offset + dc->length)
-        {
-          /* end of block is after relevant range,
-          * do not count last bytes as progress */
-          GNUNET_assert(app >
-                        (dr->offset + prc->size) - (dc->offset + dc->length));
-          app -= (dr->offset + prc->size) - (dc->offset + dc->length);
-        }
-      dc->completed += app;
-
-      /* do recursive download if option is set and either meta data
-       * says it is a directory or if no meta data is given AND filename
-       * ends in '.gnd' (top-level case) */
-      if (is_recursive_download(dc))
-        GNUNET_FS_directory_list_contents(prc->size,
-                                          pt,
-                                          off,
-                                          &trigger_recursive_download,
-                                          dc);
+      GNUNET_asprintf (
+        &dc->emsg,
+        _ ("Failed to write block of %u bytes at offset %llu in file `%s': %s"),
+        (unsigned int) prc->size,
+        (unsigned long long) off,
+        dc->filename,
+        strerror (errno));
+      goto signal_error;
     }
-  GNUNET_assert(dc->completed <= dc->length);
+    GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fh));
+    fh = NULL;
+  }
+
+  if (0 == dr->depth)
+  {
+    /* DBLOCK, update progress and try recursion if applicable */
+    app = prc->size;
+    if (dr->offset < dc->offset)
+    {
+      /* starting offset begins in the middle of pt,
+       * do not count first bytes as progress */
+      GNUNET_assert (app > (dc->offset - dr->offset));
+      app -= (dc->offset - dr->offset);
+    }
+    if (dr->offset + prc->size > dc->offset + dc->length)
+    {
+      /* end of block is after relevant range,
+      * do not count last bytes as progress */
+      GNUNET_assert (app >
+                     (dr->offset + prc->size) - (dc->offset + dc->length));
+      app -= (dr->offset + prc->size) - (dc->offset + dc->length);
+    }
+    dc->completed += app;
+
+    /* do recursive download if option is set and either meta data
+     * says it is a directory or if no meta data is given AND filename
+     * ends in '.gnd' (top-level case) */
+    if (is_recursive_download (dc))
+      GNUNET_FS_directory_list_contents (prc->size,
+                                         pt,
+                                         off,
+                                         &trigger_recursive_download,
+                                         dc);
+  }
+  GNUNET_assert (dc->completed <= dc->length);
   dr->state = BRS_DOWNLOAD_DOWN;
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_PROGRESS;
   pi.value.download.specifics.progress.data = pt;
@@ -1171,120 +1172,120 @@ process_result_with_request(void *cls,
   if (prc->last_transmission.abs_value_us !=
       GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)
     pi.value.download.specifics.progress.block_download_duration =
-      GNUNET_TIME_absolute_get_duration(prc->last_transmission);
+      GNUNET_TIME_absolute_get_duration (prc->last_transmission);
   else
     pi.value.download.specifics.progress.block_download_duration =
       GNUNET_TIME_UNIT_ZERO; /* found locally */
-  GNUNET_FS_download_make_status_(&pi, dc);
+  GNUNET_FS_download_make_status_ (&pi, dc);
   if (0 == dr->depth)
-    propagate_up(dr);
+    propagate_up (dr);
 
   if (dc->completed == dc->length)
-    {
-      /* download completed, signal */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Download completed, truncating file to desired length %llu\n",
-                 (unsigned long long)GNUNET_ntohll(
-                   dc->uri->data.chk.file_length));
-      /* truncate file to size (since we store IBlocks at the end) */
-      if (NULL != dc->filename)
-        {
-          if (0 != truncate(dc->filename,
-                            GNUNET_ntohll(dc->uri->data.chk.file_length)))
-            GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                                     "truncate",
-                                     dc->filename);
-        }
-      GNUNET_assert(0 == dr->depth);
-      check_completed(dc);
-    }
+  {
+    /* download completed, signal */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Download completed, truncating file to desired length %llu\n",
+                (unsigned long long) GNUNET_ntohll (
+                  dc->uri->data.chk.file_length));
+    /* truncate file to size (since we store IBlocks at the end) */
+    if (NULL != dc->filename)
+    {
+      if (0 != truncate (dc->filename,
+                         GNUNET_ntohll (dc->uri->data.chk.file_length)))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                  "truncate",
+                                  dc->filename);
+    }
+    GNUNET_assert (0 == dr->depth);
+    check_completed (dc);
+  }
   if (0 == dr->depth)
-    {
-      /* bottom of the tree, no child downloads possible, just sync */
-      GNUNET_FS_download_sync_(dc);
-      return GNUNET_YES;
-    }
+  {
+    /* bottom of the tree, no child downloads possible, just sync */
+    GNUNET_FS_download_sync_ (dc);
+    return GNUNET_YES;
+  }
 
-  GNUNET_log(
+  GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "Triggering downloads of children (this block was at depth %u and offset %llu)\n",
     dr->depth,
-    (unsigned long long)dr->offset);
-  GNUNET_assert(0 == (prc->size % sizeof(struct ContentHashKey)));
-  chkarr = (struct ContentHashKey *)pt;
+    (unsigned long long) dr->offset);
+  GNUNET_assert (0 == (prc->size % sizeof(struct ContentHashKey)));
+  chkarr = (struct ContentHashKey *) pt;
   for (i = dr->num_children - 1; i >= 0; i--)
+  {
+    drc = dr->children[i];
+    switch (drc->state)
     {
-      drc = dr->children[i];
-      switch (drc->state)
-        {
-        case BRS_INIT:
-          if ((drc->chk_idx + 1) * sizeof(struct ContentHashKey) > prc->size)
-            {
-              /* 'chkarr' does not have enough space for this chk_idx;
-                 internal error! */
-              GNUNET_break(0);
-              GNUNET_assert(0);
-              dc->emsg = GNUNET_strdup(_("internal error decoding tree"));
-              goto signal_error;
-            }
-          drc->chk = chkarr[drc->chk_idx];
-          drc->state = BRS_CHK_SET;
-          if (GNUNET_YES == dc->issue_requests)
-            schedule_block_download(dc, drc);
-          break;
-
-        case BRS_RECONSTRUCT_DOWN:
-          GNUNET_assert(0);
-          break;
-
-        case BRS_RECONSTRUCT_META_UP:
-          GNUNET_assert(0);
-          break;
-
-        case BRS_RECONSTRUCT_UP:
-          GNUNET_assert(0);
-          break;
-
-        case BRS_CHK_SET:
-          GNUNET_assert(0);
-          break;
-
-        case BRS_DOWNLOAD_DOWN:
-          GNUNET_assert(0);
-          break;
-
-        case BRS_DOWNLOAD_UP:
-          GNUNET_assert(0);
-          break;
-
-        case BRS_ERROR:
-          GNUNET_assert(0);
-          break;
-
-        default:
-          GNUNET_assert(0);
-          break;
-        }
+    case BRS_INIT:
+      if ((drc->chk_idx + 1) * sizeof(struct ContentHashKey) > prc->size)
+      {
+        /* 'chkarr' does not have enough space for this chk_idx;
+           internal error! */
+        GNUNET_break (0);
+        GNUNET_assert (0);
+        dc->emsg = GNUNET_strdup (_ ("internal error decoding tree"));
+        goto signal_error;
+      }
+      drc->chk = chkarr[drc->chk_idx];
+      drc->state = BRS_CHK_SET;
+      if (GNUNET_YES == dc->issue_requests)
+        schedule_block_download (dc, drc);
+      break;
+
+    case BRS_RECONSTRUCT_DOWN:
+      GNUNET_assert (0);
+      break;
+
+    case BRS_RECONSTRUCT_META_UP:
+      GNUNET_assert (0);
+      break;
+
+    case BRS_RECONSTRUCT_UP:
+      GNUNET_assert (0);
+      break;
+
+    case BRS_CHK_SET:
+      GNUNET_assert (0);
+      break;
+
+    case BRS_DOWNLOAD_DOWN:
+      GNUNET_assert (0);
+      break;
+
+    case BRS_DOWNLOAD_UP:
+      GNUNET_assert (0);
+      break;
+
+    case BRS_ERROR:
+      GNUNET_assert (0);
+      break;
+
+    default:
+      GNUNET_assert (0);
+      break;
     }
-  GNUNET_FS_download_sync_(dc);
+  }
+  GNUNET_FS_download_sync_ (dc);
   return GNUNET_YES;
 
 signal_error:
   if (NULL != fh)
-    GNUNET_DISK_file_close(fh);
+    GNUNET_DISK_file_close (fh);
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
   pi.value.download.specifics.error.message = dc->emsg;
-  GNUNET_FS_download_make_status_(&pi, dc);
-  GNUNET_MQ_destroy(dc->mq);
+  GNUNET_FS_download_make_status_ (&pi, dc);
+  GNUNET_MQ_destroy (dc->mq);
   dc->mq = NULL;
-  GNUNET_FS_free_download_request_(dc->top_request);
+  GNUNET_FS_free_download_request_ (dc->top_request);
   dc->top_request = NULL;
   if (NULL != dc->job_queue)
-    {
-      GNUNET_FS_dequeue_(dc->job_queue);
-      dc->job_queue = NULL;
-    }
-  GNUNET_FS_download_sync_(dc);
+  {
+    GNUNET_FS_dequeue_ (dc->job_queue);
+    dc->job_queue = NULL;
+  }
+  GNUNET_FS_download_sync_ (dc);
   return GNUNET_NO;
 }
 
@@ -1297,7 +1298,7 @@ signal_error:
  * @param msg message received
  */
 static int
-check_put(void *cls, const struct ClientPutMessage *cm)
+check_put (void *cls, const struct ClientPutMessage *cm)
 {
   /* any varsize length is OK */
   return GNUNET_OK;
@@ -1312,28 +1313,28 @@ check_put(void *cls, const struct ClientPutMessage *cm)
  * @param msg message received
  */
 static void
-handle_put(void *cls, const struct ClientPutMessage *cm)
+handle_put (void *cls, const struct ClientPutMessage *cm)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
-  uint16_t msize = ntohs(cm->header.size) - sizeof(*cm);
+  uint16_t msize = ntohs (cm->header.size) - sizeof(*cm);
   struct ProcessResultClosure prc;
 
   prc.dc = dc;
   prc.data = &cm[1];
-  prc.last_transmission = GNUNET_TIME_absolute_ntoh(cm->last_transmission);
+  prc.last_transmission = GNUNET_TIME_absolute_ntoh (cm->last_transmission);
   prc.size = msize;
-  prc.type = ntohl(cm->type);
+  prc.type = ntohl (cm->type);
   prc.do_store = GNUNET_YES;
-  prc.respect_offered = ntohl(cm->respect_offered);
-  prc.num_transmissions = ntohl(cm->num_transmissions);
-  GNUNET_CRYPTO_hash(prc.data, msize, &prc.query);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received result for query `%s' from FS service\n",
-             GNUNET_h2s(&prc.query));
-  GNUNET_CONTAINER_multihashmap_get_multiple(dc->active,
-                                             &prc.query,
-                                             &process_result_with_request,
-                                             &prc);
+  prc.respect_offered = ntohl (cm->respect_offered);
+  prc.num_transmissions = ntohl (cm->num_transmissions);
+  GNUNET_CRYPTO_hash (prc.data, msize, &prc.query);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received result for query `%s' from FS service\n",
+              GNUNET_h2s (&prc.query));
+  GNUNET_CONTAINER_multihashmap_get_multiple (dc->active,
+                                              &prc.query,
+                                              &process_result_with_request,
+                                              &prc);
 }
 
 
@@ -1346,18 +1347,18 @@ handle_put(void *cls, const struct ClientPutMessage *cm)
  * @param error error code
  */
 static void
-download_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
+download_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
 
   if (NULL != dc->mq)
-    {
-      GNUNET_MQ_destroy(dc->mq);
-      dc->mq = NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Transmitting download request failed, trying to reconnect\n");
-  try_reconnect(dc);
+  {
+    GNUNET_MQ_destroy (dc->mq);
+    dc->mq = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transmitting download request failed, trying to reconnect\n");
+  try_reconnect (dc);
 }
 
 
@@ -1367,31 +1368,31 @@ download_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
  * @param cls our download context
  */
 static void
-do_reconnect(void *cls)
+do_reconnect (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_MQ_MessageHandler handlers[] =
-  { GNUNET_MQ_hd_var_size(put,
-                          GNUNET_MESSAGE_TYPE_FS_PUT,
-                          struct ClientPutMessage,
-                          dc),
-    GNUNET_MQ_handler_end() };
+  { GNUNET_MQ_hd_var_size (put,
+                           GNUNET_MESSAGE_TYPE_FS_PUT,
+                           struct ClientPutMessage,
+                           dc),
+    GNUNET_MQ_handler_end () };
 
   dc->task = NULL;
-  dc->mq = GNUNET_CLIENT_connect(dc->h->cfg,
-                                 "fs",
-                                 handlers,
-                                 &download_mq_error_handler,
-                                 dc);
+  dc->mq = GNUNET_CLIENT_connect (dc->h->cfg,
+                                  "fs",
+                                  handlers,
+                                  &download_mq_error_handler,
+                                  dc);
   if (NULL == dc->mq)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 "Connecting to `%s'-service failed, will try again.\n",
-                 "FS");
-      try_reconnect(dc);
-      return;
-    }
-  GNUNET_CONTAINER_multihashmap_iterate(dc->active, &retry_entry, dc);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Connecting to `%s'-service failed, will try again.\n",
+                "FS");
+    try_reconnect (dc);
+    return;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (dc->active, &retry_entry, dc);
 }
 
 
@@ -1403,27 +1404,27 @@ do_reconnect(void *cls)
  * @param dc download context that is having trouble
  */
 static void
-try_reconnect(struct GNUNET_FS_DownloadContext *dc)
+try_reconnect (struct GNUNET_FS_DownloadContext *dc)
 {
   if (NULL != dc->mq)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Moving all requests back to pending list\n");
-      GNUNET_MQ_destroy(dc->mq);
-      dc->mq = NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Moving all requests back to pending list\n");
+    GNUNET_MQ_destroy (dc->mq);
+    dc->mq = NULL;
+  }
   if (0 == dc->reconnect_backoff.rel_value_us)
     dc->reconnect_backoff = GNUNET_TIME_UNIT_MILLISECONDS;
   else
-    dc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF(dc->reconnect_backoff);
+    dc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (dc->reconnect_backoff);
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Will try to reconnect in %s\n",
-             GNUNET_STRINGS_relative_time_to_string(dc->reconnect_backoff,
-                                                    GNUNET_YES));
-  GNUNET_break(NULL != dc->job_queue);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Will try to reconnect in %s\n",
+              GNUNET_STRINGS_relative_time_to_string (dc->reconnect_backoff,
+                                                      GNUNET_YES));
+  GNUNET_break (NULL != dc->job_queue);
   dc->task =
-    GNUNET_SCHEDULER_add_delayed(dc->reconnect_backoff, &do_reconnect, dc);
+    GNUNET_SCHEDULER_add_delayed (dc->reconnect_backoff, &do_reconnect, dc);
 }
 
 
@@ -1434,18 +1435,18 @@ try_reconnect(struct GNUNET_FS_DownloadContext *dc)
  * @param mq handle to use for communcation with FS (we must destroy it!)
  */
 static void
-activate_fs_download(void *cls)
+activate_fs_download (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
-  GNUNET_assert(NULL == dc->mq);
-  GNUNET_assert(NULL != dc->active);
-  do_reconnect(dc);
+  GNUNET_assert (NULL == dc->mq);
+  GNUNET_assert (NULL != dc->active);
+  do_reconnect (dc);
   if (NULL != dc->mq)
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download activated\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download activated\n");
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_ACTIVE;
-  GNUNET_FS_download_make_status_(&pi, dc);
+  GNUNET_FS_download_make_status_ (&pi, dc);
 }
 
 
@@ -1455,19 +1456,19 @@ activate_fs_download(void *cls)
  * @param cls the `struct GNUNET_FS_DownloadContext`
  */
 static void
-deactivate_fs_download(void *cls)
+deactivate_fs_download (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download deactivated\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download deactivated\n");
   if (NULL != dc->mq)
-    {
-      GNUNET_MQ_destroy(dc->mq);
-      dc->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (dc->mq);
+    dc->mq = NULL;
+  }
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_INACTIVE;
-  GNUNET_FS_download_make_status_(&pi, dc);
+  GNUNET_FS_download_make_status_ (&pi, dc);
 }
 
 
@@ -1491,38 +1492,38 @@ deactivate_fs_download(void *cls)
  *         the specified depth
  */
 static struct DownloadRequest *
-create_download_request(struct DownloadRequest *parent,
-                        unsigned int chk_idx,
-                        unsigned int depth,
-                        uint64_t dr_offset,
-                        uint64_t file_start_offset,
-                        uint64_t desired_length)
+create_download_request (struct DownloadRequest *parent,
+                         unsigned int chk_idx,
+                         unsigned int depth,
+                         uint64_t dr_offset,
+                         uint64_t file_start_offset,
+                         uint64_t desired_length)
 {
   struct DownloadRequest *dr;
   unsigned int i;
   unsigned int head_skip;
   uint64_t child_block_size;
 
-  dr = GNUNET_new(struct DownloadRequest);
+  dr = GNUNET_new (struct DownloadRequest);
   dr->parent = parent;
   dr->depth = depth;
   dr->offset = dr_offset;
   dr->chk_idx = chk_idx;
   if (0 == depth)
     return dr;
-  child_block_size = GNUNET_FS_tree_compute_tree_size(depth - 1);
+  child_block_size = GNUNET_FS_tree_compute_tree_size (depth - 1);
 
   /* calculate how many blocks at this level are not interesting
    * from the start (rounded down), either because of the requested
    * file offset or because this IBlock is further along */
   if (dr_offset < file_start_offset)
-    {
-      head_skip = (file_start_offset - dr_offset) / child_block_size;
-    }
+  {
+    head_skip = (file_start_offset - dr_offset) / child_block_size;
+  }
   else
-    {
-      head_skip = 0;
-    }
+  {
+    head_skip = 0;
+  }
 
   /* calculate index of last block at this level that is interesting (rounded up) */
   dr->num_children =
@@ -1530,32 +1531,32 @@ create_download_request(struct DownloadRequest *parent,
   if (dr->num_children * child_block_size <
       file_start_offset + desired_length - dr_offset)
     dr->num_children++; /* round up */
-  GNUNET_assert(dr->num_children > head_skip);
+  GNUNET_assert (dr->num_children > head_skip);
   dr->num_children -= head_skip;
   if (dr->num_children > CHK_PER_INODE)
     dr->num_children = CHK_PER_INODE; /* cap at max */
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Block at offset %llu and depth %u has %u children\n",
-             (unsigned long long)dr_offset,
-             depth,
-             dr->num_children);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Block at offset %llu and depth %u has %u children\n",
+              (unsigned long long) dr_offset,
+              depth,
+              dr->num_children);
 
   /* now we can get the total number of *interesting* children for this block */
 
   /* why else would we have gotten here to begin with? (that'd be a bad logic error) */
-  GNUNET_assert(dr->num_children > 0);
+  GNUNET_assert (dr->num_children > 0);
 
-  dr->children = GNUNET_new_array(dr->num_children, struct DownloadRequest *);
+  dr->children = GNUNET_new_array (dr->num_children, struct DownloadRequest *);
   for (i = 0; i < dr->num_children; i++)
-    {
-      dr->children[i] =
-        create_download_request(dr,
-                                i + head_skip,
-                                depth - 1,
-                                dr_offset + (i + head_skip) * child_block_size,
-                                file_start_offset,
-                                desired_length);
-    }
+  {
+    dr->children[i] =
+      create_download_request (dr,
+                               i + head_skip,
+                               depth - 1,
+                               dr_offset + (i + head_skip) * child_block_size,
+                               file_start_offset,
+                               desired_length);
+  }
   return dr;
 }
 
@@ -1567,25 +1568,25 @@ create_download_request(struct DownloadRequest *parent,
  * @param cls the 'struct ReconstructContext'
  */
 static void
-reconstruct_cont(void *cls)
+reconstruct_cont (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
 
   /* clean up state from tree encoder */
   if (NULL != dc->task)
-    {
-      GNUNET_SCHEDULER_cancel(dc->task);
-      dc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (dc->task);
+    dc->task = NULL;
+  }
   if (NULL != dc->rfh)
-    {
-      GNUNET_break(GNUNET_OK == GNUNET_DISK_file_close(dc->rfh));
-      dc->rfh = NULL;
-    }
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (dc->rfh));
+    dc->rfh = NULL;
+  }
   /* start "normal" download */
   dc->issue_requests = GNUNET_YES;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Starting normal download\n");
-  schedule_block_download(dc, dc->top_request);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting normal download\n");
+  schedule_block_download (dc, dc->top_request);
 }
 
 
@@ -1595,12 +1596,12 @@ reconstruct_cont(void *cls)
  * @param cls the 'struct GNUJNET_FS_DownloadContext' we're processing
  */
 static void
-get_next_block(void *cls)
+get_next_block (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
 
   dc->task = NULL;
-  GNUNET_FS_tree_encoder_next(dc->te);
+  GNUNET_FS_tree_encoder_next (dc->te);
 }
 
 
@@ -1622,13 +1623,13 @@ get_next_block(void *cls)
  * @param block_size size of block (in bytes)
  */
 static void
-reconstruct_cb(void *cls,
-               const struct ContentHashKey *chk,
-               uint64_t offset,
-               unsigned int depth,
-               enum GNUNET_BLOCK_Type type,
-               const void *block,
-               uint16_t block_size)
+reconstruct_cb (void *cls,
+                const struct ContentHashKey *chk,
+                uint64_t offset,
+                unsigned int depth,
+                enum GNUNET_BLOCK_Type type,
+                const void *block,
+                uint16_t block_size)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
@@ -1639,125 +1640,125 @@ reconstruct_cb(void *cls,
   /* find corresponding request entry */
   dr = dc->top_request;
   while (dr->depth > depth)
-    {
-      GNUNET_assert(dr->num_children > 0);
-      blen = GNUNET_FS_tree_compute_tree_size(dr->depth - 1);
-      chld = (offset - dr->offset) / blen;
-      if (chld < dr->children[0]->chk_idx)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Block %u < %u irrelevant for our range\n",
-                     chld,
-                     dr->children[0]->chk_idx);
-          dc->task = GNUNET_SCHEDULER_add_now(&get_next_block, dc);
-          return; /* irrelevant block */
-        }
-      if (chld > dr->children[dr->num_children - 1]->chk_idx)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Block %u > %u irrelevant for our range\n",
-                     chld,
-                     dr->children[dr->num_children - 1]->chk_idx);
-          dc->task = GNUNET_SCHEDULER_add_now(&get_next_block, dc);
-          return; /* irrelevant block */
-        }
-      dr = dr->children[chld - dr->children[0]->chk_idx];
-    }
-  GNUNET_log(
+  {
+    GNUNET_assert (dr->num_children > 0);
+    blen = GNUNET_FS_tree_compute_tree_size (dr->depth - 1);
+    chld = (offset - dr->offset) / blen;
+    if (chld < dr->children[0]->chk_idx)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Block %u < %u irrelevant for our range\n",
+                  chld,
+                  dr->children[0]->chk_idx);
+      dc->task = GNUNET_SCHEDULER_add_now (&get_next_block, dc);
+      return;     /* irrelevant block */
+    }
+    if (chld > dr->children[dr->num_children - 1]->chk_idx)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Block %u > %u irrelevant for our range\n",
+                  chld,
+                  dr->children[dr->num_children - 1]->chk_idx);
+      dc->task = GNUNET_SCHEDULER_add_now (&get_next_block, dc);
+      return;     /* irrelevant block */
+    }
+    dr = dr->children[chld - dr->children[0]->chk_idx];
+  }
+  GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "Matched TE block with request at offset %llu and depth %u in state %d\n",
-    (unsigned long long)dr->offset,
+    (unsigned long long) dr->offset,
     dr->depth,
     dr->state);
   /* FIXME: this code needs more testing and might
      need to handle more states... */
   switch (dr->state)
-    {
-    case BRS_INIT:
-      break;
+  {
+  case BRS_INIT:
+    break;
 
-    case BRS_RECONSTRUCT_DOWN:
-      break;
+  case BRS_RECONSTRUCT_DOWN:
+    break;
 
-    case BRS_RECONSTRUCT_META_UP:
-      break;
+  case BRS_RECONSTRUCT_META_UP:
+    break;
 
-    case BRS_RECONSTRUCT_UP:
-      break;
+  case BRS_RECONSTRUCT_UP:
+    break;
 
-    case BRS_CHK_SET:
-      if (0 == memcmp(chk, &dr->chk, sizeof(struct ContentHashKey)))
+  case BRS_CHK_SET:
+    if (0 == memcmp (chk, &dr->chk, sizeof(struct ContentHashKey)))
+    {
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_DEBUG,
+        "Reconstruction succeeded, can use block at offset %llu, depth %u\n",
+        (unsigned long long) offset,
+        depth);
+      /* block matches, hence tree below matches;
+       * this request is done! */
+      dr->state = BRS_DOWNLOAD_UP;
+      (void) GNUNET_CONTAINER_multihashmap_remove (dc->active,
+                                                   &dr->chk.query,
+                                                   dr);
+      /* calculate how many bytes of payload this block
+       * corresponds to */
+      blen = GNUNET_FS_tree_compute_tree_size (dr->depth);
+      /* how many of those bytes are in the requested range? */
+      blen = GNUNET_MIN (blen, dc->length + dc->offset - dr->offset);
+      /* signal progress */
+      dc->completed += blen;
+      pi.status = GNUNET_FS_STATUS_DOWNLOAD_PROGRESS;
+      pi.value.download.specifics.progress.data = NULL;
+      pi.value.download.specifics.progress.offset = offset;
+      pi.value.download.specifics.progress.data_len = 0;
+      pi.value.download.specifics.progress.depth = 0;
+      pi.value.download.specifics.progress.respect_offered = 0;
+      pi.value.download.specifics.progress.block_download_duration =
+        GNUNET_TIME_UNIT_ZERO;
+      GNUNET_FS_download_make_status_ (&pi, dc);
+      /* FIXME: duplicated code from 'process_result_with_request - refactor */
+      if (dc->completed == dc->length)
+      {
+        /* download completed, signal */
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Download completed, truncating file to desired length %llu\n",
+                    (unsigned long long) GNUNET_ntohll (
+                      dc->uri->data.chk.file_length));
+        /* truncate file to size (since we store IBlocks at the end) */
+        if (NULL != dc->filename)
         {
-          GNUNET_log(
-            GNUNET_ERROR_TYPE_DEBUG,
-            "Reconstruction succeeded, can use block at offset %llu, depth %u\n",
-            (unsigned long long)offset,
-            depth);
-          /* block matches, hence tree below matches;
-           * this request is done! */
-          dr->state = BRS_DOWNLOAD_UP;
-          (void)GNUNET_CONTAINER_multihashmap_remove(dc->active,
-                                                     &dr->chk.query,
-                                                     dr);
-          /* calculate how many bytes of payload this block
-           * corresponds to */
-          blen = GNUNET_FS_tree_compute_tree_size(dr->depth);
-          /* how many of those bytes are in the requested range? */
-          blen = GNUNET_MIN(blen, dc->length + dc->offset - dr->offset);
-          /* signal progress */
-          dc->completed += blen;
-          pi.status = GNUNET_FS_STATUS_DOWNLOAD_PROGRESS;
-          pi.value.download.specifics.progress.data = NULL;
-          pi.value.download.specifics.progress.offset = offset;
-          pi.value.download.specifics.progress.data_len = 0;
-          pi.value.download.specifics.progress.depth = 0;
-          pi.value.download.specifics.progress.respect_offered = 0;
-          pi.value.download.specifics.progress.block_download_duration =
-            GNUNET_TIME_UNIT_ZERO;
-          GNUNET_FS_download_make_status_(&pi, dc);
-          /* FIXME: duplicated code from 'process_result_with_request - refactor */
-          if (dc->completed == dc->length)
-            {
-              /* download completed, signal */
-              GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                         "Download completed, truncating file to desired length %llu\n",
-                         (unsigned long long)GNUNET_ntohll(
-                           dc->uri->data.chk.file_length));
-              /* truncate file to size (since we store IBlocks at the end) */
-              if (NULL != dc->filename)
-                {
-                  if (0 != truncate(dc->filename,
-                                    GNUNET_ntohll(dc->uri->data.chk.file_length)))
-                    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                                             "truncate",
-                                             dc->filename);
-                }
-            }
+          if (0 != truncate (dc->filename,
+                             GNUNET_ntohll (dc->uri->data.chk.file_length)))
+            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                      "truncate",
+                                      dc->filename);
         }
-      else
-        GNUNET_log(
-          GNUNET_ERROR_TYPE_DEBUG,
-          "Reconstruction failed, need to download block at offset %llu, depth %u\n",
-          (unsigned long long)offset,
-          depth);
-      break;
+      }
+    }
+    else
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_DEBUG,
+        "Reconstruction failed, need to download block at offset %llu, depth %u\n",
+        (unsigned long long) offset,
+        depth);
+    break;
 
-    case BRS_DOWNLOAD_DOWN:
-      break;
+  case BRS_DOWNLOAD_DOWN:
+    break;
 
-    case BRS_DOWNLOAD_UP:
-      break;
+  case BRS_DOWNLOAD_UP:
+    break;
 
-    case BRS_ERROR:
-      break;
+  case BRS_ERROR:
+    break;
 
-    default:
-      GNUNET_assert(0);
-      break;
-    }
-  dc->task = GNUNET_SCHEDULER_add_now(&get_next_block, dc);
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+  dc->task = GNUNET_SCHEDULER_add_now (&get_next_block, dc);
   if ((dr == dc->top_request) && (dr->state == BRS_DOWNLOAD_UP))
-    check_completed(dc);
+    check_completed (dc);
 }
 
 
@@ -1774,7 +1775,7 @@ reconstruct_cb(void *cls,
  * @return number of bytes copied to buf, 0 on error
  */
 static size_t
-fh_reader(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
+fh_reader (void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_DISK_FileHandle *fh = dc->rfh;
@@ -1782,19 +1783,19 @@ fh_reader(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
 
   if (NULL != emsg)
     *emsg = NULL;
-  if (offset != GNUNET_DISK_file_seek(fh, offset, GNUNET_DISK_SEEK_SET))
-    {
-      if (NULL != emsg)
-        *emsg = GNUNET_strdup(strerror(errno));
-      return 0;
-    }
-  ret = GNUNET_DISK_file_read(fh, buf, max);
+  if (offset != GNUNET_DISK_file_seek (fh, offset, GNUNET_DISK_SEEK_SET))
+  {
+    if (NULL != emsg)
+      *emsg = GNUNET_strdup (strerror (errno));
+    return 0;
+  }
+  ret = GNUNET_DISK_file_read (fh, buf, max);
   if (ret < 0)
-    {
-      if (NULL != emsg)
-        *emsg = GNUNET_strdup(strerror(errno));
-      return 0;
-    }
+  {
+    if (NULL != emsg)
+      *emsg = GNUNET_strdup (strerror (errno));
+    return 0;
+  }
   return ret;
 }
 
@@ -1806,155 +1807,155 @@ fh_reader(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
  * @param cls the 'struct GNUNET_FS_DownloadContext'
  */
 void
-GNUNET_FS_download_start_task_(void *cls)
+GNUNET_FS_download_start_task_ (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   struct GNUNET_DISK_FileHandle *fh;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Start task running...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start task running...\n");
   dc->task = NULL;
   if (0 == dc->length)
-    {
-      /* no bytes required! */
-      if (NULL != dc->filename)
-        {
-          fh = GNUNET_DISK_file_open(dc->filename,
-                                     GNUNET_DISK_OPEN_READWRITE |
-                                     GNUNET_DISK_OPEN_CREATE |
-                                     ((0 ==
-                                       GNUNET_FS_uri_chk_get_file_size(dc->uri))
-                                      ? GNUNET_DISK_OPEN_TRUNCATE
-                                      : 0),
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE |
-                                     GNUNET_DISK_PERM_GROUP_READ |
-                                     GNUNET_DISK_PERM_OTHER_READ);
-          GNUNET_DISK_file_close(fh);
-        }
-      GNUNET_FS_download_sync_(dc);
-      pi.status = GNUNET_FS_STATUS_DOWNLOAD_START;
-      pi.value.download.specifics.start.meta = dc->meta;
-      GNUNET_FS_download_make_status_(&pi, dc);
-      check_completed(dc);
-      return;
-    }
+  {
+    /* no bytes required! */
+    if (NULL != dc->filename)
+    {
+      fh = GNUNET_DISK_file_open (dc->filename,
+                                  GNUNET_DISK_OPEN_READWRITE
+                                  | GNUNET_DISK_OPEN_CREATE
+                                  | ((0 ==
+                                      GNUNET_FS_uri_chk_get_file_size (dc->uri))
+                                     ? GNUNET_DISK_OPEN_TRUNCATE
+                                     : 0),
+                                  GNUNET_DISK_PERM_USER_READ
+                                  | GNUNET_DISK_PERM_USER_WRITE
+                                  | GNUNET_DISK_PERM_GROUP_READ
+                                  | GNUNET_DISK_PERM_OTHER_READ);
+      GNUNET_DISK_file_close (fh);
+    }
+    GNUNET_FS_download_sync_ (dc);
+    pi.status = GNUNET_FS_STATUS_DOWNLOAD_START;
+    pi.value.download.specifics.start.meta = dc->meta;
+    GNUNET_FS_download_make_status_ (&pi, dc);
+    check_completed (dc);
+    return;
+  }
   if (NULL != dc->emsg)
     return;
   if (NULL == dc->top_request)
-    {
-      dc->top_request = create_download_request(NULL,
-                                                0,
-                                                dc->treedepth - 1,
-                                                0,
-                                                dc->offset,
-                                                dc->length);
-      dc->top_request->state = BRS_CHK_SET;
-      dc->top_request->chk = (dc->uri->type == GNUNET_FS_URI_CHK)
-                             ? dc->uri->data.chk.chk
-                             : dc->uri->data.loc.fi.chk;
-      /* signal start */
-      GNUNET_FS_download_sync_(dc);
-      if (NULL != dc->search)
-        GNUNET_FS_search_result_sync_(dc->search);
-      pi.status = GNUNET_FS_STATUS_DOWNLOAD_START;
-      pi.value.download.specifics.start.meta = dc->meta;
-      GNUNET_FS_download_make_status_(&pi, dc);
-    }
-  GNUNET_FS_download_start_downloading_(dc);
+  {
+    dc->top_request = create_download_request (NULL,
+                                               0,
+                                               dc->treedepth - 1,
+                                               0,
+                                               dc->offset,
+                                               dc->length);
+    dc->top_request->state = BRS_CHK_SET;
+    dc->top_request->chk = (dc->uri->type == GNUNET_FS_URI_CHK)
+                           ? dc->uri->data.chk.chk
+                           : dc->uri->data.loc.fi.chk;
+    /* signal start */
+    GNUNET_FS_download_sync_ (dc);
+    if (NULL != dc->search)
+      GNUNET_FS_search_result_sync_ (dc->search);
+    pi.status = GNUNET_FS_STATUS_DOWNLOAD_START;
+    pi.value.download.specifics.start.meta = dc->meta;
+    GNUNET_FS_download_make_status_ (&pi, dc);
+  }
+  GNUNET_FS_download_start_downloading_ (dc);
   /* attempt reconstruction from disk */
-  if (GNUNET_YES == GNUNET_DISK_file_test(dc->filename))
-    dc->rfh = GNUNET_DISK_file_open(dc->filename,
-                                    GNUNET_DISK_OPEN_READ,
-                                    GNUNET_DISK_PERM_NONE);
+  if (GNUNET_YES == GNUNET_DISK_file_test (dc->filename))
+    dc->rfh = GNUNET_DISK_file_open (dc->filename,
+                                     GNUNET_DISK_OPEN_READ,
+                                     GNUNET_DISK_PERM_NONE);
   if (dc->top_request->state == BRS_CHK_SET)
-    {
-      if (NULL != dc->rfh)
+  {
+    if (NULL != dc->rfh)
+    {
+      /* first, try top-down */
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Trying top-down reconstruction for `%s'\n",
+                  dc->filename);
+      try_top_down_reconstruction (dc, dc->top_request);
+      switch (dc->top_request->state)
+      {
+      case BRS_CHK_SET:
+        break;       /* normal */
+
+      case BRS_DOWNLOAD_DOWN:
+        break;       /* normal, some blocks already down */
+
+      case BRS_DOWNLOAD_UP:
+        /* already done entirely, party! */
+        if (NULL != dc->rfh)
         {
-          /* first, try top-down */
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Trying top-down reconstruction for `%s'\n",
-                     dc->filename);
-          try_top_down_reconstruction(dc, dc->top_request);
-          switch (dc->top_request->state)
-            {
-            case BRS_CHK_SET:
-              break; /* normal */
-
-            case BRS_DOWNLOAD_DOWN:
-              break; /* normal, some blocks already down */
-
-            case BRS_DOWNLOAD_UP:
-              /* already done entirely, party! */
-              if (NULL != dc->rfh)
-                {
-                  /* avoid hanging on to file handle longer than
-                   * necessary */
-                  GNUNET_DISK_file_close(dc->rfh);
-                  dc->rfh = NULL;
-                }
-              return;
-
-            case BRS_ERROR:
-              GNUNET_asprintf(&dc->emsg, _("Invalid URI"));
-              GNUNET_FS_download_sync_(dc);
-              pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
-              pi.value.download.specifics.error.message = dc->emsg;
-              GNUNET_FS_download_make_status_(&pi, dc);
-              return;
-
-            default:
-              GNUNET_assert(0);
-              break;
-            }
+          /* avoid hanging on to file handle longer than
+           * necessary */
+          GNUNET_DISK_file_close (dc->rfh);
+          dc->rfh = NULL;
         }
+        return;
+
+      case BRS_ERROR:
+        GNUNET_asprintf (&dc->emsg, _ ("Invalid URI"));
+        GNUNET_FS_download_sync_ (dc);
+        pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
+        pi.value.download.specifics.error.message = dc->emsg;
+        GNUNET_FS_download_make_status_ (&pi, dc);
+        return;
+
+      default:
+        GNUNET_assert (0);
+        break;
+      }
     }
+  }
   /* attempt reconstruction from meta data */
-  if ((GNUNET_FS_uri_chk_get_file_size(dc->uri) <= MAX_INLINE_SIZE) &&
+  if ((GNUNET_FS_uri_chk_get_file_size (dc->uri) <= MAX_INLINE_SIZE) &&
       (NULL != dc->meta))
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Trying to find embedded meta data for download of size %llu with %u bytes MD\n",
+      (unsigned long long) GNUNET_FS_uri_chk_get_file_size (dc->uri),
+      (unsigned int) GNUNET_CONTAINER_meta_data_get_serialized_size (dc->meta));
+    GNUNET_CONTAINER_meta_data_iterate (dc->meta, &match_full_data, dc);
+    if (BRS_DOWNLOAD_UP == dc->top_request->state)
     {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_DEBUG,
-        "Trying to find embedded meta data for download of size %llu with %u bytes MD\n",
-        (unsigned long long)GNUNET_FS_uri_chk_get_file_size(dc->uri),
-        (unsigned int)GNUNET_CONTAINER_meta_data_get_serialized_size(dc->meta));
-      GNUNET_CONTAINER_meta_data_iterate(dc->meta, &match_full_data, dc);
-      if (BRS_DOWNLOAD_UP == dc->top_request->state)
-        {
-          if (NULL != dc->rfh)
-            {
-              /* avoid hanging on to file handle longer than
-               * necessary */
-              GNUNET_DISK_file_close(dc->rfh);
-              dc->rfh = NULL;
-            }
-          return; /* finished, status update was already done for us */
-        }
-    }
+      if (NULL != dc->rfh)
+      {
+        /* avoid hanging on to file handle longer than
+         * necessary */
+        GNUNET_DISK_file_close (dc->rfh);
+        dc->rfh = NULL;
+      }
+      return;     /* finished, status update was already done for us */
+    }
+  }
   if (NULL != dc->rfh)
-    {
-      /* finally, actually run bottom-up */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Trying bottom-up reconstruction of file `%s'\n",
-                 dc->filename);
-      dc->te =
-        GNUNET_FS_tree_encoder_create(dc->h,
-                                      GNUNET_FS_uri_chk_get_file_size(dc->uri),
-                                      dc,
-                                      &fh_reader,
-                                      &reconstruct_cb,
-                                      NULL,
-                                      &reconstruct_cont);
-      dc->task = GNUNET_SCHEDULER_add_now(&get_next_block, dc);
-    }
+  {
+    /* finally, actually run bottom-up */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Trying bottom-up reconstruction of file `%s'\n",
+                dc->filename);
+    dc->te =
+      GNUNET_FS_tree_encoder_create (dc->h,
+                                     GNUNET_FS_uri_chk_get_file_size (dc->uri),
+                                     dc,
+                                     &fh_reader,
+                                     &reconstruct_cb,
+                                     NULL,
+                                     &reconstruct_cont);
+    dc->task = GNUNET_SCHEDULER_add_now (&get_next_block, dc);
+  }
   else
-    {
-      /* simple, top-level download */
-      dc->issue_requests = GNUNET_YES;
-      schedule_block_download(dc, dc->top_request);
-    }
+  {
+    /* simple, top-level download */
+    dc->issue_requests = GNUNET_YES;
+    schedule_block_download (dc, dc->top_request);
+  }
   if (BRS_DOWNLOAD_UP == dc->top_request->state)
-    check_completed(dc);
+    check_completed (dc);
 }
 
 
@@ -1965,59 +1966,59 @@ GNUNET_FS_download_start_task_(void *cls)
  * @param cls the 'struct GNUNET_FS_DownloadContext' to signal for
  */
 void
-GNUNET_FS_download_signal_suspend_(void *cls)
+GNUNET_FS_download_signal_suspend_ (void *cls)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
   if (NULL != dc->top)
-    GNUNET_FS_end_top(dc->h, dc->top);
+    GNUNET_FS_end_top (dc->h, dc->top);
   while (NULL != dc->child_head)
-    GNUNET_FS_download_signal_suspend_(dc->child_head);
+    GNUNET_FS_download_signal_suspend_ (dc->child_head);
   if (NULL != dc->search)
-    {
-      dc->search->download = NULL;
-      dc->search = NULL;
-    }
+  {
+    dc->search->download = NULL;
+    dc->search = NULL;
+  }
   if (NULL != dc->job_queue)
-    {
-      GNUNET_FS_dequeue_(dc->job_queue);
-      dc->job_queue = NULL;
-    }
+  {
+    GNUNET_FS_dequeue_ (dc->job_queue);
+    dc->job_queue = NULL;
+  }
   if (NULL != dc->parent)
-    GNUNET_CONTAINER_DLL_remove(dc->parent->child_head,
-                                dc->parent->child_tail,
-                                dc);
+    GNUNET_CONTAINER_DLL_remove (dc->parent->child_head,
+                                 dc->parent->child_tail,
+                                 dc);
   if (NULL != dc->task)
-    {
-      GNUNET_SCHEDULER_cancel(dc->task);
-      dc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (dc->task);
+    dc->task = NULL;
+  }
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_SUSPEND;
-  GNUNET_FS_download_make_status_(&pi, dc);
+  GNUNET_FS_download_make_status_ (&pi, dc);
   if (NULL != dc->te)
-    {
-      GNUNET_FS_tree_encoder_finish(dc->te, NULL);
-      dc->te = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (dc->te, NULL);
+    dc->te = NULL;
+  }
   if (NULL != dc->rfh)
-    {
-      GNUNET_DISK_file_close(dc->rfh);
-      dc->rfh = NULL;
-    }
-  GNUNET_FS_free_download_request_(dc->top_request);
+  {
+    GNUNET_DISK_file_close (dc->rfh);
+    dc->rfh = NULL;
+  }
+  GNUNET_FS_free_download_request_ (dc->top_request);
   if (NULL != dc->active)
-    {
-      GNUNET_CONTAINER_multihashmap_destroy(dc->active);
-      dc->active = NULL;
-    }
-  GNUNET_free_non_null(dc->filename);
-  GNUNET_CONTAINER_meta_data_destroy(dc->meta);
-  GNUNET_FS_uri_destroy(dc->uri);
-  GNUNET_free_non_null(dc->temp_filename);
-  GNUNET_free_non_null(dc->serialization);
-  GNUNET_assert(NULL == dc->job_queue);
-  GNUNET_free(dc);
+  {
+    GNUNET_CONTAINER_multihashmap_destroy (dc->active);
+    dc->active = NULL;
+  }
+  GNUNET_free_non_null (dc->filename);
+  GNUNET_CONTAINER_meta_data_destroy (dc->meta);
+  GNUNET_FS_uri_destroy (dc->uri);
+  GNUNET_free_non_null (dc->temp_filename);
+  GNUNET_free_non_null (dc->serialization);
+  GNUNET_assert (NULL == dc->job_queue);
+  GNUNET_free (dc);
 }
 
 
@@ -2041,72 +2042,72 @@ GNUNET_FS_download_signal_suspend_(void *cls)
  * @return context that can be used to control this download
  */
 struct GNUNET_FS_DownloadContext *
-create_download_context(struct GNUNET_FS_Handle *h,
-                        const struct GNUNET_FS_Uri *uri,
-                        const struct GNUNET_CONTAINER_MetaData *meta,
-                        const char *filename,
-                        const char *tempname,
-                        uint64_t offset,
-                        uint64_t length,
-                        uint32_t anonymity,
-                        enum GNUNET_FS_DownloadOptions options,
-                        void *cctx)
+create_download_context (struct GNUNET_FS_Handle *h,
+                         const struct GNUNET_FS_Uri *uri,
+                         const struct GNUNET_CONTAINER_MetaData *meta,
+                         const char *filename,
+                         const char *tempname,
+                         uint64_t offset,
+                         uint64_t length,
+                         uint32_t anonymity,
+                         enum GNUNET_FS_DownloadOptions options,
+                         void *cctx)
 {
   struct GNUNET_FS_DownloadContext *dc;
 
-  GNUNET_assert(GNUNET_FS_uri_test_chk(uri) || GNUNET_FS_uri_test_loc(uri));
+  GNUNET_assert (GNUNET_FS_uri_test_chk (uri) || GNUNET_FS_uri_test_loc (uri));
   if ((offset + length < offset) ||
-      (offset + length > GNUNET_FS_uri_chk_get_file_size(uri)))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  dc = GNUNET_new(struct GNUNET_FS_DownloadContext);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Starting download %p, %u bytes at offset %llu\n",
-             dc,
-             (unsigned int)length,
-             (unsigned long long)offset);
+      (offset + length > GNUNET_FS_uri_chk_get_file_size (uri)))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  dc = GNUNET_new (struct GNUNET_FS_DownloadContext);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting download %p, %u bytes at offset %llu\n",
+              dc,
+              (unsigned int) length,
+              (unsigned long long) offset);
   dc->h = h;
-  dc->uri = GNUNET_FS_uri_dup(uri);
-  dc->meta = GNUNET_CONTAINER_meta_data_duplicate(meta);
+  dc->uri = GNUNET_FS_uri_dup (uri);
+  dc->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
   dc->client_info = cctx;
-  dc->start_time = GNUNET_TIME_absolute_get();
+  dc->start_time = GNUNET_TIME_absolute_get ();
   if (NULL != filename)
-    {
-      dc->filename = GNUNET_strdup(filename);
-      if (GNUNET_YES == GNUNET_DISK_file_test(filename))
-        GNUNET_break(GNUNET_OK == GNUNET_DISK_file_size(filename,
+  {
+    dc->filename = GNUNET_strdup (filename);
+    if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+      GNUNET_break (GNUNET_OK == GNUNET_DISK_file_size (filename,
                                                         &dc->old_file_size,
                                                         GNUNET_YES,
                                                         GNUNET_YES));
-    }
-  if (GNUNET_FS_uri_test_loc(dc->uri))
-    GNUNET_assert(GNUNET_OK ==
-                  GNUNET_FS_uri_loc_get_peer_identity(dc->uri, &dc->target));
+  }
+  if (GNUNET_FS_uri_test_loc (dc->uri))
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_FS_uri_loc_get_peer_identity (dc->uri, &dc->target));
   dc->offset = offset;
   dc->length = length;
   dc->anonymity = anonymity;
   dc->options = options;
   dc->active =
-    GNUNET_CONTAINER_multihashmap_create(1 + 2 * (length / DBLOCK_SIZE),
-                                         GNUNET_NO);
+    GNUNET_CONTAINER_multihashmap_create (1 + 2 * (length / DBLOCK_SIZE),
+                                          GNUNET_NO);
   dc->treedepth =
-    GNUNET_FS_compute_depth(GNUNET_FS_uri_chk_get_file_size(dc->uri));
-  if ((NULL == filename) && (is_recursive_download(dc)))
-    {
-      if (NULL != tempname)
-        dc->temp_filename = GNUNET_strdup(tempname);
-      else
-        dc->temp_filename = GNUNET_DISK_mktemp("gnunet-directory-download-tmp");
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Starting download `%s' of %llu bytes with tree depth %u\n",
-             filename,
-             (unsigned long long)length,
-             dc->treedepth);
-  GNUNET_assert(NULL == dc->job_queue);
-  dc->task = GNUNET_SCHEDULER_add_now(&GNUNET_FS_download_start_task_, dc);
+    GNUNET_FS_compute_depth (GNUNET_FS_uri_chk_get_file_size (dc->uri));
+  if ((NULL == filename) && (is_recursive_download (dc)))
+  {
+    if (NULL != tempname)
+      dc->temp_filename = GNUNET_strdup (tempname);
+    else
+      dc->temp_filename = GNUNET_DISK_mktemp ("gnunet-directory-download-tmp");
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting download `%s' of %llu bytes with tree depth %u\n",
+              filename,
+              (unsigned long long) length,
+              dc->treedepth);
+  GNUNET_assert (NULL == dc->job_queue);
+  dc->task = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, dc);
   return dc;
 }
 
@@ -2142,38 +2143,38 @@ create_download_context(struct GNUNET_FS_Handle *h,
  * @return context that can be used to control this download
  */
 struct GNUNET_FS_DownloadContext *
-GNUNET_FS_download_start(struct GNUNET_FS_Handle *h,
-                         const struct GNUNET_FS_Uri *uri,
-                         const struct GNUNET_CONTAINER_MetaData *meta,
-                         const char *filename,
-                         const char *tempname,
-                         uint64_t offset,
-                         uint64_t length,
-                         uint32_t anonymity,
-                         enum GNUNET_FS_DownloadOptions options,
-                         void *cctx,
-                         struct GNUNET_FS_DownloadContext *parent)
+GNUNET_FS_download_start (struct GNUNET_FS_Handle *h,
+                          const struct GNUNET_FS_Uri *uri,
+                          const struct GNUNET_CONTAINER_MetaData *meta,
+                          const char *filename,
+                          const char *tempname,
+                          uint64_t offset,
+                          uint64_t length,
+                          uint32_t anonymity,
+                          enum GNUNET_FS_DownloadOptions options,
+                          void *cctx,
+                          struct GNUNET_FS_DownloadContext *parent)
 {
   struct GNUNET_FS_DownloadContext *dc;
 
-  dc = create_download_context(h,
-                               uri,
-                               meta,
-                               filename,
-                               tempname,
-                               offset,
-                               length,
-                               anonymity,
-                               options,
-                               cctx);
+  dc = create_download_context (h,
+                                uri,
+                                meta,
+                                filename,
+                                tempname,
+                                offset,
+                                length,
+                                anonymity,
+                                options,
+                                cctx);
   if (NULL == dc)
     return NULL;
   dc->parent = parent;
   if (NULL != parent)
-    GNUNET_CONTAINER_DLL_insert(parent->child_head, parent->child_tail, dc);
+    GNUNET_CONTAINER_DLL_insert (parent->child_head, parent->child_tail, dc);
   else if (0 == (GNUNET_FS_DOWNLOAD_IS_PROBE & options))
     dc->top =
-      GNUNET_FS_make_top(dc->h, &GNUNET_FS_download_signal_suspend_, dc);
+      GNUNET_FS_make_top (dc->h, &GNUNET_FS_download_signal_suspend_, dc);
   return dc;
 }
 
@@ -2213,43 +2214,43 @@ GNUNET_FS_download_start(struct GNUNET_FS_Handle *h,
  * @return context that can be used to control this download
  */
 struct GNUNET_FS_DownloadContext *
-GNUNET_FS_download_start_from_search(struct GNUNET_FS_Handle *h,
-                                     struct GNUNET_FS_SearchResult *sr,
-                                     const char *filename,
-                                     const char *tempname,
-                                     uint64_t offset,
-                                     uint64_t length,
-                                     uint32_t anonymity,
-                                     enum GNUNET_FS_DownloadOptions options,
-                                     void *cctx)
+GNUNET_FS_download_start_from_search (struct GNUNET_FS_Handle *h,
+                                      struct GNUNET_FS_SearchResult *sr,
+                                      const char *filename,
+                                      const char *tempname,
+                                      uint64_t offset,
+                                      uint64_t length,
+                                      uint32_t anonymity,
+                                      enum GNUNET_FS_DownloadOptions options,
+                                      void *cctx)
 {
   struct GNUNET_FS_DownloadContext *dc;
 
   if ((NULL == sr) || (NULL != sr->download))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  dc = create_download_context(h,
-                               sr->uri,
-                               sr->meta,
-                               filename,
-                               tempname,
-                               offset,
-                               length,
-                               anonymity,
-                               options,
-                               cctx);
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  dc = create_download_context (h,
+                                sr->uri,
+                                sr->meta,
+                                filename,
+                                tempname,
+                                offset,
+                                length,
+                                anonymity,
+                                options,
+                                cctx);
   if (NULL == dc)
     return NULL;
   dc->search = sr;
   sr->download = dc;
   if (NULL != sr->probe_ctx)
-    {
-      GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES);
-      sr->probe_ctx = NULL;
-      GNUNET_FS_stop_probe_ping_task_(sr);
-    }
+  {
+    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
+    sr->probe_ctx = NULL;
+    GNUNET_FS_stop_probe_ping_task_ (sr);
+  }
   return dc;
 }
 
@@ -2260,28 +2261,28 @@ GNUNET_FS_download_start_from_search(struct GNUNET_FS_Handle *h,
  * @param dc our download context
  */
 void
-GNUNET_FS_download_start_downloading_(struct GNUNET_FS_DownloadContext *dc)
+GNUNET_FS_download_start_downloading_ (struct GNUNET_FS_DownloadContext *dc)
 {
   if (dc->completed == dc->length)
     return;
   if (NULL != dc->mq)
     return; /* already running */
-  GNUNET_assert(NULL == dc->job_queue);
-  GNUNET_assert(NULL == dc->task);
-  GNUNET_assert(NULL != dc->active);
+  GNUNET_assert (NULL == dc->job_queue);
+  GNUNET_assert (NULL == dc->task);
+  GNUNET_assert (NULL != dc->active);
   dc->job_queue =
-    GNUNET_FS_queue_(dc->h,
-                     &activate_fs_download,
-                     &deactivate_fs_download,
-                     dc,
-                     (dc->length + DBLOCK_SIZE - 1) / DBLOCK_SIZE,
-                     (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
-                     ? GNUNET_FS_QUEUE_PRIORITY_NORMAL
-                     : GNUNET_FS_QUEUE_PRIORITY_PROBE);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Download %p put into queue as job %p\n",
-             dc,
-             dc->job_queue);
+    GNUNET_FS_queue_ (dc->h,
+                      &activate_fs_download,
+                      &deactivate_fs_download,
+                      dc,
+                      (dc->length + DBLOCK_SIZE - 1) / DBLOCK_SIZE,
+                      (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
+                      ? GNUNET_FS_QUEUE_PRIORITY_NORMAL
+                      : GNUNET_FS_QUEUE_PRIORITY_PROBE);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Download %p put into queue as job %p\n",
+              dc,
+              dc->job_queue);
 }
 
 /**
@@ -2290,9 +2291,9 @@ GNUNET_FS_download_start_downloading_(struct GNUNET_FS_DownloadContext *dc)
  * @param dc handle for the download
  */
 void
-GNUNET_FS_download_suspend(struct GNUNET_FS_DownloadContext *dc)
+GNUNET_FS_download_suspend (struct GNUNET_FS_DownloadContext *dc)
 {
-  deactivate_fs_download(dc);
+  deactivate_fs_download (dc);
 }
 
 
@@ -2302,23 +2303,23 @@ GNUNET_FS_download_suspend(struct GNUNET_FS_DownloadContext *dc)
  * @param dc handle for the download
  */
 void
-GNUNET_FS_download_resume(struct GNUNET_FS_DownloadContext *dc)
+GNUNET_FS_download_resume (struct GNUNET_FS_DownloadContext *dc)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_ACTIVE;
-  GNUNET_FS_download_make_status_(&pi, dc);
+  GNUNET_FS_download_make_status_ (&pi, dc);
 
-  GNUNET_assert(NULL == dc->task);
+  GNUNET_assert (NULL == dc->task);
   dc->job_queue =
-    GNUNET_FS_queue_(dc->h,
-                     &activate_fs_download,
-                     &deactivate_fs_download,
-                     dc,
-                     (dc->length + DBLOCK_SIZE - 1) / DBLOCK_SIZE,
-                     (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
-                     ? GNUNET_FS_QUEUE_PRIORITY_NORMAL
-                     : GNUNET_FS_QUEUE_PRIORITY_PROBE);
+    GNUNET_FS_queue_ (dc->h,
+                      &activate_fs_download,
+                      &deactivate_fs_download,
+                      dc,
+                      (dc->length + DBLOCK_SIZE - 1) / DBLOCK_SIZE,
+                      (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
+                      ? GNUNET_FS_QUEUE_PRIORITY_NORMAL
+                      : GNUNET_FS_QUEUE_PRIORITY_PROBE);
 }
 
 
@@ -2329,88 +2330,88 @@ GNUNET_FS_download_resume(struct GNUNET_FS_DownloadContext *dc)
  * @param do_delete delete files of incomplete downloads
  */
 void
-GNUNET_FS_download_stop(struct GNUNET_FS_DownloadContext *dc, int do_delete)
+GNUNET_FS_download_stop (struct GNUNET_FS_DownloadContext *dc, int do_delete)
 {
   struct GNUNET_FS_ProgressInfo pi;
   int have_children;
   int search_was_null;
 
   if (NULL != dc->top)
-    GNUNET_FS_end_top(dc->h, dc->top);
+    GNUNET_FS_end_top (dc->h, dc->top);
   if (NULL != dc->task)
-    {
-      GNUNET_SCHEDULER_cancel(dc->task);
-      dc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (dc->task);
+    dc->task = NULL;
+  }
   search_was_null = (NULL == dc->search);
   if (NULL != dc->search)
-    {
-      dc->search->download = NULL;
-      GNUNET_FS_search_result_sync_(dc->search);
-      dc->search = NULL;
-    }
+  {
+    dc->search->download = NULL;
+    GNUNET_FS_search_result_sync_ (dc->search);
+    dc->search = NULL;
+  }
   if (NULL != dc->job_queue)
-    {
-      GNUNET_FS_dequeue_(dc->job_queue);
-      dc->job_queue = NULL;
-    }
+  {
+    GNUNET_FS_dequeue_ (dc->job_queue);
+    dc->job_queue = NULL;
+  }
   if (NULL != dc->te)
-    {
-      GNUNET_FS_tree_encoder_finish(dc->te, NULL);
-      dc->te = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (dc->te, NULL);
+    dc->te = NULL;
+  }
   have_children = (NULL != dc->child_head) ? GNUNET_YES : GNUNET_NO;
   while (NULL != dc->child_head)
-    GNUNET_FS_download_stop(dc->child_head, do_delete);
+    GNUNET_FS_download_stop (dc->child_head, do_delete);
   if (NULL != dc->parent)
-    GNUNET_CONTAINER_DLL_remove(dc->parent->child_head,
-                                dc->parent->child_tail,
-                                dc);
+    GNUNET_CONTAINER_DLL_remove (dc->parent->child_head,
+                                 dc->parent->child_tail,
+                                 dc);
   if (NULL != dc->serialization)
-    GNUNET_FS_remove_sync_file_(dc->h,
-                                ((NULL != dc->parent) || (!search_was_null))
+    GNUNET_FS_remove_sync_file_ (dc->h,
+                                 ((NULL != dc->parent) || (! search_was_null))
+                                 ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
+                                 : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
+                                 dc->serialization);
+  if ((GNUNET_YES == have_children) && (NULL == dc->parent))
+    GNUNET_FS_remove_sync_dir_ (dc->h,
+                                (! search_was_null)
                                 ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
                                 : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
                                 dc->serialization);
-  if ((GNUNET_YES == have_children) && (NULL == dc->parent))
-    GNUNET_FS_remove_sync_dir_(dc->h,
-                               (!search_was_null)
-                               ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
-                               : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
-                               dc->serialization);
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_STOPPED;
-  GNUNET_FS_download_make_status_(&pi, dc);
-  GNUNET_FS_free_download_request_(dc->top_request);
+  GNUNET_FS_download_make_status_ (&pi, dc);
+  GNUNET_FS_free_download_request_ (dc->top_request);
   dc->top_request = NULL;
   if (NULL != dc->active)
-    {
-      GNUNET_CONTAINER_multihashmap_destroy(dc->active);
-      dc->active = NULL;
-    }
+  {
+    GNUNET_CONTAINER_multihashmap_destroy (dc->active);
+    dc->active = NULL;
+  }
   if (NULL != dc->filename)
-    {
-      if ((dc->completed != dc->length) && (GNUNET_YES == do_delete))
-        {
-          if ((0 != unlink(dc->filename)) && (ENOENT != errno))
-            GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                                     "unlink",
-                                     dc->filename);
-        }
-      GNUNET_free(dc->filename);
-    }
-  GNUNET_CONTAINER_meta_data_destroy(dc->meta);
-  GNUNET_FS_uri_destroy(dc->uri);
+  {
+    if ((dc->completed != dc->length) && (GNUNET_YES == do_delete))
+    {
+      if ((0 != unlink (dc->filename)) && (ENOENT != errno))
+        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                                  "unlink",
+                                  dc->filename);
+    }
+    GNUNET_free (dc->filename);
+  }
+  GNUNET_CONTAINER_meta_data_destroy (dc->meta);
+  GNUNET_FS_uri_destroy (dc->uri);
   if (NULL != dc->temp_filename)
-    {
-      if (0 != unlink(dc->temp_filename))
-        GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR,
-                                 "unlink",
-                                 dc->temp_filename);
-      GNUNET_free(dc->temp_filename);
-    }
-  GNUNET_free_non_null(dc->serialization);
-  GNUNET_assert(NULL == dc->job_queue);
-  GNUNET_free(dc);
+  {
+    if (0 != unlink (dc->temp_filename))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                                "unlink",
+                                dc->temp_filename);
+    GNUNET_free (dc->temp_filename);
+  }
+  GNUNET_free_non_null (dc->serialization);
+  GNUNET_assert (NULL == dc->job_queue);
+  GNUNET_free (dc);
 }
 
 /* end of fs_download.c */
diff --git a/src/fs/fs_file_information.c b/src/fs/fs_file_information.c
index dbcfd81c4..bbbc30a6e 100644
--- a/src/fs/fs_file_information.c
+++ b/src/fs/fs_file_information.c
@@ -42,7 +42,7 @@
  *         can be used to read this fi-struct from disk.
  */
 const char *
-GNUNET_FS_file_information_get_id(struct GNUNET_FS_FileInformation *s)
+GNUNET_FS_file_information_get_id (struct GNUNET_FS_FileInformation *s)
 {
   if (NULL != s->dir)
     return NULL;
@@ -56,7 +56,7 @@ GNUNET_FS_file_information_get_id(struct GNUNET_FS_FileInformation *s)
  * @return "filename" field of the structure (can be NULL)
  */
 const char *
-GNUNET_FS_file_information_get_filename(struct GNUNET_FS_FileInformation *s)
+GNUNET_FS_file_information_get_filename (struct GNUNET_FS_FileInformation *s)
 {
   return s->filename;
 }
@@ -71,12 +71,12 @@ GNUNET_FS_file_information_get_filename(struct GNUNET_FS_FileInformation *s)
  * @param filename filename to set
  */
 void
-GNUNET_FS_file_information_set_filename(struct GNUNET_FS_FileInformation *s,
-                                        const char *filename)
+GNUNET_FS_file_information_set_filename (struct GNUNET_FS_FileInformation *s,
+                                         const char *filename)
 {
-  GNUNET_free_non_null(s->filename);
+  GNUNET_free_non_null (s->filename);
   if (filename)
-    s->filename = GNUNET_strdup(filename);
+    s->filename = GNUNET_strdup (filename);
   else
     s->filename = NULL;
 }
@@ -97,7 +97,7 @@ GNUNET_FS_file_information_set_filename(struct GNUNET_FS_FileInformation *s,
  * @return publish structure entry for the file
  */
 struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_from_file(
+GNUNET_FS_file_information_create_from_file (
   struct GNUNET_FS_Handle *h,
   void *client_info,
   const char *filename,
@@ -114,44 +114,44 @@ GNUNET_FS_file_information_create_from_file(
 
   /* FIXME: should include_symbolic_links be GNUNET_NO or GNUNET_YES here? */
   if (GNUNET_OK !=
-      GNUNET_DISK_file_size(filename, &fsize, GNUNET_NO, GNUNET_YES))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "stat", filename);
-      return NULL;
-    }
-  fi = GNUNET_FS_make_file_reader_context_(filename);
+      GNUNET_DISK_file_size (filename, &fsize, GNUNET_NO, GNUNET_YES))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+    return NULL;
+  }
+  fi = GNUNET_FS_make_file_reader_context_ (filename);
   if (NULL == fi)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   ret =
-    GNUNET_FS_file_information_create_from_reader(h,
-                                                  client_info,
-                                                  fsize,
-                                                  &GNUNET_FS_data_reader_file_,
-                                                  fi,
-                                                  keywords,
-                                                  meta,
-                                                  do_index,
-                                                  bo);
+    GNUNET_FS_file_information_create_from_reader (h,
+                                                   client_info,
+                                                   fsize,
+                                                   &GNUNET_FS_data_reader_file_,
+                                                   fi,
+                                                   keywords,
+                                                   meta,
+                                                   do_index,
+                                                   bo);
   if (ret == NULL)
     return NULL;
   ret->h = h;
-  ret->filename = GNUNET_strdup(filename);
+  ret->filename = GNUNET_strdup (filename);
   fn = filename;
-  while (NULL != (ss = strstr(fn, DIR_SEPARATOR_STR)))
+  while (NULL != (ss = strstr (fn, DIR_SEPARATOR_STR)))
     fn = ss + 1;
 /* FIXME: If we assume that on other platforms CRT is UTF-8-aware, then
  * this should be changed to EXTRACTOR_METAFORMAT_UTF8
  */
-  GNUNET_CONTAINER_meta_data_insert(ret->meta,
-                                    "<gnunet>",
-                                    EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                    EXTRACTOR_METAFORMAT_C_STRING,
-                                    "text/plain",
-                                    fn,
-                                    strlen(fn) + 1);
+  GNUNET_CONTAINER_meta_data_insert (ret->meta,
+                                     "<gnunet>",
+                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                                     EXTRACTOR_METAFORMAT_C_STRING,
+                                     "text/plain",
+                                     fn,
+                                     strlen (fn) + 1);
   return ret;
 }
 
@@ -173,7 +173,7 @@ GNUNET_FS_file_information_create_from_file(
  * @return publish structure entry for the file
  */
 struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_from_data(
+GNUNET_FS_file_information_create_from_data (
   struct GNUNET_FS_Handle *h,
   void *client_info,
   uint64_t length,
@@ -184,19 +184,20 @@ GNUNET_FS_file_information_create_from_data(
   const struct GNUNET_FS_BlockOptions *bo)
 {
   if (GNUNET_YES == do_index)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  return GNUNET_FS_file_information_create_from_reader(h,
-                                                       client_info,
-                                                       length,
-                                                       &GNUNET_FS_data_reader_copy_,
-                                                       data,
-                                                       keywords,
-                                                       meta,
-                                                       do_index,
-                                                       bo);
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  return GNUNET_FS_file_information_create_from_reader (h,
+                                                        client_info,
+                                                        length,
+                                                        &
+                                                        GNUNET_FS_data_reader_copy_,
+                                                        data,
+                                                        keywords,
+                                                        meta,
+                                                        do_index,
+                                                        bo);
 }
 
 
@@ -217,7 +218,7 @@ GNUNET_FS_file_information_create_from_data(
  * @return publish structure entry for the file
  */
 struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_from_reader(
+GNUNET_FS_file_information_create_from_reader (
   struct GNUNET_FS_Handle *h,
   void *client_info,
   uint64_t length,
@@ -231,17 +232,17 @@ GNUNET_FS_file_information_create_from_reader(
   struct GNUNET_FS_FileInformation *ret;
 
   if ((GNUNET_YES == do_index) && (reader != &GNUNET_FS_data_reader_file_))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  ret = GNUNET_new(struct GNUNET_FS_FileInformation);
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  ret = GNUNET_new (struct GNUNET_FS_FileInformation);
   ret->h = h;
   ret->client_info = client_info;
-  ret->meta = GNUNET_CONTAINER_meta_data_duplicate(meta);
+  ret->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
   if (ret->meta == NULL)
-    ret->meta = GNUNET_CONTAINER_meta_data_create();
-  ret->keywords = (keywords == NULL) ? NULL : GNUNET_FS_uri_dup(keywords);
+    ret->meta = GNUNET_CONTAINER_meta_data_create ();
+  ret->keywords = (keywords == NULL) ? NULL : GNUNET_FS_uri_dup (keywords);
   ret->data.file.reader = reader;
   ret->data.file.reader_cls = reader_cls;
   ret->data.file.do_index = do_index;
@@ -258,7 +259,7 @@ GNUNET_FS_file_information_create_from_reader(
  * @return #GNUNET_YES if so, #GNUNET_NO if not
  */
 int
-GNUNET_FS_file_information_is_directory(
+GNUNET_FS_file_information_is_directory (
   const struct GNUNET_FS_FileInformation *ent)
 {
   return ent->is_directory;
@@ -278,7 +279,7 @@ GNUNET_FS_file_information_is_directory(
  * @return publish structure entry for the directory , NULL on error
  */
 struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_empty_directory(
+GNUNET_FS_file_information_create_empty_directory (
   struct GNUNET_FS_Handle *h,
   void *client_info,
   const struct GNUNET_FS_Uri *keywords,
@@ -288,15 +289,15 @@ GNUNET_FS_file_information_create_empty_directory(
 {
   struct GNUNET_FS_FileInformation *ret;
 
-  ret = GNUNET_new(struct GNUNET_FS_FileInformation);
+  ret = GNUNET_new (struct GNUNET_FS_FileInformation);
   ret->h = h;
   ret->client_info = client_info;
-  ret->meta = GNUNET_CONTAINER_meta_data_duplicate(meta);
-  ret->keywords = GNUNET_FS_uri_dup(keywords);
+  ret->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+  ret->keywords = GNUNET_FS_uri_dup (keywords);
   ret->bo = *bo;
   ret->is_directory = GNUNET_YES;
   if (filename != NULL)
-    ret->filename = GNUNET_strdup(filename);
+    ret->filename = GNUNET_strdup (filename);
   return ret;
 }
 
@@ -313,15 +314,15 @@ GNUNET_FS_file_information_create_empty_directory(
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_FS_file_information_add(struct GNUNET_FS_FileInformation *dir,
-                               struct GNUNET_FS_FileInformation *ent)
+GNUNET_FS_file_information_add (struct GNUNET_FS_FileInformation *dir,
+                                struct GNUNET_FS_FileInformation *ent)
 {
   if ((ent->dir != NULL) || (ent->next != NULL) ||
       (dir->is_directory != GNUNET_YES))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   ent->dir = dir;
   ent->next = dir->data.dir.entries;
   dir->data.dir.entries = ent;
@@ -345,45 +346,45 @@ GNUNET_FS_file_information_add(struct GNUNET_FS_FileInformation *dir,
  * @param proc_cls closure for @a proc
  */
 void
-GNUNET_FS_file_information_inspect(struct GNUNET_FS_FileInformation *dir,
-                                   GNUNET_FS_FileInformationProcessor proc,
-                                   void *proc_cls)
+GNUNET_FS_file_information_inspect (struct GNUNET_FS_FileInformation *dir,
+                                    GNUNET_FS_FileInformationProcessor proc,
+                                    void *proc_cls)
 {
   struct GNUNET_FS_FileInformation *pos;
   int no;
 
   no = GNUNET_NO;
   if (GNUNET_OK !=
-      proc(proc_cls,
-           dir,
-           (dir->is_directory == GNUNET_YES) ? dir->data.dir.dir_size
-           : dir->data.file.file_size,
-           dir->meta,
-           &dir->keywords,
-           &dir->bo,
-           (dir->is_directory == GNUNET_YES) ? &no : &dir->data.file.do_index,
-           &dir->client_info))
+      proc (proc_cls,
+            dir,
+            (dir->is_directory == GNUNET_YES) ? dir->data.dir.dir_size
+            : dir->data.file.file_size,
+            dir->meta,
+            &dir->keywords,
+            &dir->bo,
+            (dir->is_directory == GNUNET_YES) ? &no : &dir->data.file.do_index,
+            &dir->client_info))
     return;
   if (dir->is_directory != GNUNET_YES)
     return;
   pos = dir->data.dir.entries;
   while (pos != NULL)
-    {
-      no = GNUNET_NO;
-      if (GNUNET_OK !=
-          proc(proc_cls,
-               pos,
-               (pos->is_directory == GNUNET_YES) ? pos->data.dir.dir_size
-               : pos->data.file.file_size,
-               pos->meta,
-               &pos->keywords,
-               &pos->bo,
-               (pos->is_directory == GNUNET_YES) ? &no
-               : &pos->data.file.do_index,
-               &pos->client_info))
-        break;
-      pos = pos->next;
-    }
+  {
+    no = GNUNET_NO;
+    if (GNUNET_OK !=
+        proc (proc_cls,
+              pos,
+              (pos->is_directory == GNUNET_YES) ? pos->data.dir.dir_size
+              : pos->data.file.file_size,
+              pos->meta,
+              &pos->keywords,
+              &pos->bo,
+              (pos->is_directory == GNUNET_YES) ? &no
+              : &pos->data.file.do_index,
+              &pos->client_info))
+      break;
+    pos = pos->next;
+  }
 }
 
 
@@ -398,75 +399,75 @@ GNUNET_FS_file_information_inspect(struct GNUNET_FS_FileInformation *dir,
  * @param cleaner_cls closure for @a cleaner
  */
 void
-GNUNET_FS_file_information_destroy(struct GNUNET_FS_FileInformation *fi,
-                                   GNUNET_FS_FileInformationProcessor cleaner,
-                                   void *cleaner_cls)
+GNUNET_FS_file_information_destroy (struct GNUNET_FS_FileInformation *fi,
+                                    GNUNET_FS_FileInformationProcessor cleaner,
+                                    void *cleaner_cls)
 {
   struct GNUNET_FS_FileInformation *pos;
   int no;
 
   no = GNUNET_NO;
   if (GNUNET_YES == fi->is_directory)
+  {
+    /* clean up directory */
+    while (NULL != (pos = fi->data.dir.entries))
     {
-      /* clean up directory */
-      while (NULL != (pos = fi->data.dir.entries))
-        {
-          fi->data.dir.entries = pos->next;
-          GNUNET_FS_file_information_destroy(pos, cleaner, cleaner_cls);
-        }
-      /* clean up client-info */
-      if (NULL != cleaner)
-        cleaner(cleaner_cls,
-                fi,
-                fi->data.dir.dir_size,
-                fi->meta,
-                &fi->keywords,
-                &fi->bo,
-                &no,
-                &fi->client_info);
-      GNUNET_free_non_null(fi->data.dir.dir_data);
+      fi->data.dir.entries = pos->next;
+      GNUNET_FS_file_information_destroy (pos, cleaner, cleaner_cls);
     }
+    /* clean up client-info */
+    if (NULL != cleaner)
+      cleaner (cleaner_cls,
+               fi,
+               fi->data.dir.dir_size,
+               fi->meta,
+               &fi->keywords,
+               &fi->bo,
+               &no,
+               &fi->client_info);
+    GNUNET_free_non_null (fi->data.dir.dir_data);
+  }
   else
+  {
+    /* call clean-up function of the reader */
+    if (NULL != fi->data.file.reader)
     {
-      /* call clean-up function of the reader */
-      if (NULL != fi->data.file.reader)
-        {
-          (void)fi->data.file.reader(fi->data.file.reader_cls, 0, 0, NULL, NULL);
-          fi->data.file.reader = NULL;
-        }
-      /* clean up client-info */
-      if (NULL != cleaner)
-        cleaner(cleaner_cls,
-                fi,
-                fi->data.file.file_size,
-                fi->meta,
-                &fi->keywords,
-                &fi->bo,
-                &fi->data.file.do_index,
-                &fi->client_info);
+      (void) fi->data.file.reader (fi->data.file.reader_cls, 0, 0, NULL, NULL);
+      fi->data.file.reader = NULL;
     }
-  GNUNET_free_non_null(fi->filename);
-  GNUNET_free_non_null(fi->emsg);
+    /* clean up client-info */
+    if (NULL != cleaner)
+      cleaner (cleaner_cls,
+               fi,
+               fi->data.file.file_size,
+               fi->meta,
+               &fi->keywords,
+               &fi->bo,
+               &fi->data.file.do_index,
+               &fi->client_info);
+  }
+  GNUNET_free_non_null (fi->filename);
+  GNUNET_free_non_null (fi->emsg);
   if (NULL != fi->sks_uri)
-    GNUNET_FS_uri_destroy(fi->sks_uri);
+    GNUNET_FS_uri_destroy (fi->sks_uri);
   if (NULL != fi->chk_uri)
-    GNUNET_FS_uri_destroy(fi->chk_uri);
+    GNUNET_FS_uri_destroy (fi->chk_uri);
   /* clean up serialization */
-  if ((NULL != fi->serialization) && (0 != unlink(fi->serialization)))
-    GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING,
-                             "unlink",
-                             fi->serialization);
+  if ((NULL != fi->serialization) && (0 != unlink (fi->serialization)))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+                              "unlink",
+                              fi->serialization);
   if (NULL != fi->keywords)
-    GNUNET_FS_uri_destroy(fi->keywords);
+    GNUNET_FS_uri_destroy (fi->keywords);
   if (NULL != fi->meta)
-    GNUNET_CONTAINER_meta_data_destroy(fi->meta);
-  GNUNET_free_non_null(fi->serialization);
+    GNUNET_CONTAINER_meta_data_destroy (fi->meta);
+  GNUNET_free_non_null (fi->serialization);
   if (NULL != fi->te)
-    {
-      GNUNET_FS_tree_encoder_finish(fi->te, NULL);
-      fi->te = NULL;
-    }
-  GNUNET_free(fi);
+  {
+    GNUNET_FS_tree_encoder_finish (fi->te, NULL);
+    fi->te = NULL;
+  }
+  GNUNET_free (fi);
 }
 
 
diff --git a/src/fs/fs_getopt.c b/src/fs/fs_getopt.c
index 4f53f64a5..84c1f6123 100644
--- a/src/fs/fs_getopt.c
+++ b/src/fs/fs_getopt.c
@@ -43,10 +43,10 @@
  * @return #GNUNET_OK on success
  */
 static int
-getopt_set_keywords(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-                    void *scls,
-                    const char *option,
-                    const char *value)
+getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                     void *scls,
+                     const char *option,
+                     const char *value)
 {
   struct GNUNET_FS_Uri **uri = scls;
   struct GNUNET_FS_Uri *u = *uri;
@@ -54,64 +54,64 @@ getopt_set_keywords(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
   size_t slen;
 
   if (NULL == u)
-    {
-      u = GNUNET_new(struct GNUNET_FS_Uri);
-      *uri = u;
-      u->type = GNUNET_FS_URI_KSK;
-      u->data.ksk.keywordCount = 0;
-      u->data.ksk.keywords = NULL;
-    }
+  {
+    u = GNUNET_new (struct GNUNET_FS_Uri);
+    *uri = u;
+    u->type = GNUNET_FS_URI_KSK;
+    u->data.ksk.keywordCount = 0;
+    u->data.ksk.keywords = NULL;
+  }
   else
-    {
-      GNUNET_assert(GNUNET_FS_URI_KSK == u->type);
-    }
-  slen = strlen(value);
+  {
+    GNUNET_assert (GNUNET_FS_URI_KSK == u->type);
+  }
+  slen = strlen (value);
   if (0 == slen)
     return GNUNET_SYSERR;       /* cannot be empty */
   if (value[0] == '+')
+  {
+    /* simply preserve the "mandatory" flag */
+    if (slen < 2)
+      return GNUNET_SYSERR;     /* empty keywords not allowed */
+    if ((value[1] == '"') && (slen > 3) && (value[slen - 1] == '"'))
     {
-      /* simply preserve the "mandatory" flag */
-      if (slen < 2)
-        return GNUNET_SYSERR;   /* empty keywords not allowed */
-      if ((value[1] == '"') && (slen > 3) && (value[slen - 1] == '"'))
-        {
-          /* remove the quotes, keep the '+' */
-          val = GNUNET_malloc(slen - 1);
-          val[0] = '+';
-          GNUNET_memcpy(&val[1],
-                        &value[2],
-                        slen - 3);
-          val[slen - 2] = '\0';
-        }
-      else
-        {
-          /* no quotes, just keep the '+' */
-          val = GNUNET_strdup(value);
-        }
+      /* remove the quotes, keep the '+' */
+      val = GNUNET_malloc (slen - 1);
+      val[0] = '+';
+      GNUNET_memcpy (&val[1],
+                     &value[2],
+                     slen - 3);
+      val[slen - 2] = '\0';
     }
+    else
+    {
+      /* no quotes, just keep the '+' */
+      val = GNUNET_strdup (value);
+    }
+  }
   else
+  {
+    if ((value[0] == '"') && (slen > 2) && (value[slen - 1] == '"'))
+    {
+      /* remove the quotes, add a space */
+      val = GNUNET_malloc (slen);
+      val[0] = ' ';
+      GNUNET_memcpy (&val[1],
+                     &value[1],
+                     slen - 2);
+      val[slen - 1] = '\0';
+    }
+    else
     {
-      if ((value[0] == '"') && (slen > 2) && (value[slen - 1] == '"'))
-        {
-          /* remove the quotes, add a space */
-          val = GNUNET_malloc(slen);
-          val[0] = ' ';
-          GNUNET_memcpy(&val[1],
-                        &value[1],
-                        slen - 2);
-          val[slen - 1] = '\0';
-        }
-      else
-        {
-          /* add a space to indicate "not mandatory" */
-          val = GNUNET_malloc(slen + 2);
-          strcpy(val, " ");
-          strcat(val, value);
-        }
+      /* add a space to indicate "not mandatory" */
+      val = GNUNET_malloc (slen + 2);
+      strcpy (val, " ");
+      strcat (val, value);
     }
-  GNUNET_array_append(u->data.ksk.keywords,
-                      u->data.ksk.keywordCount,
-                      val);
+  }
+  GNUNET_array_append (u->data.ksk.keywords,
+                       u->data.ksk.keywordCount,
+                       val);
   return GNUNET_OK;
 }
 
@@ -126,11 +126,11 @@ getopt_set_keywords(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] topKeywords set to the desired value
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_FS_GETOPT_KEYWORDS(char shortName,
-                          const char *name,
-                          const char *argumentHelp,
-                          const char *description,
-                          struct GNUNET_FS_Uri **topKeywords)
+GNUNET_FS_GETOPT_KEYWORDS (char shortName,
+                           const char *name,
+                           const char *argumentHelp,
+                           const char *description,
+                           struct GNUNET_FS_Uri **topKeywords)
 {
   struct GNUNET_GETOPT_CommandLineOption clo = {
     .shortName = shortName,
@@ -139,7 +139,7 @@ GNUNET_FS_GETOPT_KEYWORDS(char shortName,
     .description = description,
     .require_argument = 1,
     .processor = &getopt_set_keywords,
-    .scls = (void *)topKeywords
+    .scls = (void *) topKeywords
   };
 
   return clo;
@@ -159,10 +159,10 @@ GNUNET_FS_GETOPT_KEYWORDS(char shortName,
  * @return #GNUNET_OK on success
  */
 static int
-getopt_set_metadata(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
-                    void *scls,
-                    const char *option,
-                    const char *value)
+getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
+                     void *scls,
+                     const char *option,
+                     const char *value)
 {
   struct GNUNET_CONTAINER_MetaData **mm = scls;
 
@@ -176,66 +176,67 @@ getopt_set_metadata(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
 
   meta = *mm;
   if (meta == NULL)
-    {
-      meta = GNUNET_CONTAINER_meta_data_create();
-      *mm = meta;
-    }
+  {
+    meta = GNUNET_CONTAINER_meta_data_create ();
+    *mm = meta;
+  }
 
   /* Use GNUNET_STRINGS_get_utf8_args() in main() to acquire utf-8-encoded
    * commandline arguments, so that the following line is not needed.
    */
   /*tmp = GNUNET_STRINGS_to_utf8 (value, strlen (value), locale_charset ());*/
-  tmp = GNUNET_strdup(value);
+  tmp = GNUNET_strdup (value);
 #if HAVE_EXTRACTOR_H && HAVE_LIBEXTRACTOR
-  type = EXTRACTOR_metatype_get_max();
+  type = EXTRACTOR_metatype_get_max ();
   while (type > 0)
+  {
+    type--;
+    typename = EXTRACTOR_metatype_to_string (type);
+    typename_i18n = dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN, typename);
+    if ((strlen (tmp) >= strlen (typename) + 1) &&
+        (tmp[strlen (typename)] == ':') &&
+        (0 == strncmp (typename, tmp, strlen (typename))))
     {
-      type--;
-      typename = EXTRACTOR_metatype_to_string(type);
-      typename_i18n = dgettext(LIBEXTRACTOR_GETTEXT_DOMAIN, typename);
-      if ((strlen(tmp) >= strlen(typename) + 1) &&
-          (tmp[strlen(typename)] == ':') &&
-          (0 == strncmp(typename, tmp, strlen(typename))))
-        {
-          GNUNET_CONTAINER_meta_data_insert(meta, "<gnunet>", type,
-                                            EXTRACTOR_METAFORMAT_UTF8,
-                                            "text/plain",
-                                            &tmp[strlen(typename) + 1],
-                                            strlen(&tmp[strlen(typename) + 1]) +
-                                            1);
-          GNUNET_free(tmp);
-          tmp = NULL;
-          break;
-        }
-      if ((strlen(tmp) >= strlen(typename_i18n) + 1) &&
-          (tmp[strlen(typename_i18n)] == ':') &&
-          (0 == strncmp(typename_i18n, tmp, strlen(typename_i18n))))
-        {
-          GNUNET_CONTAINER_meta_data_insert(meta, "<gnunet>", type,
-                                            EXTRACTOR_METAFORMAT_UTF8,
-                                            "text/plain",
-                                            &tmp[strlen(typename_i18n) + 1],
-                                            strlen(&tmp
-                                                   [strlen(typename_i18n) + 1]) +
-                                            1);
-          GNUNET_free(tmp);
-          tmp = NULL;
-          break;
-        }
+      GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>", type,
+                                         EXTRACTOR_METAFORMAT_UTF8,
+                                         "text/plain",
+                                         &tmp[strlen (typename) + 1],
+                                         strlen (&tmp[strlen (typename) + 1])
+                                         + 1);
+      GNUNET_free (tmp);
+      tmp = NULL;
+      break;
     }
+    if ((strlen (tmp) >= strlen (typename_i18n) + 1) &&
+        (tmp[strlen (typename_i18n)] == ':') &&
+        (0 == strncmp (typename_i18n, tmp, strlen (typename_i18n))))
+    {
+      GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>", type,
+                                         EXTRACTOR_METAFORMAT_UTF8,
+                                         "text/plain",
+                                         &tmp[strlen (typename_i18n) + 1],
+                                         strlen (&tmp
+                                                 [strlen (typename_i18n) + 1])
+                                         + 1);
+      GNUNET_free (tmp);
+      tmp = NULL;
+      break;
+    }
+  }
 #endif
 
   if (NULL != tmp)
-    {
-      GNUNET_CONTAINER_meta_data_insert(meta, "<gnunet>",
-                                        EXTRACTOR_METATYPE_UNKNOWN,
-                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                        tmp, strlen(tmp) + 1);
-      GNUNET_free(tmp);
-      printf(_
-               ("Unknown metadata type in metadata option `%s'.  Using metadata type `unknown' instead.\n"),
-             value);
-    }
+  {
+    GNUNET_CONTAINER_meta_data_insert (meta, "<gnunet>",
+                                       EXTRACTOR_METATYPE_UNKNOWN,
+                                       EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                       tmp, strlen (tmp) + 1);
+    GNUNET_free (tmp);
+    printf (_
+            (
+              "Unknown metadata type in metadata option `%s'.  Using metadata type `unknown' instead.\n"),
+            value);
+  }
   return GNUNET_OK;
 }
 
@@ -249,11 +250,11 @@ getopt_set_metadata(struct GNUNET_GETOPT_CommandLineProcessorContext *ctx,
  * @param[out] metadata set to the desired value
  */
 struct GNUNET_GETOPT_CommandLineOption
-GNUNET_FS_GETOPT_METADATA(char shortName,
-                          const char *name,
-                          const char *argumentHelp,
-                          const char *description,
-                          struct GNUNET_CONTAINER_MetaData **meta)
+GNUNET_FS_GETOPT_METADATA (char shortName,
+                           const char *name,
+                           const char *argumentHelp,
+                           const char *description,
+                           struct GNUNET_CONTAINER_MetaData **meta)
 {
   struct GNUNET_GETOPT_CommandLineOption clo = {
     .shortName = shortName,
@@ -262,7 +263,7 @@ GNUNET_FS_GETOPT_METADATA(char shortName,
     .description = description,
     .require_argument = 1,
     .processor = &getopt_set_metadata,
-    .scls = (void *)meta
+    .scls = (void *) meta
   };
 
   return clo;
diff --git a/src/fs/fs_list_indexed.c b/src/fs/fs_list_indexed.c
index c023d0ac6..0e16fb01b 100644
--- a/src/fs/fs_list_indexed.c
+++ b/src/fs/fs_list_indexed.c
@@ -34,7 +34,8 @@
 /**
  * Context for #GNUNET_FS_get_indexed_files().
  */
-struct GNUNET_FS_GetIndexedContext {
+struct GNUNET_FS_GetIndexedContext
+{
   /**
    * Connection to the FS service.
    */
@@ -70,15 +71,15 @@ struct GNUNET_FS_GetIndexedContext {
  * @param msg message with indexing information
  */
 static void
-handle_index_info_end(void *cls,
-                      const struct GNUNET_MessageHeader *msg)
+handle_index_info_end (void *cls,
+                       const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_GetIndexedContext *gic = cls;
 
-  (void)gic->iterator(gic->iterator_cls,
-                      NULL,
-                      NULL);
-  GNUNET_FS_get_indexed_files_cancel(gic);
+  (void) gic->iterator (gic->iterator_cls,
+                        NULL,
+                        NULL);
+  GNUNET_FS_get_indexed_files_cancel (gic);
 }
 
 
@@ -90,18 +91,18 @@ handle_index_info_end(void *cls,
  * @param iim message with indexing information
  */
 static int
-check_index_info(void *cls,
-                 const struct IndexInfoMessage *iim)
+check_index_info (void *cls,
+                  const struct IndexInfoMessage *iim)
 {
-  uint16_t msize = ntohs(iim->header.size) - sizeof(*iim);
+  uint16_t msize = ntohs (iim->header.size) - sizeof(*iim);
   const char *filename;
 
-  filename = (const char *)&iim[1];
+  filename = (const char *) &iim[1];
   if (filename[msize - 1] != '\0')
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -114,21 +115,21 @@ check_index_info(void *cls,
  * @param iim message with indexing information
  */
 static void
-handle_index_info(void *cls,
-                  const struct IndexInfoMessage *iim)
+handle_index_info (void *cls,
+                   const struct IndexInfoMessage *iim)
 {
   struct GNUNET_FS_GetIndexedContext *gic = cls;
   const char *filename;
 
-  filename = (const char *)&iim[1];
+  filename = (const char *) &iim[1];
   if (GNUNET_OK !=
-      gic->iterator(gic->iterator_cls,
-                    filename,
-                    &iim->file_id))
-    {
-      GNUNET_FS_get_indexed_files_cancel(gic);
-      return;
-    }
+      gic->iterator (gic->iterator_cls,
+                     filename,
+                     &iim->file_id))
+  {
+    GNUNET_FS_get_indexed_files_cancel (gic);
+    return;
+  }
 }
 
 
@@ -141,16 +142,16 @@ handle_index_info(void *cls,
  * @param error error code
  */
 static void
-mq_error_handler(void *cls,
-                 enum GNUNET_MQ_Error error)
+mq_error_handler (void *cls,
+                  enum GNUNET_MQ_Error error)
 {
   struct GNUNET_FS_GetIndexedContext *gic = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             _("Failed to receive response from `%s' service.\n"),
-             "fs");
-  (void)gic->iterator(gic->iterator_cls, NULL, NULL);
-  GNUNET_FS_get_indexed_files_cancel(gic);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ ("Failed to receive response from `%s' service.\n"),
+              "fs");
+  (void) gic->iterator (gic->iterator_cls, NULL, NULL);
+  GNUNET_FS_get_indexed_files_cancel (gic);
 }
 
 
@@ -163,45 +164,45 @@ mq_error_handler(void *cls,
  * @return NULL on error ('iter' is not called)
  */
 struct GNUNET_FS_GetIndexedContext *
-GNUNET_FS_get_indexed_files(struct GNUNET_FS_Handle *h,
-                            GNUNET_FS_IndexedFileProcessor iterator,
-                            void *iterator_cls)
+GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h,
+                             GNUNET_FS_IndexedFileProcessor iterator,
+                             void *iterator_cls)
 {
   struct GNUNET_FS_GetIndexedContext *gic
-    = GNUNET_new(struct GNUNET_FS_GetIndexedContext);
+    = GNUNET_new (struct GNUNET_FS_GetIndexedContext);
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_fixed_size(index_info_end,
-                            GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END,
-                            struct GNUNET_MessageHeader,
-                            gic),
-    GNUNET_MQ_hd_var_size(index_info,
-                          GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY,
-                          struct IndexInfoMessage,
-                          gic),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_fixed_size (index_info_end,
+                             GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END,
+                             struct GNUNET_MessageHeader,
+                             gic),
+    GNUNET_MQ_hd_var_size (index_info,
+                           GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY,
+                           struct IndexInfoMessage,
+                           gic),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
 
-  gic->mq = GNUNET_CLIENT_connect(h->cfg,
-                                  "fs",
-                                  handlers,
-                                  &mq_error_handler,
-                                  h);
+  gic->mq = GNUNET_CLIENT_connect (h->cfg,
+                                   "fs",
+                                   handlers,
+                                   &mq_error_handler,
+                                   h);
   if (NULL == gic->mq)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failed to not connect to `%s' service.\n"),
-                 "fs");
-      GNUNET_free(gic);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to not connect to `%s' service.\n"),
+                "fs");
+    GNUNET_free (gic);
+    return NULL;
+  }
   gic->iterator = iterator;
   gic->iterator_cls = iterator_cls;
-  env = GNUNET_MQ_msg(msg,
-                      GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET);
-  GNUNET_MQ_send(gic->mq,
-                 env);
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET);
+  GNUNET_MQ_send (gic->mq,
+                  env);
   return gic;
 }
 
@@ -212,10 +213,10 @@ GNUNET_FS_get_indexed_files(struct GNUNET_FS_Handle *h,
  * @param gic operation to cancel
  */
 void
-GNUNET_FS_get_indexed_files_cancel(struct GNUNET_FS_GetIndexedContext *gic)
+GNUNET_FS_get_indexed_files_cancel (struct GNUNET_FS_GetIndexedContext *gic)
 {
-  GNUNET_MQ_destroy(gic->mq);
-  GNUNET_free(gic);
+  GNUNET_MQ_destroy (gic->mq);
+  GNUNET_free (gic);
 }
 
 
diff --git a/src/fs/fs_misc.c b/src/fs/fs_misc.c
index 79f082626..2e7816d65 100644
--- a/src/fs/fs_misc.c
+++ b/src/fs/fs_misc.c
@@ -35,8 +35,8 @@
  * @return NULL if meta data is useless for suggesting a filename
  */
 char *
-GNUNET_FS_meta_data_suggest_filename(const struct GNUNET_CONTAINER_MetaData
-                                     *md)
+GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData
+                                      *md)
 {
   static const char *mimeMap[][2] = {
     { "application/bz2", ".bz2" },
@@ -111,52 +111,52 @@ GNUNET_FS_meta_data_suggest_filename(const struct GNUNET_CONTAINER_MetaData
   const char *ext;
 
   ret =
-    GNUNET_CONTAINER_meta_data_get_by_type(md,
-                                           EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+    GNUNET_CONTAINER_meta_data_get_by_type (md,
+                                            EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
   if (ret != NULL)
     return ret;
   ext = NULL;
   mime =
-    GNUNET_CONTAINER_meta_data_get_by_type(md, EXTRACTOR_METATYPE_MIMETYPE);
+    GNUNET_CONTAINER_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
   if (mime != NULL)
-    {
-      i = 0;
-      while ((mimeMap[i][0] != NULL) && (0 != strcmp(mime, mimeMap[i][0])))
-        i++;
-      if (mimeMap[i][1] == NULL)
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-                   _("Did not find mime type `%s' in extension list.\n"), mime);
-      else
-        ext = mimeMap[i][1];
-      GNUNET_free(mime);
-    }
+  {
+    i = 0;
+    while ((mimeMap[i][0] != NULL) && (0 != strcmp (mime, mimeMap[i][0])))
+      i++;
+    if (mimeMap[i][1] == NULL)
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+                  _ ("Did not find mime type `%s' in extension list.\n"), mime);
+    else
+      ext = mimeMap[i][1];
+    GNUNET_free (mime);
+  }
   base =
-    GNUNET_CONTAINER_meta_data_get_first_by_types(md,
-                                                  EXTRACTOR_METATYPE_TITLE,
-                                                  EXTRACTOR_METATYPE_BOOK_TITLE,
-                                                  EXTRACTOR_METATYPE_ORIGINAL_TITLE,
-                                                  EXTRACTOR_METATYPE_PACKAGE_NAME,
-                                                  EXTRACTOR_METATYPE_URL,
-                                                  EXTRACTOR_METATYPE_URI,
-                                                  EXTRACTOR_METATYPE_DESCRIPTION,
-                                                  EXTRACTOR_METATYPE_ISRC,
-                                                  EXTRACTOR_METATYPE_JOURNAL_NAME,
-                                                  EXTRACTOR_METATYPE_AUTHOR_NAME,
-                                                  EXTRACTOR_METATYPE_SUBJECT,
-                                                  EXTRACTOR_METATYPE_ALBUM,
-                                                  EXTRACTOR_METATYPE_ARTIST,
-                                                  EXTRACTOR_METATYPE_KEYWORDS,
-                                                  EXTRACTOR_METATYPE_COMMENT,
-                                                  EXTRACTOR_METATYPE_UNKNOWN,
-                                                  -1);
+    GNUNET_CONTAINER_meta_data_get_first_by_types (md,
+                                                   EXTRACTOR_METATYPE_TITLE,
+                                                   EXTRACTOR_METATYPE_BOOK_TITLE,
+                                                   EXTRACTOR_METATYPE_ORIGINAL_TITLE,
+                                                   EXTRACTOR_METATYPE_PACKAGE_NAME,
+                                                   EXTRACTOR_METATYPE_URL,
+                                                   EXTRACTOR_METATYPE_URI,
+                                                   EXTRACTOR_METATYPE_DESCRIPTION,
+                                                   EXTRACTOR_METATYPE_ISRC,
+                                                   EXTRACTOR_METATYPE_JOURNAL_NAME,
+                                                   EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                                   EXTRACTOR_METATYPE_SUBJECT,
+                                                   EXTRACTOR_METATYPE_ALBUM,
+                                                   EXTRACTOR_METATYPE_ARTIST,
+                                                   EXTRACTOR_METATYPE_KEYWORDS,
+                                                   EXTRACTOR_METATYPE_COMMENT,
+                                                   EXTRACTOR_METATYPE_UNKNOWN,
+                                                   -1);
   if ((base == NULL) && (ext == NULL))
     return NULL;
   if (base == NULL)
-    return GNUNET_strdup(ext);
+    return GNUNET_strdup (ext);
   if (ext == NULL)
     return base;
-  GNUNET_asprintf(&ret, "%s%s", base, ext);
-  GNUNET_free(base);
+  GNUNET_asprintf (&ret, "%s%s", base, ext);
+  GNUNET_free (base);
   return ret;
 }
 
diff --git a/src/fs/fs_namespace.c b/src/fs/fs_namespace.c
index b740eb2ba..6ede02afd 100644
--- a/src/fs/fs_namespace.c
+++ b/src/fs/fs_namespace.c
@@ -37,7 +37,8 @@
  * Information about an (updateable) node in the
  * namespace.
  */
-struct NamespaceUpdateNode {
+struct NamespaceUpdateNode
+{
   /**
    * Identifier for this node.
    */
@@ -74,7 +75,8 @@ struct NamespaceUpdateNode {
 /**
  * Handle to update information for a namespace.
  */
-struct GNUNET_FS_UpdateInformationGraph {
+struct GNUNET_FS_UpdateInformationGraph
+{
   /**
    * Handle to the FS service context.
    */
@@ -122,7 +124,7 @@ struct GNUNET_FS_UpdateInformationGraph {
  * @return NULL on error, otherwise the name of the directory
  */
 static char *
-get_update_information_directory(
+get_update_information_directory (
   struct GNUNET_FS_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
 {
@@ -133,20 +135,20 @@ get_update_information_directory(
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename(h->cfg, "FS", "UPDATE_DIR", &dn))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR, "fs", "UPDATE_DIR");
-      return NULL;
-    }
-  GNUNET_CRYPTO_ecdsa_key_get_public(ns, &pub);
-  GNUNET_CRYPTO_hash(&pub, sizeof(pub), &hc);
-  GNUNET_CRYPTO_hash_to_enc(&hc, &enc);
-  GNUNET_asprintf(&ret,
-                  "%s%s%s",
-                  dn,
-                  DIR_SEPARATOR_STR,
-                  (const char *)enc.encoding);
-  GNUNET_free(dn);
+      GNUNET_CONFIGURATION_get_value_filename (h->cfg, "FS", "UPDATE_DIR", &dn))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "fs", "UPDATE_DIR");
+    return NULL;
+  }
+  GNUNET_CRYPTO_ecdsa_key_get_public (ns, &pub);
+  GNUNET_CRYPTO_hash (&pub, sizeof(pub), &hc);
+  GNUNET_CRYPTO_hash_to_enc (&hc, &enc);
+  GNUNET_asprintf (&ret,
+                   "%s%s%s",
+                   dn,
+                   DIR_SEPARATOR_STR,
+                   (const char *) enc.encoding);
+  GNUNET_free (dn);
   return ret;
 }
 
@@ -157,24 +159,24 @@ get_update_information_directory(
  * @param uig data structure to free
  */
 static void
-free_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
+free_update_information_graph (struct GNUNET_FS_UpdateInformationGraph *uig)
 {
   unsigned int i;
   struct NamespaceUpdateNode *nsn;
 
   for (i = 0; i < uig->update_node_count; i++)
-    {
-      nsn = uig->update_nodes[i];
-      GNUNET_CONTAINER_meta_data_destroy(nsn->md);
-      GNUNET_FS_uri_destroy(nsn->uri);
-      GNUNET_free(nsn->id);
-      GNUNET_free(nsn->update);
-      GNUNET_free(nsn);
-    }
-  GNUNET_array_grow(uig->update_nodes, uig->update_node_count, 0);
+  {
+    nsn = uig->update_nodes[i];
+    GNUNET_CONTAINER_meta_data_destroy (nsn->md);
+    GNUNET_FS_uri_destroy (nsn->uri);
+    GNUNET_free (nsn->id);
+    GNUNET_free (nsn->update);
+    GNUNET_free (nsn);
+  }
+  GNUNET_array_grow (uig->update_nodes, uig->update_node_count, 0);
   if (NULL != uig->update_map)
-    GNUNET_CONTAINER_multihashmap_destroy(uig->update_map);
-  GNUNET_free(uig);
+    GNUNET_CONTAINER_multihashmap_destroy (uig->update_map);
+  GNUNET_free (uig);
 }
 
 
@@ -184,7 +186,7 @@ free_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
  * @param uig update information graph to dump
  */
 static void
-write_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
+write_update_information_graph (struct GNUNET_FS_UpdateInformationGraph *uig)
 {
   char *fn;
   struct GNUNET_BIO_WriteHandle *wh;
@@ -192,40 +194,40 @@ write_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
   struct NamespaceUpdateNode *n;
   char *uris;
 
-  fn = get_update_information_directory(uig->h, &uig->ns);
-  wh = GNUNET_BIO_write_open(fn);
+  fn = get_update_information_directory (uig->h, &uig->ns);
+  wh = GNUNET_BIO_write_open (fn);
   if (NULL == wh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to open `%s' for writing: %s\n"),
-                 fn,
-                 strerror(errno));
-      GNUNET_free(fn);
-      return;
-    }
-  if (GNUNET_OK != GNUNET_BIO_write_int32(wh, uig->update_node_count))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to open `%s' for writing: %s\n"),
+                fn,
+                strerror (errno));
+    GNUNET_free (fn);
+    return;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_int32 (wh, uig->update_node_count))
     goto END;
   for (i = 0; i < uig->update_node_count; i++)
+  {
+    n = uig->update_nodes[i];
+    uris = GNUNET_FS_uri_to_string (n->uri);
+    if ((GNUNET_OK != GNUNET_BIO_write_string (wh, n->id)) ||
+        (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, n->md)) ||
+        (GNUNET_OK != GNUNET_BIO_write_string (wh, n->update)) ||
+        (GNUNET_OK != GNUNET_BIO_write_string (wh, uris)))
     {
-      n = uig->update_nodes[i];
-      uris = GNUNET_FS_uri_to_string(n->uri);
-      if ((GNUNET_OK != GNUNET_BIO_write_string(wh, n->id)) ||
-          (GNUNET_OK != GNUNET_BIO_write_meta_data(wh, n->md)) ||
-          (GNUNET_OK != GNUNET_BIO_write_string(wh, n->update)) ||
-          (GNUNET_OK != GNUNET_BIO_write_string(wh, uris)))
-        {
-          GNUNET_free(uris);
-          break;
-        }
-      GNUNET_free(uris);
+      GNUNET_free (uris);
+      break;
     }
+    GNUNET_free (uris);
+  }
 END:
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-               _("Failed to write `%s': %s\n"),
-               fn,
-               strerror(errno));
-  GNUNET_free(fn);
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to write `%s': %s\n"),
+                fn,
+                strerror (errno));
+  GNUNET_free (fn);
 }
 
 
@@ -237,8 +239,8 @@ END:
  * @return update graph, never NULL
  */
 static struct GNUNET_FS_UpdateInformationGraph *
-read_update_information_graph(struct GNUNET_FS_Handle *h,
-                              const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
+read_update_information_graph (struct GNUNET_FS_Handle *h,
+                               const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
 {
   struct GNUNET_FS_UpdateInformationGraph *uig;
   char *fn;
@@ -249,79 +251,79 @@ read_update_information_graph(struct GNUNET_FS_Handle *h,
   uint32_t count;
   char *emsg;
 
-  uig = GNUNET_new(struct GNUNET_FS_UpdateInformationGraph);
+  uig = GNUNET_new (struct GNUNET_FS_UpdateInformationGraph);
   uig->h = h;
   uig->ns = *ns;
-  fn = get_update_information_directory(h, ns);
-  if (GNUNET_YES != GNUNET_DISK_file_test(fn))
-    {
-      GNUNET_free(fn);
-      return uig;
-    }
-  rh = GNUNET_BIO_read_open(fn);
+  fn = get_update_information_directory (h, ns);
+  if (GNUNET_YES != GNUNET_DISK_file_test (fn))
+  {
+    GNUNET_free (fn);
+    return uig;
+  }
+  rh = GNUNET_BIO_read_open (fn);
   if (NULL == rh)
-    {
-      GNUNET_free(fn);
-      return uig;
-    }
-  if (GNUNET_OK != GNUNET_BIO_read_int32(rh, &count))
-    {
-      GNUNET_break(0);
-      goto END;
-    }
+  {
+    GNUNET_free (fn);
+    return uig;
+  }
+  if (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &count))
+  {
+    GNUNET_break (0);
+    goto END;
+  }
   if (count > 1024 * 1024)
-    {
-      GNUNET_break(0);
-      goto END;
-    }
+  {
+    GNUNET_break (0);
+    goto END;
+  }
   if (0 == count)
     goto END;
   uig->update_nodes =
-    GNUNET_malloc(count * sizeof(struct NamespaceUpdateNode *));
+    GNUNET_malloc (count * sizeof(struct NamespaceUpdateNode *));
 
   for (i = 0; i < count; i++)
+  {
+    n = GNUNET_new (struct NamespaceUpdateNode);
+    if ((GNUNET_OK !=
+         GNUNET_BIO_read_string (rh, "identifier", &n->id, 1024)) ||
+        (GNUNET_OK != GNUNET_BIO_read_meta_data (rh, "meta", &n->md)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_read_string (rh, "update-id", &n->update, 1024)) ||
+        (GNUNET_OK != GNUNET_BIO_read_string (rh, "uri", &uris, 1024 * 2)))
     {
-      n = GNUNET_new(struct NamespaceUpdateNode);
-      if ((GNUNET_OK !=
-           GNUNET_BIO_read_string(rh, "identifier", &n->id, 1024)) ||
-          (GNUNET_OK != GNUNET_BIO_read_meta_data(rh, "meta", &n->md)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_read_string(rh, "update-id", &n->update, 1024)) ||
-          (GNUNET_OK != GNUNET_BIO_read_string(rh, "uri", &uris, 1024 * 2)))
-        {
-          GNUNET_break(0);
-          GNUNET_free_non_null(n->id);
-          GNUNET_free_non_null(n->update);
-          if (n->md != NULL)
-            GNUNET_CONTAINER_meta_data_destroy(n->md);
-          GNUNET_free(n);
-          break;
-        }
-      n->uri = GNUNET_FS_uri_parse(uris, &emsg);
-      GNUNET_free(uris);
-      if (n->uri == NULL)
-        {
-          GNUNET_break(0);
-          GNUNET_free(emsg);
-          GNUNET_free(n->id);
-          GNUNET_free_non_null(n->update);
-          GNUNET_CONTAINER_meta_data_destroy(n->md);
-          GNUNET_free(n);
-          break;
-        }
-      uig->update_nodes[i] = n;
+      GNUNET_break (0);
+      GNUNET_free_non_null (n->id);
+      GNUNET_free_non_null (n->update);
+      if (n->md != NULL)
+        GNUNET_CONTAINER_meta_data_destroy (n->md);
+      GNUNET_free (n);
+      break;
     }
-  uig->update_node_count = i;
-END:
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
+    n->uri = GNUNET_FS_uri_parse (uris, &emsg);
+    GNUNET_free (uris);
+    if (n->uri == NULL)
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to read `%s': %s\n"),
-                 fn,
-                 emsg);
-      GNUNET_free(emsg);
+      GNUNET_break (0);
+      GNUNET_free (emsg);
+      GNUNET_free (n->id);
+      GNUNET_free_non_null (n->update);
+      GNUNET_CONTAINER_meta_data_destroy (n->md);
+      GNUNET_free (n);
+      break;
     }
-  GNUNET_free(fn);
+    uig->update_nodes[i] = n;
+  }
+  uig->update_node_count = i;
+END:
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to read `%s': %s\n"),
+                fn,
+                emsg);
+    GNUNET_free (emsg);
+  }
+  GNUNET_free (fn);
   return uig;
 }
 
@@ -329,7 +331,8 @@ END:
 /**
  * Context for the SKS publication.
  */
-struct GNUNET_FS_PublishSksContext {
+struct GNUNET_FS_PublishSksContext
+{
   /**
    * URI of the new entry in the namespace.
    */
@@ -381,33 +384,33 @@ struct GNUNET_FS_PublishSksContext {
  * @param msg error message (or NULL)
  */
 static void
-sks_publish_cont(void *cls, const char *msg)
+sks_publish_cont (void *cls, const char *msg)
 {
   struct GNUNET_FS_PublishSksContext *psc = cls;
   struct GNUNET_FS_UpdateInformationGraph *uig;
 
   psc->uc = NULL;
   if (NULL != msg)
-    {
-      if (NULL != psc->cont)
-        psc->cont(psc->cont_cls, NULL, msg);
-      GNUNET_FS_publish_sks_cancel(psc);
-      return;
-    }
+  {
+    if (NULL != psc->cont)
+      psc->cont (psc->cont_cls, NULL, msg);
+    GNUNET_FS_publish_sks_cancel (psc);
+    return;
+  }
   if (NULL != psc->nsn)
-    {
-      /* FIXME: this can be done much more
-       * efficiently by simply appending to the
-       * file and overwriting the 4-byte header */
-      uig = read_update_information_graph(psc->h, &psc->ns);
-      GNUNET_array_append(uig->update_nodes, uig->update_node_count, psc->nsn);
-      psc->nsn = NULL;
-      write_update_information_graph(uig);
-      free_update_information_graph(uig);
-    }
+  {
+    /* FIXME: this can be done much more
+     * efficiently by simply appending to the
+     * file and overwriting the 4-byte header */
+    uig = read_update_information_graph (psc->h, &psc->ns);
+    GNUNET_array_append (uig->update_nodes, uig->update_node_count, psc->nsn);
+    psc->nsn = NULL;
+    write_update_information_graph (uig);
+    free_update_information_graph (uig);
+  }
   if (NULL != psc->cont)
-    psc->cont(psc->cont_cls, psc->uri, NULL);
-  GNUNET_FS_publish_sks_cancel(psc);
+    psc->cont (psc->cont_cls, psc->uri, NULL);
+  GNUNET_FS_publish_sks_cancel (psc);
 }
 
 
@@ -427,59 +430,59 @@ sks_publish_cont(void *cls, const char *msg)
  * @return NULL on error ('cont' will still be called)
  */
 struct GNUNET_FS_PublishSksContext *
-GNUNET_FS_publish_sks(struct GNUNET_FS_Handle *h,
-                      const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
-                      const char *identifier,
-                      const char *update,
-                      const struct GNUNET_CONTAINER_MetaData *meta,
-                      const struct GNUNET_FS_Uri *uri,
-                      const struct GNUNET_FS_BlockOptions *bo,
-                      enum GNUNET_FS_PublishOptions options,
-                      GNUNET_FS_PublishContinuation cont,
-                      void *cont_cls)
+GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
+                       const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
+                       const char *identifier,
+                       const char *update,
+                       const struct GNUNET_CONTAINER_MetaData *meta,
+                       const struct GNUNET_FS_Uri *uri,
+                       const struct GNUNET_FS_BlockOptions *bo,
+                       enum GNUNET_FS_PublishOptions options,
+                       GNUNET_FS_PublishContinuation cont,
+                       void *cont_cls)
 {
   struct GNUNET_FS_PublishSksContext *psc;
   struct GNUNET_FS_Uri *sks_uri;
 
-  sks_uri = GNUNET_new(struct GNUNET_FS_Uri);
+  sks_uri = GNUNET_new (struct GNUNET_FS_Uri);
   sks_uri->type = GNUNET_FS_URI_SKS;
-  sks_uri->data.sks.identifier = GNUNET_strdup(identifier);
-  GNUNET_CRYPTO_ecdsa_key_get_public(ns, &sks_uri->data.sks.ns);
+  sks_uri->data.sks.identifier = GNUNET_strdup (identifier);
+  GNUNET_CRYPTO_ecdsa_key_get_public (ns, &sks_uri->data.sks.ns);
 
-  psc = GNUNET_new(struct GNUNET_FS_PublishSksContext);
+  psc = GNUNET_new (struct GNUNET_FS_PublishSksContext);
   psc->h = h;
   psc->uri = sks_uri;
   psc->cont = cont;
   psc->cont_cls = cont_cls;
   psc->ns = *ns;
   if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
+  {
+    psc->dsh = GNUNET_DATASTORE_connect (h->cfg);
+    if (NULL == psc->dsh)
     {
-      psc->dsh = GNUNET_DATASTORE_connect(h->cfg);
-      if (NULL == psc->dsh)
-        {
-          sks_publish_cont(psc, _("Failed to connect to datastore."));
-          return NULL;
-        }
+      sks_publish_cont (psc, _ ("Failed to connect to datastore."));
+      return NULL;
     }
+  }
   if (NULL != update)
-    {
-      psc->nsn = GNUNET_new(struct NamespaceUpdateNode);
-      psc->nsn->id = GNUNET_strdup(identifier);
-      psc->nsn->update = GNUNET_strdup(update);
-      psc->nsn->md = GNUNET_CONTAINER_meta_data_duplicate(meta);
-      psc->nsn->uri = GNUNET_FS_uri_dup(uri);
-    }
-  psc->uc = GNUNET_FS_publish_ublock_(h,
-                                      psc->dsh,
-                                      identifier,
-                                      update,
-                                      ns,
-                                      meta,
-                                      uri,
-                                      bo,
-                                      options,
-                                      &sks_publish_cont,
-                                      psc);
+  {
+    psc->nsn = GNUNET_new (struct NamespaceUpdateNode);
+    psc->nsn->id = GNUNET_strdup (identifier);
+    psc->nsn->update = GNUNET_strdup (update);
+    psc->nsn->md = GNUNET_CONTAINER_meta_data_duplicate (meta);
+    psc->nsn->uri = GNUNET_FS_uri_dup (uri);
+  }
+  psc->uc = GNUNET_FS_publish_ublock_ (h,
+                                       psc->dsh,
+                                       identifier,
+                                       update,
+                                       ns,
+                                       meta,
+                                       uri,
+                                       bo,
+                                       options,
+                                       &sks_publish_cont,
+                                       psc);
   return psc;
 }
 
@@ -490,35 +493,36 @@ GNUNET_FS_publish_sks(struct GNUNET_FS_Handle *h,
  * @param psc context of the operation to abort.
  */
 void
-GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
+GNUNET_FS_publish_sks_cancel (struct GNUNET_FS_PublishSksContext *psc)
 {
   if (NULL != psc->uc)
-    {
-      GNUNET_FS_publish_ublock_cancel_(psc->uc);
-      psc->uc = NULL;
-    }
+  {
+    GNUNET_FS_publish_ublock_cancel_ (psc->uc);
+    psc->uc = NULL;
+  }
   if (NULL != psc->dsh)
-    {
-      GNUNET_DATASTORE_disconnect(psc->dsh, GNUNET_NO);
-      psc->dsh = NULL;
-    }
-  GNUNET_FS_uri_destroy(psc->uri);
+  {
+    GNUNET_DATASTORE_disconnect (psc->dsh, GNUNET_NO);
+    psc->dsh = NULL;
+  }
+  GNUNET_FS_uri_destroy (psc->uri);
   if (NULL != psc->nsn)
-    {
-      GNUNET_CONTAINER_meta_data_destroy(psc->nsn->md);
-      GNUNET_FS_uri_destroy(psc->nsn->uri);
-      GNUNET_free(psc->nsn->id);
-      GNUNET_free(psc->nsn->update);
-      GNUNET_free(psc->nsn);
-    }
-  GNUNET_free(psc);
+  {
+    GNUNET_CONTAINER_meta_data_destroy (psc->nsn->md);
+    GNUNET_FS_uri_destroy (psc->nsn->uri);
+    GNUNET_free (psc->nsn->id);
+    GNUNET_free (psc->nsn->update);
+    GNUNET_free (psc->nsn);
+  }
+  GNUNET_free (psc);
 }
 
 
 /**
  * Closure for 'process_update_node'.
  */
-struct ProcessUpdateClosure {
+struct ProcessUpdateClosure
+{
   /**
    * Function to call for each node.
    */
@@ -542,12 +546,12 @@ struct ProcessUpdateClosure {
  *         GNUNET_NO if not.
  */
 static int
-process_update_node(void *cls, const struct GNUNET_HashCode *key, void *value)
+process_update_node (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct ProcessUpdateClosure *pc = cls;
   struct NamespaceUpdateNode *nsn = value;
 
-  pc->ip(pc->ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
+  pc->ip (pc->ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
   return GNUNET_YES;
 }
 
@@ -555,7 +559,8 @@ process_update_node(void *cls, const struct GNUNET_HashCode *key, void *value)
 /**
  * Closure for 'find_trees'.
  */
-struct FindTreeClosure {
+struct FindTreeClosure
+{
   /**
    * UIG we are operating on.
    */
@@ -604,38 +609,38 @@ struct FindTreeClosure {
  *         GNUNET_NO if not.
  */
 static int
-find_trees(void *cls, const struct GNUNET_HashCode *key, void *value)
+find_trees (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct FindTreeClosure *fc = cls;
   struct NamespaceUpdateNode *nsn = value;
   struct GNUNET_HashCode hc;
 
   if (nsn->nug == fc->nug)
-    {
-      if (UINT_MAX == nsn->tree_id)
-        return GNUNET_YES; /* circular */
-      GNUNET_assert(nsn->tree_id < fc->tree_array_size);
-      if (fc->tree_array[nsn->tree_id] != nsn)
-        return GNUNET_YES; /* part of "another" (directed) TREE,
+  {
+    if (UINT_MAX == nsn->tree_id)
+      return GNUNET_YES;   /* circular */
+    GNUNET_assert (nsn->tree_id < fc->tree_array_size);
+    if (fc->tree_array[nsn->tree_id] != nsn)
+      return GNUNET_YES;   /* part of "another" (directed) TREE,
                             * and not root of it, end trace */
-      if (nsn->tree_id == fc->id)
-        return GNUNET_YES; /* that's our own root (can this be?) */
-      /* merge existing TREE, we have a root for both */
-      fc->tree_array[nsn->tree_id] = NULL;
-      if (UINT_MAX == fc->id)
-        fc->id = nsn->tree_id; /* take over ID */
-    }
+    if (nsn->tree_id == fc->id)
+      return GNUNET_YES;   /* that's our own root (can this be?) */
+    /* merge existing TREE, we have a root for both */
+    fc->tree_array[nsn->tree_id] = NULL;
+    if (UINT_MAX == fc->id)
+      fc->id = nsn->tree_id;   /* take over ID */
+  }
   else
-    {
-      nsn->nug = fc->nug;
-      nsn->tree_id = UINT_MAX; /* mark as undef */
-      /* trace */
-      GNUNET_CRYPTO_hash(nsn->update, strlen(nsn->update), &hc);
-      GNUNET_CONTAINER_multihashmap_get_multiple(fc->uig->update_map,
-                                                 &hc,
-                                                 &find_trees,
-                                                 fc);
-    }
+  {
+    nsn->nug = fc->nug;
+    nsn->tree_id = UINT_MAX;   /* mark as undef */
+    /* trace */
+    GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
+    GNUNET_CONTAINER_multihashmap_get_multiple (fc->uig->update_map,
+                                                &hc,
+                                                &find_trees,
+                                                fc);
+  }
   return GNUNET_YES;
 }
 
@@ -664,7 +669,7 @@ find_trees(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @param ip_cls closure for ip
  */
 void
-GNUNET_FS_namespace_list_updateable(
+GNUNET_FS_namespace_list_updateable (
   struct GNUNET_FS_Handle *h,
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
   const char *next_id,
@@ -679,125 +684,125 @@ GNUNET_FS_namespace_list_updateable(
   struct FindTreeClosure fc;
   struct GNUNET_FS_UpdateInformationGraph *uig;
 
-  uig = read_update_information_graph(h, ns);
+  uig = read_update_information_graph (h, ns);
   if (NULL == uig->update_nodes)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "No updateable nodes found for ID `%s'\n",
-                 next_id);
-      free_update_information_graph(uig);
-      return; /* no nodes */
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No updateable nodes found for ID `%s'\n",
+                next_id);
+    free_update_information_graph (uig);
+    return;   /* no nodes */
+  }
   uig->update_map =
-    GNUNET_CONTAINER_multihashmap_create(2 + 3 * uig->update_node_count / 4,
-                                         GNUNET_NO);
+    GNUNET_CONTAINER_multihashmap_create (2 + 3 * uig->update_node_count / 4,
+                                          GNUNET_NO);
   for (i = 0; i < uig->update_node_count; i++)
-    {
-      nsn = uig->update_nodes[i];
-      GNUNET_CRYPTO_hash(nsn->id, strlen(nsn->id), &hc);
-      GNUNET_CONTAINER_multihashmap_put(
-        uig->update_map,
-        &hc,
-        nsn,
-        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-    }
+  {
+    nsn = uig->update_nodes[i];
+    GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
+    GNUNET_CONTAINER_multihashmap_put (
+      uig->update_map,
+      &hc,
+      nsn,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  }
   if (NULL != next_id)
-    {
-      GNUNET_CRYPTO_hash(next_id, strlen(next_id), &hc);
-      pc.ip = ip;
-      pc.ip_cls = ip_cls;
-      GNUNET_CONTAINER_multihashmap_get_multiple(uig->update_map,
-                                                 &hc,
-                                                 &process_update_node,
-                                                 &pc);
-      free_update_information_graph(uig);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Calculating TREEs to find roots of update trees\n");
+  {
+    GNUNET_CRYPTO_hash (next_id, strlen (next_id), &hc);
+    pc.ip = ip;
+    pc.ip_cls = ip_cls;
+    GNUNET_CONTAINER_multihashmap_get_multiple (uig->update_map,
+                                                &hc,
+                                                &process_update_node,
+                                                &pc);
+    free_update_information_graph (uig);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Calculating TREEs to find roots of update trees\n");
   /* Find heads of TREEs in update graph */
   nug = ++uig->nug_gen;
   fc.tree_array = NULL;
   fc.tree_array_size = 0;
 
   for (i = 0; i < uig->update_node_count; i++)
+  {
+    nsn = uig->update_nodes[i];
+    if (nsn->nug == nug)
     {
-      nsn = uig->update_nodes[i];
-      if (nsn->nug == nug)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "TREE of node `%s' is %u\n",
-                     nsn->id,
-                     nsn->nug);
-          continue; /* already placed in TREE */
-        }
-      GNUNET_CRYPTO_hash(nsn->update, strlen(nsn->update), &hc);
-      nsn->nug = nug;
-      nsn->tree_id = UINT_MAX;
-      fc.id = UINT_MAX;
-      fc.nug = nug;
-      fc.uig = uig;
-      GNUNET_CONTAINER_multihashmap_get_multiple(uig->update_map,
-                                                 &hc,
-                                                 &find_trees,
-                                                 &fc);
-      if (UINT_MAX == fc.id)
-        {
-          /* start new TREE */
-          for (fc.id = 0; fc.id < fc.tree_array_size; fc.id++)
-            {
-              if (NULL == fc.tree_array[fc.id])
-                {
-                  fc.tree_array[fc.id] = nsn;
-                  nsn->tree_id = fc.id;
-                  break;
-                }
-            }
-          if (fc.id == fc.tree_array_size)
-            {
-              GNUNET_array_append(fc.tree_array, fc.tree_array_size, nsn);
-              nsn->tree_id = fc.id;
-            }
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Starting new TREE %u with node `%s'\n",
-                     nsn->tree_id,
-                     nsn->id);
-          /* put all nodes with same identifier into this TREE */
-          GNUNET_CRYPTO_hash(nsn->id, strlen(nsn->id), &hc);
-          fc.id = nsn->tree_id;
-          fc.nug = nug;
-          fc.uig = uig;
-          GNUNET_CONTAINER_multihashmap_get_multiple(uig->update_map,
-                                                     &hc,
-                                                     &find_trees,
-                                                     &fc);
-        }
-      else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "TREE of node `%s' is %u\n",
+                  nsn->id,
+                  nsn->nug);
+      continue;     /* already placed in TREE */
+    }
+    GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
+    nsn->nug = nug;
+    nsn->tree_id = UINT_MAX;
+    fc.id = UINT_MAX;
+    fc.nug = nug;
+    fc.uig = uig;
+    GNUNET_CONTAINER_multihashmap_get_multiple (uig->update_map,
+                                                &hc,
+                                                &find_trees,
+                                                &fc);
+    if (UINT_MAX == fc.id)
+    {
+      /* start new TREE */
+      for (fc.id = 0; fc.id < fc.tree_array_size; fc.id++)
+      {
+        if (NULL == fc.tree_array[fc.id])
         {
-          /* make head of TREE "id" */
           fc.tree_array[fc.id] = nsn;
           nsn->tree_id = fc.id;
+          break;
         }
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "TREE of node `%s' is %u\n",
-                 nsn->id,
-                 fc.id);
+      }
+      if (fc.id == fc.tree_array_size)
+      {
+        GNUNET_array_append (fc.tree_array, fc.tree_array_size, nsn);
+        nsn->tree_id = fc.id;
+      }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Starting new TREE %u with node `%s'\n",
+                  nsn->tree_id,
+                  nsn->id);
+      /* put all nodes with same identifier into this TREE */
+      GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
+      fc.id = nsn->tree_id;
+      fc.nug = nug;
+      fc.uig = uig;
+      GNUNET_CONTAINER_multihashmap_get_multiple (uig->update_map,
+                                                  &hc,
+                                                  &find_trees,
+                                                  &fc);
     }
+    else
+    {
+      /* make head of TREE "id" */
+      fc.tree_array[fc.id] = nsn;
+      nsn->tree_id = fc.id;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "TREE of node `%s' is %u\n",
+                nsn->id,
+                fc.id);
+  }
   for (i = 0; i < fc.tree_array_size; i++)
+  {
+    nsn = fc.tree_array[i];
+    if (NULL != nsn)
     {
-      nsn = fc.tree_array[i];
-      if (NULL != nsn)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Root of TREE %u is node `%s'\n",
-                     i,
-                     nsn->id);
-          ip(ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Root of TREE %u is node `%s'\n",
+                  i,
+                  nsn->id);
+      ip (ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
     }
-  GNUNET_array_grow(fc.tree_array, fc.tree_array_size, 0);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Done processing TREEs\n");
-  free_update_information_graph(uig);
+  }
+  GNUNET_array_grow (fc.tree_array, fc.tree_array_size, 0);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done processing TREEs\n");
+  free_update_information_graph (uig);
 }
 
 
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index b599bb06e..8bb57b1e2 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -44,10 +44,10 @@
  * @return value returned from callback
  */
 void *
-GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                               struct GNUNET_FS_PublishContext *pc,
-                               const struct GNUNET_FS_FileInformation *p,
-                               uint64_t offset)
+GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                struct GNUNET_FS_PublishContext *pc,
+                                const struct GNUNET_FS_FileInformation *p,
+                                uint64_t offset)
 {
   pi->value.publish.pc = pc;
   pi->value.publish.fi = p;
@@ -55,16 +55,17 @@ GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi,
   pi->value.publish.pctx = (NULL == p->dir) ? NULL : p->dir->client_info;
   pi->value.publish.filename = p->filename;
   pi->value.publish.size =
-    (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size;
+    (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size :
+    p->data.file.file_size;
   pi->value.publish.eta =
-    GNUNET_TIME_calculate_eta(p->start_time, offset,
-                              pi->value.publish.size);
+    GNUNET_TIME_calculate_eta (p->start_time, offset,
+                               pi->value.publish.size);
   pi->value.publish.completed = offset;
   pi->value.publish.duration =
-    GNUNET_TIME_absolute_get_duration(p->start_time);
+    GNUNET_TIME_absolute_get_duration (p->start_time);
   pi->value.publish.anonymity = p->bo.anonymity_level;
   pi->fsh = pc->h;
-  return pc->h->upcb(pc->h->upcb_cls, pi);
+  return pc->h->upcb (pc->h->upcb_cls, pi);
 }
 
 
@@ -74,31 +75,31 @@ GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi,
  * @param pc struct to clean up
  */
 static void
-publish_cleanup(struct GNUNET_FS_PublishContext *pc)
+publish_cleanup (struct GNUNET_FS_PublishContext *pc)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Cleaning up publish context (done!)\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cleaning up publish context (done!)\n");
   if (NULL != pc->fhc)
-    {
-      GNUNET_CRYPTO_hash_file_cancel(pc->fhc);
-      pc->fhc = NULL;
-    }
-  GNUNET_FS_file_information_destroy(pc->fi, NULL, NULL);
-  GNUNET_free_non_null(pc->nid);
-  GNUNET_free_non_null(pc->nuid);
-  GNUNET_free_non_null(pc->serialization);
+  {
+    GNUNET_CRYPTO_hash_file_cancel (pc->fhc);
+    pc->fhc = NULL;
+  }
+  GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
+  GNUNET_free_non_null (pc->nid);
+  GNUNET_free_non_null (pc->nuid);
+  GNUNET_free_non_null (pc->serialization);
   if (NULL != pc->dsh)
-    {
-      GNUNET_DATASTORE_disconnect(pc->dsh, GNUNET_NO);
-      pc->dsh = NULL;
-    }
+  {
+    GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO);
+    pc->dsh = NULL;
+  }
   if (NULL != pc->mq)
-    {
-      GNUNET_MQ_destroy(pc->mq);
-      pc->mq = NULL;
-    }
-  GNUNET_assert(NULL == pc->upload_task);
-  GNUNET_free(pc);
+  {
+    GNUNET_MQ_destroy (pc->mq);
+    pc->mq = NULL;
+  }
+  GNUNET_assert (NULL == pc->upload_task);
+  GNUNET_free (pc);
 }
 
 
@@ -112,42 +113,42 @@ publish_cleanup(struct GNUNET_FS_PublishContext *pc)
  * @param msg error message (or NULL)
  */
 static void
-ds_put_cont(void *cls,
-            int success,
-            struct GNUNET_TIME_Absolute min_expiration,
-            const char *msg)
+ds_put_cont (void *cls,
+             int success,
+             struct GNUNET_TIME_Absolute min_expiration,
+             const char *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
   pc->qre = NULL;
   if (GNUNET_SYSERR == success)
+  {
+    GNUNET_asprintf (&pc->fi_pos->emsg,
+                     _ ("Publishing failed: %s"),
+                     msg);
+    pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
+    pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
+    pi.value.publish.specifics.error.message = pc->fi_pos->emsg;
+    pc->fi_pos->client_info =
+      GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi_pos, 0);
+    if ((GNUNET_YES != pc->fi_pos->is_directory) &&
+        (NULL != pc->fi_pos->filename) &&
+        (GNUNET_YES == pc->any_done) &&
+        (GNUNET_YES == pc->fi_pos->data.file.do_index))
     {
-      GNUNET_asprintf(&pc->fi_pos->emsg,
-                      _("Publishing failed: %s"),
-                      msg);
-      pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
-      pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
-      pi.value.publish.specifics.error.message = pc->fi_pos->emsg;
-      pc->fi_pos->client_info =
-        GNUNET_FS_publish_make_status_(&pi, pc, pc->fi_pos, 0);
-      if ((GNUNET_YES != pc->fi_pos->is_directory) &&
-          (NULL != pc->fi_pos->filename) &&
-          (GNUNET_YES == pc->any_done) &&
-          (GNUNET_YES == pc->fi_pos->data.file.do_index))
-        {
-          /* run unindex to clean up */
-          GNUNET_FS_unindex_start(pc->h,
-                                  pc->fi_pos->filename,
-                                  NULL);
-        }
-      return;
+      /* run unindex to clean up */
+      GNUNET_FS_unindex_start (pc->h,
+                               pc->fi_pos->filename,
+                               NULL);
     }
+    return;
+  }
   pc->any_done = GNUNET_YES;
-  GNUNET_assert(NULL == pc->upload_task);
+  GNUNET_assert (NULL == pc->upload_task);
   pc->upload_task =
-    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                       &GNUNET_FS_publish_main_, pc);
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                        &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -160,8 +161,8 @@ ds_put_cont(void *cls,
  * @param pc context of the publication
  */
 static void
-signal_publish_completion(struct GNUNET_FS_FileInformation *p,
-                          struct GNUNET_FS_PublishContext *pc)
+signal_publish_completion (struct GNUNET_FS_FileInformation *p,
+                           struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
@@ -170,8 +171,8 @@ signal_publish_completion(struct GNUNET_FS_FileInformation *p,
   pi.value.publish.specifics.completed.chk_uri = p->chk_uri;
   pi.value.publish.specifics.completed.sks_uri = p->sks_uri;
   p->client_info =
-    GNUNET_FS_publish_make_status_(&pi, pc, p,
-                                   p->data.file.file_size);
+    GNUNET_FS_publish_make_status_ (&pi, pc, p,
+                                    p->data.file.file_size);
 }
 
 
@@ -185,27 +186,27 @@ signal_publish_completion(struct GNUNET_FS_FileInformation *p,
  * @param emsg error message
  */
 static void
-signal_publish_error(struct GNUNET_FS_FileInformation *p,
-                     struct GNUNET_FS_PublishContext *pc,
-                     const char *emsg)
+signal_publish_error (struct GNUNET_FS_FileInformation *p,
+                      struct GNUNET_FS_PublishContext *pc,
+                      const char *emsg)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
-  p->emsg = GNUNET_strdup(emsg);
+  p->emsg = GNUNET_strdup (emsg);
   pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
   pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
   pi.value.publish.specifics.error.message = emsg;
-  p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0);
+  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
   if ((p->is_directory != GNUNET_YES) &&
       (NULL != p->filename) &&
       (GNUNET_YES == pc->any_done) &&
       (p->data.file.do_index == GNUNET_YES))
-    {
-      /* run unindex to clean up */
-      GNUNET_FS_unindex_start(pc->h,
-                              p->filename,
-                              NULL);
-    }
+  {
+    /* run unindex to clean up */
+    GNUNET_FS_unindex_start (pc->h,
+                             p->filename,
+                             NULL);
+  }
 }
 
 
@@ -218,18 +219,18 @@ signal_publish_error(struct GNUNET_FS_FileInformation *p,
  * @param msg error message (typically NULL, not used)
  */
 static void
-finish_release_reserve(void *cls, int success,
-                       struct GNUNET_TIME_Absolute min_expiration,
-                       const char *msg)
+finish_release_reserve (void *cls, int success,
+                        struct GNUNET_TIME_Absolute min_expiration,
+                        const char *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   pc->qre = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Releasing reserve done!\n");
-  signal_publish_completion(pc->fi, pc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Releasing reserve done!\n");
+  signal_publish_completion (pc->fi, pc);
   pc->all_done = GNUNET_YES;
-  GNUNET_FS_publish_sync_(pc);
+  GNUNET_FS_publish_sync_ (pc);
 }
 
 
@@ -242,35 +243,35 @@ finish_release_reserve(void *cls, int success,
  * @param emsg NULL on success, otherwise error message
  */
 static void
-publish_sblocks_cont(void *cls,
-                     const struct GNUNET_FS_Uri *uri,
-                     const char *emsg)
+publish_sblocks_cont (void *cls,
+                      const struct GNUNET_FS_Uri *uri,
+                      const char *emsg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   pc->sks_pc = NULL;
   if (NULL != emsg)
-    {
-      signal_publish_error(pc->fi, pc, emsg);
-      GNUNET_FS_publish_sync_(pc);
-      return;
-    }
+  {
+    signal_publish_error (pc->fi, pc, emsg);
+    GNUNET_FS_publish_sync_ (pc);
+    return;
+  }
   if (NULL != uri)
-    {
-      /* sks publication, remember namespace URI */
-      pc->fi->sks_uri = GNUNET_FS_uri_dup(uri);
-    }
-  GNUNET_assert(pc->qre == NULL);
+  {
+    /* sks publication, remember namespace URI */
+    pc->fi->sks_uri = GNUNET_FS_uri_dup (uri);
+  }
+  GNUNET_assert (pc->qre == NULL);
   if ((pc->dsh != NULL) && (pc->rid != 0))
-    {
-      pc->qre =
-        GNUNET_DATASTORE_release_reserve(pc->dsh, pc->rid, UINT_MAX, UINT_MAX,
-                                         &finish_release_reserve, pc);
-    }
+  {
+    pc->qre =
+      GNUNET_DATASTORE_release_reserve (pc->dsh, pc->rid, UINT_MAX, UINT_MAX,
+                                        &finish_release_reserve, pc);
+  }
   else
-    {
-      finish_release_reserve(pc, GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, NULL);
-    }
+  {
+    finish_release_reserve (pc, GNUNET_OK, GNUNET_TIME_UNIT_ZERO_ABS, NULL);
+  }
 }
 
 
@@ -281,20 +282,20 @@ publish_sblocks_cont(void *cls,
  * @param pc overall upload data
  */
 static void
-publish_sblock(struct GNUNET_FS_PublishContext *pc)
+publish_sblock (struct GNUNET_FS_PublishContext *pc)
 {
   if (NULL != pc->ns)
-    pc->sks_pc = GNUNET_FS_publish_sks(pc->h,
-                                       pc->ns,
-                                       pc->nid,
-                                       pc->nuid,
-                                       pc->fi->meta,
-                                       pc->fi->chk_uri,
-                                       &pc->fi->bo,
-                                       pc->options,
-                                       &publish_sblocks_cont, pc);
+    pc->sks_pc = GNUNET_FS_publish_sks (pc->h,
+                                        pc->ns,
+                                        pc->nid,
+                                        pc->nuid,
+                                        pc->fi->meta,
+                                        pc->fi->chk_uri,
+                                        &pc->fi->bo,
+                                        pc->options,
+                                        &publish_sblocks_cont, pc);
   else
-    publish_sblocks_cont(pc, NULL, NULL);
+    publish_sblocks_cont (pc, NULL, NULL);
 }
 
 
@@ -308,44 +309,44 @@ publish_sblock(struct GNUNET_FS_PublishContext *pc)
  * @param emsg NULL on success, otherwise error message
  */
 static void
-publish_kblocks_cont(void *cls,
-                     const struct GNUNET_FS_Uri *uri,
-                     const char *emsg)
+publish_kblocks_cont (void *cls,
+                      const struct GNUNET_FS_Uri *uri,
+                      const char *emsg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p = pc->fi_pos;
 
   pc->ksk_pc = NULL;
   if (NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Error uploading KSK blocks: %s\n",
-                 emsg);
-      signal_publish_error(p, pc, emsg);
-      GNUNET_FS_file_information_sync_(p);
-      GNUNET_FS_publish_sync_(pc);
-      GNUNET_assert(NULL == pc->upload_task);
-      pc->upload_task =
-        GNUNET_SCHEDULER_add_with_priority
-          (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-          &GNUNET_FS_publish_main_,
-          pc);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "KSK blocks published, moving on to next file\n");
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Error uploading KSK blocks: %s\n",
+                emsg);
+    signal_publish_error (p, pc, emsg);
+    GNUNET_FS_file_information_sync_ (p);
+    GNUNET_FS_publish_sync_ (pc);
+    GNUNET_assert (NULL == pc->upload_task);
+    pc->upload_task =
+      GNUNET_SCHEDULER_add_with_priority
+        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+        &GNUNET_FS_publish_main_,
+        pc);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "KSK blocks published, moving on to next file\n");
   if (NULL != p->dir)
-    signal_publish_completion(p, pc);
+    signal_publish_completion (p, pc);
   /* move on to next file */
   if (NULL != p->next)
     pc->fi_pos = p->next;
   else
     pc->fi_pos = p->dir;
-  GNUNET_FS_publish_sync_(pc);
-  GNUNET_assert(NULL == pc->upload_task);
+  GNUNET_FS_publish_sync_ (pc);
+  GNUNET_assert (NULL == pc->upload_task);
   pc->upload_task =
-    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                       &GNUNET_FS_publish_main_, pc);
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                        &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -363,11 +364,11 @@ publish_kblocks_cont(void *cls,
  * @return number of bytes copied to buf, 0 on error
  */
 static size_t
-block_reader(void *cls,
-             uint64_t offset,
-             size_t max,
-             void *buf,
-             char **emsg)
+block_reader (void *cls,
+              uint64_t offset,
+              size_t max,
+              void *buf,
+              char **emsg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -376,31 +377,31 @@ block_reader(void *cls,
 
   p = pc->fi_pos;
   if (GNUNET_YES == p->is_directory)
-    {
-      pt_size = GNUNET_MIN(max, p->data.dir.dir_size - offset);
-      dd = p->data.dir.dir_data;
-      GNUNET_memcpy(buf, &dd[offset], pt_size);
-    }
+  {
+    pt_size = GNUNET_MIN (max, p->data.dir.dir_size - offset);
+    dd = p->data.dir.dir_data;
+    GNUNET_memcpy (buf, &dd[offset], pt_size);
+  }
   else
-    {
-      if (UINT64_MAX == offset)
-        {
-          if (&GNUNET_FS_data_reader_file_ == p->data.file.reader)
-            {
-              /* force closing the file to avoid keeping too many files open */
-              p->data.file.reader(p->data.file.reader_cls, offset, 0, NULL, NULL);
-            }
-          return 0;
-        }
-      pt_size = GNUNET_MIN(max, p->data.file.file_size - offset);
-      if (0 == pt_size)
-        return 0;               /* calling reader with pt_size==0
+  {
+    if (UINT64_MAX == offset)
+    {
+      if (&GNUNET_FS_data_reader_file_ == p->data.file.reader)
+      {
+        /* force closing the file to avoid keeping too many files open */
+        p->data.file.reader (p->data.file.reader_cls, offset, 0, NULL, NULL);
+      }
+      return 0;
+    }
+    pt_size = GNUNET_MIN (max, p->data.file.file_size - offset);
+    if (0 == pt_size)
+      return 0;                 /* calling reader with pt_size==0
                                  * might free buf, so don't! */
-      if (pt_size !=
-          p->data.file.reader(p->data.file.reader_cls, offset, pt_size, buf,
-                              emsg))
-        return 0;
-    }
+    if (pt_size !=
+        p->data.file.reader (p->data.file.reader_cls, offset, pt_size, buf,
+                             emsg))
+      return 0;
+  }
   return pt_size;
 }
 
@@ -413,7 +414,7 @@ block_reader(void *cls,
  * @param cls our publishing context
  */
 static void
-encode_cont(void *cls)
+encode_cont (void *cls)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -421,44 +422,44 @@ encode_cont(void *cls)
   char *emsg;
   uint64_t flen;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Finished with tree encoder\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finished with tree encoder\n");
   p = pc->fi_pos;
-  p->chk_uri = GNUNET_FS_tree_encoder_get_uri(p->te);
-  GNUNET_FS_file_information_sync_(p);
-  GNUNET_FS_tree_encoder_finish(p->te, &emsg);
+  p->chk_uri = GNUNET_FS_tree_encoder_get_uri (p->te);
+  GNUNET_FS_file_information_sync_ (p);
+  GNUNET_FS_tree_encoder_finish (p->te, &emsg);
   p->te = NULL;
   if (NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Error during tree walk: %s\n",
-                 emsg);
-      GNUNET_asprintf(&p->emsg,
-                      _("Publishing failed: %s"),
-                      emsg);
-      GNUNET_free(emsg);
-      pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
-      pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
-      pi.value.publish.specifics.error.message = p->emsg;
-      p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Error during tree walk: %s\n",
+                emsg);
+    GNUNET_asprintf (&p->emsg,
+                     _ ("Publishing failed: %s"),
+                     emsg);
+    GNUNET_free (emsg);
+    pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
+    pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
+    pi.value.publish.specifics.error.message = p->emsg;
+    p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
+  }
   else
-    {
-      /* final progress event */
-      GNUNET_assert(NULL != p->chk_uri);
-      flen = GNUNET_FS_uri_chk_get_file_size(p->chk_uri);
-      pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS;
-      pi.value.publish.specifics.progress.data = NULL;
-      pi.value.publish.specifics.progress.offset = flen;
-      pi.value.publish.specifics.progress.data_len = 0;
-      pi.value.publish.specifics.progress.depth = GNUNET_FS_compute_depth(flen);
-      p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, flen);
-    }
+  {
+    /* final progress event */
+    GNUNET_assert (NULL != p->chk_uri);
+    flen = GNUNET_FS_uri_chk_get_file_size (p->chk_uri);
+    pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS;
+    pi.value.publish.specifics.progress.data = NULL;
+    pi.value.publish.specifics.progress.offset = flen;
+    pi.value.publish.specifics.progress.data_len = 0;
+    pi.value.publish.specifics.progress.depth = GNUNET_FS_compute_depth (flen);
+    p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, flen);
+  }
   /* continue with main */  /* continue with main */
-  GNUNET_assert(NULL == pc->upload_task);
+  GNUNET_assert (NULL == pc->upload_task);
   pc->upload_task =
-    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                       &GNUNET_FS_publish_main_, pc);
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                        &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -477,13 +478,13 @@ encode_cont(void *cls)
  * @param block_size size of @a block (in bytes)
  */
 static void
-block_proc(void *cls,
-           const struct ContentHashKey *chk,
-           uint64_t offset,
-           unsigned int depth,
-           enum GNUNET_BLOCK_Type type,
-           const void *block,
-           uint16_t block_size)
+block_proc (void *cls,
+            const struct ContentHashKey *chk,
+            uint64_t offset,
+            unsigned int depth,
+            enum GNUNET_BLOCK_Type type,
+            const void *block,
+            uint16_t block_size)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -491,62 +492,63 @@ block_proc(void *cls,
 
   p = pc->fi_pos;
   if (NULL == pc->dsh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Waiting for datastore connection\n");
-      GNUNET_assert(NULL == pc->upload_task);
-      pc->upload_task =
-        GNUNET_SCHEDULER_add_with_priority
-          (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Waiting for datastore connection\n");
+    GNUNET_assert (NULL == pc->upload_task);
+    pc->upload_task =
+      GNUNET_SCHEDULER_add_with_priority
+        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc);
+    return;
+  }
 
   if ((GNUNET_YES != p->is_directory) &&
       (GNUNET_YES == p->data.file.do_index) &&
       (GNUNET_BLOCK_TYPE_FS_DBLOCK == type))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Indexing block `%s' for offset %llu with index size %u\n",
-                 GNUNET_h2s(&chk->query),
-                 (unsigned long long)offset,
-                 (unsigned int)sizeof(struct OnDemandBlock));
-      odb.offset = GNUNET_htonll(offset);
-      odb.file_id = p->data.file.file_id;
-      GNUNET_assert(pc->qre == NULL);
-      pc->qre =
-        GNUNET_DATASTORE_put(pc->dsh,
-                             (p->is_directory == GNUNET_YES) ? 0 : pc->rid,
-                             &chk->query,
-                             sizeof(struct OnDemandBlock),
-                             &odb,
-                             GNUNET_BLOCK_TYPE_FS_ONDEMAND,
-                             p->bo.content_priority,
-                             p->bo.anonymity_level,
-                             p->bo.replication_level,
-                             p->bo.expiration_time,
-                             -2, 1,
-                             &ds_put_cont, pc);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Publishing block `%s' for offset %llu with size %u\n",
-             GNUNET_h2s(&chk->query),
-             (unsigned long long)offset,
-             (unsigned int)block_size);
-  GNUNET_assert(pc->qre == NULL);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Indexing block `%s' for offset %llu with index size %u\n",
+                GNUNET_h2s (&chk->query),
+                (unsigned long long) offset,
+                (unsigned int) sizeof(struct OnDemandBlock));
+    odb.offset = GNUNET_htonll (offset);
+    odb.file_id = p->data.file.file_id;
+    GNUNET_assert (pc->qre == NULL);
+    pc->qre =
+      GNUNET_DATASTORE_put (pc->dsh,
+                            (p->is_directory == GNUNET_YES) ? 0 : pc->rid,
+                            &chk->query,
+                            sizeof(struct OnDemandBlock),
+                            &odb,
+                            GNUNET_BLOCK_TYPE_FS_ONDEMAND,
+                            p->bo.content_priority,
+                            p->bo.anonymity_level,
+                            p->bo.replication_level,
+                            p->bo.expiration_time,
+                            -2, 1,
+                            &ds_put_cont, pc);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Publishing block `%s' for offset %llu with size %u\n",
+              GNUNET_h2s (&chk->query),
+              (unsigned long long) offset,
+              (unsigned int) block_size);
+  GNUNET_assert (pc->qre == NULL);
   pc->qre =
-    GNUNET_DATASTORE_put(pc->dsh, (p->is_directory == GNUNET_YES) ? 0 : pc->rid,
-                         &chk->query,
-                         block_size,
-                         block,
-                         type,
-                         p->bo.content_priority,
-                         p->bo.anonymity_level,
-                         p->bo.replication_level,
-                         p->bo.expiration_time,
-                         -2, 1,
-                         &ds_put_cont,
-                         pc);
+    GNUNET_DATASTORE_put (pc->dsh, (p->is_directory == GNUNET_YES) ? 0 :
+                          pc->rid,
+                          &chk->query,
+                          block_size,
+                          block,
+                          type,
+                          p->bo.content_priority,
+                          p->bo.anonymity_level,
+                          p->bo.replication_level,
+                          p->bo.expiration_time,
+                          -2, 1,
+                          &ds_put_cont,
+                          pc);
 }
 
 
@@ -561,10 +563,10 @@ block_proc(void *cls,
  * @param depth depth of the block in the tree, 0 for DBLOCK
  */
 static void
-progress_proc(void *cls, uint64_t offset,
-              const void *pt_block,
-              size_t pt_size,
-              unsigned int depth)
+progress_proc (void *cls, uint64_t offset,
+               const void *pt_block,
+               size_t pt_size,
+               unsigned int depth)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -577,23 +579,28 @@ progress_proc(void *cls, uint64_t offset,
   pi.value.publish.specifics.progress.offset = offset;
   pi.value.publish.specifics.progress.data_len = pt_size;
   pi.value.publish.specifics.progress.depth = depth;
-  p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, offset);
+  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, offset);
   if ((0 != depth) ||
       (GNUNET_YES == p->is_directory))
     return;
   while (NULL != (par = p->dir))
-    {
-      p = par;
-      GNUNET_assert(GNUNET_YES == par->is_directory);
-      p->data.dir.contents_completed += pt_size;
-      pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY;
-      pi.value.publish.specifics.progress_directory.completed = p->data.dir.contents_completed;
-      pi.value.publish.specifics.progress_directory.total = p->data.dir.contents_size;
-      pi.value.publish.specifics.progress_directory.eta = GNUNET_TIME_calculate_eta(p->start_time,
-                                                                                    p->data.dir.contents_completed,
-                                                                                    p->data.dir.contents_size);
-      p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0);
-    }
+  {
+    p = par;
+    GNUNET_assert (GNUNET_YES == par->is_directory);
+    p->data.dir.contents_completed += pt_size;
+    pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY;
+    pi.value.publish.specifics.progress_directory.completed =
+      p->data.dir.contents_completed;
+    pi.value.publish.specifics.progress_directory.total =
+      p->data.dir.contents_size;
+    pi.value.publish.specifics.progress_directory.eta =
+      GNUNET_TIME_calculate_eta (p->start_time,
+                                 p
+                                 ->data.dir.contents_completed,
+                                 p
+                                 ->data.dir.contents_size);
+    p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
+  }
 }
 
 
@@ -605,7 +612,7 @@ progress_proc(void *cls, uint64_t offset,
  * @param pc overall upload data
  */
 static void
-publish_content(struct GNUNET_FS_PublishContext *pc)
+publish_content (struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_FS_FileInformation *p;
   char *emsg;
@@ -615,64 +622,66 @@ publish_content(struct GNUNET_FS_PublishContext *pc)
   uint64_t size;
 
   p = pc->fi_pos;
-  GNUNET_assert(NULL != p);
+  GNUNET_assert (NULL != p);
   if (NULL == p->te)
-    {
-      if (GNUNET_YES == p->is_directory)
+  {
+    if (GNUNET_YES == p->is_directory)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating directory\n");
+      db = GNUNET_FS_directory_builder_create (p->meta);
+      dirpos = p->data.dir.entries;
+      while (NULL != dirpos)
+      {
+        if (GNUNET_YES == dirpos->is_directory)
+        {
+          raw_data = dirpos->data.dir.dir_data;
+          dirpos->data.dir.dir_data = NULL;
+        }
+        else
         {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Creating directory\n");
-          db = GNUNET_FS_directory_builder_create(p->meta);
-          dirpos = p->data.dir.entries;
-          while (NULL != dirpos)
+          raw_data = NULL;
+          if ((dirpos->data.file.file_size < MAX_INLINE_SIZE) &&
+              (dirpos->data.file.file_size > 0))
+          {
+            raw_data = GNUNET_malloc (dirpos->data.file.file_size);
+            emsg = NULL;
+            if (dirpos->data.file.file_size !=
+                dirpos->data.file.reader (dirpos->data.file.reader_cls, 0,
+                                          dirpos->data.file.file_size, raw_data,
+                                          &emsg))
             {
-              if (GNUNET_YES == dirpos->is_directory)
-                {
-                  raw_data = dirpos->data.dir.dir_data;
-                  dirpos->data.dir.dir_data = NULL;
-                }
-              else
-                {
-                  raw_data = NULL;
-                  if ((dirpos->data.file.file_size < MAX_INLINE_SIZE) &&
-                      (dirpos->data.file.file_size > 0))
-                    {
-                      raw_data = GNUNET_malloc(dirpos->data.file.file_size);
-                      emsg = NULL;
-                      if (dirpos->data.file.file_size !=
-                          dirpos->data.file.reader(dirpos->data.file.reader_cls, 0,
-                                                   dirpos->data.file.file_size, raw_data,
-                                                   &emsg))
-                        {
-                          GNUNET_free_non_null(emsg);
-                          GNUNET_free(raw_data);
-                          raw_data = NULL;
-                        }
-                      dirpos->data.file.reader(dirpos->data.file.reader_cls, UINT64_MAX, 0, 0, NULL);
-                    }
-                }
-              GNUNET_FS_directory_builder_add(db, dirpos->chk_uri, dirpos->meta,
-                                              raw_data);
-              GNUNET_free_non_null(raw_data);
-              dirpos = dirpos->next;
+              GNUNET_free_non_null (emsg);
+              GNUNET_free (raw_data);
+              raw_data = NULL;
             }
-          GNUNET_free_non_null(p->data.dir.dir_data);
-          p->data.dir.dir_data = NULL;
-          p->data.dir.dir_size = 0;
-          GNUNET_FS_directory_builder_finish(db, &p->data.dir.dir_size,
-                                             &p->data.dir.dir_data);
-          GNUNET_FS_file_information_sync_(p);
+            dirpos->data.file.reader (dirpos->data.file.reader_cls, UINT64_MAX,
+                                      0, 0, NULL);
+          }
         }
-      size = (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Creating tree encoder\n");
-      p->te =
-        GNUNET_FS_tree_encoder_create(pc->h, size, pc, &block_reader,
-                                      &block_proc, &progress_proc,
-                                      &encode_cont);
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Processing next block from tree\n");
-  GNUNET_FS_tree_encoder_next(p->te);
+        GNUNET_FS_directory_builder_add (db, dirpos->chk_uri, dirpos->meta,
+                                         raw_data);
+        GNUNET_free_non_null (raw_data);
+        dirpos = dirpos->next;
+      }
+      GNUNET_free_non_null (p->data.dir.dir_data);
+      p->data.dir.dir_data = NULL;
+      p->data.dir.dir_size = 0;
+      GNUNET_FS_directory_builder_finish (db, &p->data.dir.dir_size,
+                                          &p->data.dir.dir_data);
+      GNUNET_FS_file_information_sync_ (p);
+    }
+    size = (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size :
+           p->data.file.file_size;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Creating tree encoder\n");
+    p->te =
+      GNUNET_FS_tree_encoder_create (pc->h, size, pc, &block_reader,
+                                     &block_proc, &progress_proc,
+                                     &encode_cont);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Processing next block from tree\n");
+  GNUNET_FS_tree_encoder_next (p->te);
 }
 
 
@@ -684,17 +693,17 @@ publish_content(struct GNUNET_FS_PublishContext *pc)
  * @param msg the response we got
  */
 static int
-check_index_start_failed(void *cls,
-                         const struct GNUNET_MessageHeader *msg)
+check_index_start_failed (void *cls,
+                          const struct GNUNET_MessageHeader *msg)
 {
-  size_t msize = ntohs(msg->size) - sizeof(*msg);
-  const char *emsg = (const char *)&msg[1];
+  size_t msize = ntohs (msg->size) - sizeof(*msg);
+  const char *emsg = (const char *) &msg[1];
 
   if (emsg[msize - sizeof(struct GNUNET_MessageHeader) - 1] != '\0')
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -707,27 +716,27 @@ check_index_start_failed(void *cls,
  * @param msg the response we got
  */
 static void
-handle_index_start_failed(void *cls,
-                          const struct GNUNET_MessageHeader *msg)
+handle_index_start_failed (void *cls,
+                           const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
-  const char *emsg = (const char *)&msg[1];
+  const char *emsg = (const char *) &msg[1];
   char *msgtxt;
 
-  GNUNET_MQ_destroy(pc->mq);
+  GNUNET_MQ_destroy (pc->mq);
   pc->mq = NULL;
   p = pc->fi_pos;
-  GNUNET_asprintf(&msgtxt,
-                  _("Can not index file `%s': %s.\n"),
-                  p->filename,
-                  gettext(emsg));
-  signal_publish_error(p,
-                       pc,
-                       msgtxt);
-  GNUNET_free(msgtxt);
-  GNUNET_FS_file_information_sync_(p);
-  GNUNET_FS_publish_sync_(pc);
+  GNUNET_asprintf (&msgtxt,
+                   _ ("Can not index file `%s': %s.\n"),
+                   p->filename,
+                   gettext (emsg));
+  signal_publish_error (p,
+                        pc,
+                        msgtxt);
+  GNUNET_free (msgtxt);
+  GNUNET_FS_file_information_sync_ (p);
+  GNUNET_FS_publish_sync_ (pc);
 }
 
 
@@ -739,18 +748,18 @@ handle_index_start_failed(void *cls,
  * @param msg the response we got
  */
 static void
-handle_index_start_ok(void *cls,
-                      const struct GNUNET_MessageHeader *msg)
+handle_index_start_ok (void *cls,
+                       const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
 
-  GNUNET_MQ_destroy(pc->mq);
+  GNUNET_MQ_destroy (pc->mq);
   pc->mq = NULL;
   p = pc->fi_pos;
   p->data.file.index_start_confirmed = GNUNET_YES;
-  GNUNET_FS_file_information_sync_(p);
-  publish_content(pc);
+  GNUNET_FS_file_information_sync_ (p);
+  publish_content (pc);
 }
 
 
@@ -763,25 +772,25 @@ handle_index_start_ok(void *cls,
  * @param error error code
  */
 static void
-index_mq_error_handler(void *cls,
-                       enum GNUNET_MQ_Error error)
+index_mq_error_handler (void *cls,
+                        enum GNUNET_MQ_Error error)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
 
   if (NULL != pc->mq)
-    {
-      GNUNET_MQ_destroy(pc->mq);
-      pc->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (pc->mq);
+    pc->mq = NULL;
+  }
   p = pc->fi_pos;
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             _("Can not index file `%s': %s.  Will try to insert instead.\n"),
-             p->filename,
-             _("error on index-start request to `fs' service"));
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ ("Can not index file `%s': %s.  Will try to insert instead.\n"),
+              p->filename,
+              _ ("error on index-start request to `fs' service"));
   p->data.file.do_index = GNUNET_NO;
-  GNUNET_FS_file_information_sync_(p);
-  publish_content(pc);
+  GNUNET_FS_file_information_sync_ (p);
+  publish_content (pc);
 }
 
 
@@ -793,20 +802,20 @@ index_mq_error_handler(void *cls,
  * @param res resulting hash, NULL on error
  */
 static void
-hash_for_index_cb(void *cls,
-                  const struct GNUNET_HashCode *res)
+hash_for_index_cb (void *cls,
+                   const struct GNUNET_HashCode *res)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_fixed_size(index_start_ok,
-                            GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK,
-                            struct GNUNET_MessageHeader,
-                            pc),
-    GNUNET_MQ_hd_var_size(index_start_failed,
-                          GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED,
-                          struct GNUNET_MessageHeader,
-                          pc),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_fixed_size (index_start_ok,
+                             GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK,
+                             struct GNUNET_MessageHeader,
+                             pc),
+    GNUNET_MQ_hd_var_size (index_start_failed,
+                           GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED,
+                           struct GNUNET_MessageHeader,
+                           pc),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_FS_FileInformation *p;
   struct GNUNET_MQ_Envelope *env;
@@ -819,97 +828,99 @@ hash_for_index_cb(void *cls,
   pc->fhc = NULL;
   p = pc->fi_pos;
   if (NULL == res)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Can not index file `%s': %s.  Will try to insert instead.\n"),
-                 p->filename,
-                 _("failed to compute hash"));
-      p->data.file.do_index = GNUNET_NO;
-      GNUNET_FS_file_information_sync_(p);
-      publish_content(pc);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "Can not index file `%s': %s.  Will try to insert instead.\n"),
+                p->filename,
+                _ ("failed to compute hash"));
+    p->data.file.do_index = GNUNET_NO;
+    GNUNET_FS_file_information_sync_ (p);
+    publish_content (pc);
+    return;
+  }
   if (GNUNET_YES == p->data.file.index_start_confirmed)
-    {
-      publish_content(pc);
-      return;
-    }
-  fn = GNUNET_STRINGS_filename_expand(p->filename);
-  GNUNET_assert(fn != NULL);
-  slen = strlen(fn) + 1;
+  {
+    publish_content (pc);
+    return;
+  }
+  fn = GNUNET_STRINGS_filename_expand (p->filename);
+  GNUNET_assert (fn != NULL);
+  slen = strlen (fn) + 1;
   if (slen >=
       GNUNET_MAX_MESSAGE_SIZE - sizeof(struct IndexStartMessage))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _
-                   ("Can not index file `%s': %s.  Will try to insert instead.\n"),
-                 fn, _("filename too long"));
-      GNUNET_free(fn);
-      p->data.file.do_index = GNUNET_NO;
-      GNUNET_FS_file_information_sync_(p);
-      publish_content(pc);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Hash of indexed file `%s' is `%s'\n",
-             p->filename,
-             GNUNET_h2s(res));
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                  ("Can not index file `%s': %s.  Will try to insert instead.\n"),
+                fn, _ ("filename too long"));
+    GNUNET_free (fn);
+    p->data.file.do_index = GNUNET_NO;
+    GNUNET_FS_file_information_sync_ (p);
+    publish_content (pc);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Hash of indexed file `%s' is `%s'\n",
+              p->filename,
+              GNUNET_h2s (res));
   if (0 != (pc->options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
-    {
-      p->data.file.file_id = *res;
-      p->data.file.have_hash = GNUNET_YES;
-      p->data.file.index_start_confirmed = GNUNET_YES;
-      GNUNET_FS_file_information_sync_(p);
-      publish_content(pc);
-      GNUNET_free(fn);
-      return;
-    }
-  pc->mq = GNUNET_CLIENT_connect(pc->h->cfg,
-                                 "fs",
-                                 handlers,
-                                 &index_mq_error_handler,
-                                 pc);
+  {
+    p->data.file.file_id = *res;
+    p->data.file.have_hash = GNUNET_YES;
+    p->data.file.index_start_confirmed = GNUNET_YES;
+    GNUNET_FS_file_information_sync_ (p);
+    publish_content (pc);
+    GNUNET_free (fn);
+    return;
+  }
+  pc->mq = GNUNET_CLIENT_connect (pc->h->cfg,
+                                  "fs",
+                                  handlers,
+                                  &index_mq_error_handler,
+                                  pc);
   if (NULL == pc->mq)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Can not index file `%s': %s.  Will try to insert instead.\n"),
-                 p->filename,
-                 _("could not connect to `fs' service"));
-      p->data.file.do_index = GNUNET_NO;
-      publish_content(pc);
-      GNUNET_free(fn);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "Can not index file `%s': %s.  Will try to insert instead.\n"),
+                p->filename,
+                _ ("could not connect to `fs' service"));
+    p->data.file.do_index = GNUNET_NO;
+    publish_content (pc);
+    GNUNET_free (fn);
+    return;
+  }
   if (p->data.file.have_hash != GNUNET_YES)
-    {
-      p->data.file.file_id = *res;
-      p->data.file.have_hash = GNUNET_YES;
-      GNUNET_FS_file_information_sync_(p);
-    }
-  env = GNUNET_MQ_msg_extra(ism,
-                            slen,
-                            GNUNET_MESSAGE_TYPE_FS_INDEX_START);
+  {
+    p->data.file.file_id = *res;
+    p->data.file.have_hash = GNUNET_YES;
+    GNUNET_FS_file_information_sync_ (p);
+  }
+  env = GNUNET_MQ_msg_extra (ism,
+                             slen,
+                             GNUNET_MESSAGE_TYPE_FS_INDEX_START);
   if (GNUNET_OK ==
-      GNUNET_DISK_file_get_identifiers(p->filename,
-                                       &dev,
-                                       &ino))
-    {
-      ism->device = GNUNET_htonll(dev);
-      ism->inode = GNUNET_htonll(ino);
-    }
+      GNUNET_DISK_file_get_identifiers (p->filename,
+                                        &dev,
+                                        &ino))
+  {
+    ism->device = GNUNET_htonll (dev);
+    ism->inode = GNUNET_htonll (ino);
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 _("Failed to get file identifiers for `%s'\n"),
-                 p->filename);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                _ ("Failed to get file identifiers for `%s'\n"),
+                p->filename);
+  }
   ism->file_id = *res;
-  GNUNET_memcpy(&ism[1],
-                fn,
-                slen);
-  GNUNET_free(fn);
-  GNUNET_MQ_send(pc->mq,
-                 env);
+  GNUNET_memcpy (&ism[1],
+                 fn,
+                 slen);
+  GNUNET_free (fn);
+  GNUNET_MQ_send (pc->mq,
+                  env);
 }
 
 
@@ -919,27 +930,27 @@ hash_for_index_cb(void *cls,
  * @param pc publishing context to do this for
  */
 static void
-publish_kblocks(struct GNUNET_FS_PublishContext *pc)
+publish_kblocks (struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_FS_FileInformation *p;
 
   p = pc->fi_pos;
   /* upload of "p" complete, publish KBlocks! */
   if (NULL != p->keywords)
-    {
-      pc->ksk_pc = GNUNET_FS_publish_ksk(pc->h,
-                                         p->keywords,
-                                         p->meta,
-                                         p->chk_uri,
-                                         &p->bo,
-                                         pc->options,
-                                         &publish_kblocks_cont,
-                                         pc);
-    }
+  {
+    pc->ksk_pc = GNUNET_FS_publish_ksk (pc->h,
+                                        p->keywords,
+                                        p->meta,
+                                        p->chk_uri,
+                                        &p->bo,
+                                        pc->options,
+                                        &publish_kblocks_cont,
+                                        pc);
+  }
   else
-    {
-      publish_kblocks_cont(pc, p->chk_uri, NULL);
-    }
+  {
+    publish_kblocks_cont (pc, p->chk_uri, NULL);
+  }
 }
 
 
@@ -950,8 +961,8 @@ publish_kblocks(struct GNUNET_FS_PublishContext *pc)
  * @param sig the response we got
  */
 static void
-handle_signature_response(void *cls,
-                          const struct ResponseLocSignatureMessage *sig)
+handle_signature_response (void *cls,
+                           const struct ResponseLocSignatureMessage *sig)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -961,11 +972,11 @@ handle_signature_response(void *cls,
   /* p->data.loc.fi kept from CHK before */
   p->chk_uri->data.loc.peer = sig->peer;
   p->chk_uri->data.loc.expirationTime
-    = GNUNET_TIME_absolute_ntoh(sig->expiration_time);
+    = GNUNET_TIME_absolute_ntoh (sig->expiration_time);
   p->chk_uri->data.loc.contentSignature = sig->signature;
-  GNUNET_FS_file_information_sync_(p);
-  GNUNET_FS_publish_sync_(pc);
-  publish_kblocks(pc);
+  GNUNET_FS_file_information_sync_ (p);
+  GNUNET_FS_publish_sync_ (pc);
+  publish_kblocks (pc);
 }
 
 
@@ -978,19 +989,19 @@ handle_signature_response(void *cls,
  * @param error error code
  */
 static void
-loc_mq_error_handler(void *cls,
-                     enum GNUNET_MQ_Error error)
+loc_mq_error_handler (void *cls,
+                      enum GNUNET_MQ_Error error)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   if (NULL != pc->mq)
-    {
-      GNUNET_MQ_destroy(pc->mq);
-      pc->mq = NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             _("Can not create LOC URI. Will continue with CHK instead.\n"));
-  publish_kblocks(pc);
+  {
+    GNUNET_MQ_destroy (pc->mq);
+    pc->mq = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ ("Can not create LOC URI. Will continue with CHK instead.\n"));
+  publish_kblocks (pc);
 }
 
 
@@ -1002,42 +1013,43 @@ loc_mq_error_handler(void *cls,
  * @param pc the publishing context do to this for
  */
 static void
-create_loc_uri(struct GNUNET_FS_PublishContext *pc)
+create_loc_uri (struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_fixed_size(signature_response,
-                            GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE,
-                            struct ResponseLocSignatureMessage,
-                            pc),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_fixed_size (signature_response,
+                             GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE,
+                             struct ResponseLocSignatureMessage,
+                             pc),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_Envelope *env;
   struct RequestLocSignatureMessage *req;
   struct GNUNET_FS_FileInformation *p;
 
   if (NULL != pc->mq)
-    GNUNET_MQ_destroy(pc->mq);
-  pc->mq = GNUNET_CLIENT_connect(pc->h->cfg,
-                                 "fs",
-                                 handlers,
-                                 &loc_mq_error_handler,
-                                 pc);
+    GNUNET_MQ_destroy (pc->mq);
+  pc->mq = GNUNET_CLIENT_connect (pc->h->cfg,
+                                  "fs",
+                                  handlers,
+                                  &loc_mq_error_handler,
+                                  pc);
   if (NULL == pc->mq)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Can not create LOC URI. Will continue with CHK instead.\n"));
-      publish_kblocks(pc);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "Can not create LOC URI. Will continue with CHK instead.\n"));
+    publish_kblocks (pc);
+    return;
+  }
   p = pc->fi_pos;
-  env = GNUNET_MQ_msg(req,
-                      GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN);
-  req->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
-  req->expiration_time = GNUNET_TIME_absolute_hton(p->bo.expiration_time);
+  env = GNUNET_MQ_msg (req,
+                       GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN);
+  req->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
+  req->expiration_time = GNUNET_TIME_absolute_hton (p->bo.expiration_time);
   req->chk = p->chk_uri->data.chk.chk;
-  req->file_length = GNUNET_htonll(p->chk_uri->data.chk.file_length);
-  GNUNET_MQ_send(pc->mq,
-                 env);
+  req->file_length = GNUNET_htonll (p->chk_uri->data.chk.file_length);
+  GNUNET_MQ_send (pc->mq,
+                  env);
 }
 
 
@@ -1047,7 +1059,7 @@ create_loc_uri(struct GNUNET_FS_PublishContext *pc)
  * @param cls `struct GNUNET_FS_PublishContext *` identifies the upload
  */
 void
-GNUNET_FS_publish_main_(void *cls)
+GNUNET_FS_publish_main_ (void *cls)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
@@ -1057,108 +1069,109 @@ GNUNET_FS_publish_main_(void *cls)
   pc->upload_task = NULL;
   p = pc->fi_pos;
   if (NULL == p)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publishing complete, now publishing SKS and KSK blocks.\n");
-      /* upload of entire hierarchy complete,
-       * publish namespace entries */
-      GNUNET_FS_publish_sync_(pc);
-      publish_sblock(pc);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publishing complete, now publishing SKS and KSK blocks.\n");
+    /* upload of entire hierarchy complete,
+     * publish namespace entries */
+    GNUNET_FS_publish_sync_ (pc);
+    publish_sblock (pc);
+    return;
+  }
   /* find starting position */
   while ((GNUNET_YES == p->is_directory) &&
          (NULL != p->data.dir.entries) &&
          (NULL == p->emsg) &&
          (NULL == p->data.dir.entries->chk_uri))
-    {
-      p = p->data.dir.entries;
-      pc->fi_pos = p;
-      GNUNET_FS_publish_sync_(pc);
-    }
+  {
+    p = p->data.dir.entries;
+    pc->fi_pos = p;
+    GNUNET_FS_publish_sync_ (pc);
+  }
   /* abort on error */
   if (NULL != p->emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Error uploading: %s\n",
-                 p->emsg);
-      /* error with current file, abort all
-       * related files as well! */
-      while (NULL != p->dir)
-        {
-          fn = GNUNET_CONTAINER_meta_data_get_by_type(p->meta,
-                                                      EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
-          p = p->dir;
-          if (fn != NULL)
-            {
-              GNUNET_asprintf(&p->emsg,
-                              _("Recursive upload failed at `%s': %s"),
-                              fn,
-                              p->emsg);
-              GNUNET_free(fn);
-            }
-          else
-            {
-              GNUNET_asprintf(&p->emsg,
-                              _("Recursive upload failed: %s"),
-                              p->emsg);
-            }
-          pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
-          pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
-          pi.value.publish.specifics.error.message = p->emsg;
-          p->client_info = GNUNET_FS_publish_make_status_(&pi, pc, p, 0);
-        }
-      pc->all_done = GNUNET_YES;
-      GNUNET_FS_publish_sync_(pc);
-      return;
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Error uploading: %s\n",
+                p->emsg);
+    /* error with current file, abort all
+     * related files as well! */
+    while (NULL != p->dir)
+    {
+      fn = GNUNET_CONTAINER_meta_data_get_by_type (p->meta,
+                                                   EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+      p = p->dir;
+      if (fn != NULL)
+      {
+        GNUNET_asprintf (&p->emsg,
+                         _ ("Recursive upload failed at `%s': %s"),
+                         fn,
+                         p->emsg);
+        GNUNET_free (fn);
+      }
+      else
+      {
+        GNUNET_asprintf (&p->emsg,
+                         _ ("Recursive upload failed: %s"),
+                         p->emsg);
+      }
+      pi.status = GNUNET_FS_STATUS_PUBLISH_ERROR;
+      pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
+      pi.value.publish.specifics.error.message = p->emsg;
+      p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
     }
+    pc->all_done = GNUNET_YES;
+    GNUNET_FS_publish_sync_ (pc);
+    return;
+  }
   /* handle completion */
   if (NULL != p->chk_uri)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "File upload complete, now publishing KSK blocks.\n");
-      GNUNET_FS_publish_sync_(pc);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "File upload complete, now publishing KSK blocks.\n");
+    GNUNET_FS_publish_sync_ (pc);
 
-      if ((0 == p->bo.anonymity_level) &&
-          (GNUNET_YES !=
-           GNUNET_FS_uri_test_loc(p->chk_uri)))
-        {
-          /* zero anonymity, box CHK URI in LOC URI */
-          create_loc_uri(pc);
-        }
-      else
-        {
-          publish_kblocks(pc);
-        }
-      return;
+    if ((0 == p->bo.anonymity_level) &&
+        (GNUNET_YES !=
+         GNUNET_FS_uri_test_loc (p->chk_uri)))
+    {
+      /* zero anonymity, box CHK URI in LOC URI */
+      create_loc_uri (pc);
+    }
+    else
+    {
+      publish_kblocks (pc);
     }
+    return;
+  }
   if ((GNUNET_YES != p->is_directory) && (p->data.file.do_index))
+  {
+    if (NULL == p->filename)
     {
-      if (NULL == p->filename)
-        {
-          p->data.file.do_index = GNUNET_NO;
-          GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                     _("Can not index file `%s': %s.  Will try to insert instead.\n"),
-                     "<no-name>",
-                     _("needs to be an actual file"));
-          GNUNET_FS_file_information_sync_(p);
-          publish_content(pc);
-          return;
-        }
-      if (p->data.file.have_hash)
-        {
-          hash_for_index_cb(pc, &p->data.file.file_id);
-        }
-      else
-        {
-          p->start_time = GNUNET_TIME_absolute_get();
-          pc->fhc =
-            GNUNET_CRYPTO_hash_file(GNUNET_SCHEDULER_PRIORITY_IDLE, p->filename,
-                                    HASHING_BLOCKSIZE, &hash_for_index_cb, pc);
-        }
+      p->data.file.do_index = GNUNET_NO;
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _ (
+                    "Can not index file `%s': %s.  Will try to insert instead.\n"),
+                  "<no-name>",
+                  _ ("needs to be an actual file"));
+      GNUNET_FS_file_information_sync_ (p);
+      publish_content (pc);
       return;
     }
-  publish_content(pc);
+    if (p->data.file.have_hash)
+    {
+      hash_for_index_cb (pc, &p->data.file.file_id);
+    }
+    else
+    {
+      p->start_time = GNUNET_TIME_absolute_get ();
+      pc->fhc =
+        GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE, p->filename,
+                                 HASHING_BLOCKSIZE, &hash_for_index_cb, pc);
+    }
+    return;
+  }
+  publish_content (pc);
 }
 
 
@@ -1177,14 +1190,14 @@ GNUNET_FS_publish_main_(void *cls)
  * @return #GNUNET_OK to continue (always)
  */
 static int
-fip_signal_start(void *cls,
-                 struct GNUNET_FS_FileInformation *fi,
-                 uint64_t length,
-                 struct GNUNET_CONTAINER_MetaData *meta,
-                 struct GNUNET_FS_Uri **uri,
-                 struct GNUNET_FS_BlockOptions *bo,
-                 int *do_index,
-                 void **client_info)
+fip_signal_start (void *cls,
+                  struct GNUNET_FS_FileInformation *fi,
+                  uint64_t length,
+                  struct GNUNET_CONTAINER_MetaData *meta,
+                  struct GNUNET_FS_Uri **uri,
+                  struct GNUNET_FS_BlockOptions *bo,
+                  int *do_index,
+                  void **client_info)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
@@ -1192,52 +1205,52 @@ fip_signal_start(void *cls,
   uint64_t left;
 
   if (GNUNET_YES == pc->skip_next_fi_callback)
-    {
-      pc->skip_next_fi_callback = GNUNET_NO;
-      return GNUNET_OK;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Starting publish operation\n");
+  {
+    pc->skip_next_fi_callback = GNUNET_NO;
+    return GNUNET_OK;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting publish operation\n");
   if (*do_index)
-    {
-      /* space for on-demand blocks */
-      pc->reserve_space +=
-        ((length + DBLOCK_SIZE -
-          1) / DBLOCK_SIZE) * sizeof(struct OnDemandBlock);
-    }
+  {
+    /* space for on-demand blocks */
+    pc->reserve_space +=
+      ((length + DBLOCK_SIZE
+        - 1) / DBLOCK_SIZE) * sizeof(struct OnDemandBlock);
+  }
   else
-    {
-      /* space for DBlocks */
-      pc->reserve_space += length;
-    }
+  {
+    /* space for DBlocks */
+    pc->reserve_space += length;
+  }
   /* entries for IBlocks and DBlocks, space for IBlocks */
   left = length;
   while (1)
-    {
-      left = (left + DBLOCK_SIZE - 1) / DBLOCK_SIZE;
-      pc->reserve_entries += left;
-      if (left <= 1)
-        break;
-      left = left * sizeof(struct ContentHashKey);
-      pc->reserve_space += left;
-    }
+  {
+    left = (left + DBLOCK_SIZE - 1) / DBLOCK_SIZE;
+    pc->reserve_entries += left;
+    if (left <= 1)
+      break;
+    left = left * sizeof(struct ContentHashKey);
+    pc->reserve_space += left;
+  }
   pc->reserve_entries++;
   /* entries and space for keywords */
   if (NULL != *uri)
-    {
-      kc = GNUNET_FS_uri_ksk_get_keyword_count(*uri);
-      pc->reserve_entries += kc;
-      pc->reserve_space += GNUNET_MAX_MESSAGE_SIZE * kc;
-    }
+  {
+    kc = GNUNET_FS_uri_ksk_get_keyword_count (*uri);
+    pc->reserve_entries += kc;
+    pc->reserve_space += GNUNET_MAX_MESSAGE_SIZE * kc;
+  }
   pi.status = GNUNET_FS_STATUS_PUBLISH_START;
-  *client_info = GNUNET_FS_publish_make_status_(&pi, pc, fi, 0);
-  GNUNET_FS_file_information_sync_(fi);
+  *client_info = GNUNET_FS_publish_make_status_ (&pi, pc, fi, 0);
+  GNUNET_FS_file_information_sync_ (fi);
   if ((fi->is_directory) && (fi->dir != NULL))
-    {
-      /* We are a directory, and we are not top-level; process entries in directory */
-      pc->skip_next_fi_callback = GNUNET_YES;
-      GNUNET_FS_file_information_inspect(fi, &fip_signal_start, pc);
-    }
+  {
+    /* We are a directory, and we are not top-level; process entries in directory */
+    pc->skip_next_fi_callback = GNUNET_YES;
+    GNUNET_FS_file_information_inspect (fi, &fip_signal_start, pc);
+  }
   return GNUNET_OK;
 }
 
@@ -1250,39 +1263,40 @@ fip_signal_start(void *cls,
  * @param pc the publish context of which a file is being suspended
  */
 static void
-suspend_operation(struct GNUNET_FS_FileInformation *fi,
-                  struct GNUNET_FS_PublishContext *pc)
+suspend_operation (struct GNUNET_FS_FileInformation *fi,
+                   struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t off;
 
   if (NULL != pc->ksk_pc)
-    {
-      GNUNET_FS_publish_ksk_cancel(pc->ksk_pc);
-      pc->ksk_pc = NULL;
-    }
+  {
+    GNUNET_FS_publish_ksk_cancel (pc->ksk_pc);
+    pc->ksk_pc = NULL;
+  }
   if (NULL != pc->sks_pc)
-    {
-      GNUNET_FS_publish_sks_cancel(pc->sks_pc);
-      pc->sks_pc = NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Suspending publish operation\n");
-  GNUNET_free_non_null(fi->serialization);
+  {
+    GNUNET_FS_publish_sks_cancel (pc->sks_pc);
+    pc->sks_pc = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Suspending publish operation\n");
+  GNUNET_free_non_null (fi->serialization);
   fi->serialization = NULL;
-  off = (NULL == fi->chk_uri) ? 0 : (GNUNET_YES == fi->is_directory) ? fi->data.dir.dir_size : fi->data.file.file_size;
+  off = (NULL == fi->chk_uri) ? 0 : (GNUNET_YES == fi->is_directory) ?
+        fi->data.dir.dir_size : fi->data.file.file_size;
   pi.status = GNUNET_FS_STATUS_PUBLISH_SUSPEND;
-  GNUNET_break(NULL == GNUNET_FS_publish_make_status_(&pi, pc, fi, off));
+  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, fi, off));
   if (NULL != pc->qre)
-    {
-      GNUNET_DATASTORE_cancel(pc->qre);
-      pc->qre = NULL;
-    }
+  {
+    GNUNET_DATASTORE_cancel (pc->qre);
+    pc->qre = NULL;
+  }
   if (NULL != pc->dsh)
-    {
-      GNUNET_DATASTORE_disconnect(pc->dsh, GNUNET_NO);
-      pc->dsh = NULL;
-    }
+  {
+    GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO);
+    pc->dsh = NULL;
+  }
   pc->rid = 0;
 }
 
@@ -1302,29 +1316,29 @@ suspend_operation(struct GNUNET_FS_FileInformation *fi,
  * @return #GNUNET_OK to continue (always)
  */
 static int
-fip_signal_suspend(void *cls,
-                   struct GNUNET_FS_FileInformation *fi,
-                   uint64_t length,
-                   struct GNUNET_CONTAINER_MetaData *meta,
-                   struct GNUNET_FS_Uri **uri,
-                   struct GNUNET_FS_BlockOptions *bo,
-                   int *do_index,
-                   void **client_info)
+fip_signal_suspend (void *cls,
+                    struct GNUNET_FS_FileInformation *fi,
+                    uint64_t length,
+                    struct GNUNET_CONTAINER_MetaData *meta,
+                    struct GNUNET_FS_Uri **uri,
+                    struct GNUNET_FS_BlockOptions *bo,
+                    int *do_index,
+                    void **client_info)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   if (GNUNET_YES == pc->skip_next_fi_callback)
-    {
-      pc->skip_next_fi_callback = GNUNET_NO;
-      return GNUNET_OK;
-    }
-  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(meta))
-    {
-      /* process entries in directory */
-      pc->skip_next_fi_callback = GNUNET_YES;
-      GNUNET_FS_file_information_inspect(fi, &fip_signal_suspend, pc);
-    }
-  suspend_operation(fi, pc);
+  {
+    pc->skip_next_fi_callback = GNUNET_NO;
+    return GNUNET_OK;
+  }
+  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (meta))
+  {
+    /* process entries in directory */
+    pc->skip_next_fi_callback = GNUNET_YES;
+    GNUNET_FS_file_information_inspect (fi, &fip_signal_suspend, pc);
+  }
+  suspend_operation (fi, pc);
   *client_info = NULL;
   return GNUNET_OK;
 }
@@ -1337,21 +1351,21 @@ fip_signal_suspend(void *cls,
  * @param cls the `struct GNUNET_FS_PublishContext` to signal for
  */
 void
-GNUNET_FS_publish_signal_suspend_(void *cls)
+GNUNET_FS_publish_signal_suspend_ (void *cls)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   if (NULL != pc->upload_task)
-    {
-      GNUNET_SCHEDULER_cancel(pc->upload_task);
-      pc->upload_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pc->upload_task);
+    pc->upload_task = NULL;
+  }
   pc->skip_next_fi_callback = GNUNET_YES;
-  GNUNET_FS_file_information_inspect(pc->fi, &fip_signal_suspend, pc);
-  suspend_operation(pc->fi, pc);
-  GNUNET_FS_end_top(pc->h, pc->top);
+  GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_suspend, pc);
+  suspend_operation (pc->fi, pc);
+  GNUNET_FS_end_top (pc->h, pc->top);
   pc->top = NULL;
-  publish_cleanup(pc);
+  publish_cleanup (pc);
 }
 
 
@@ -1365,30 +1379,30 @@ GNUNET_FS_publish_signal_suspend_(void *cls)
  * @param msg error message on error, otherwise NULL
  */
 static void
-finish_reserve(void *cls,
-               int success,
-               struct GNUNET_TIME_Absolute min_expiration,
-               const char *msg)
+finish_reserve (void *cls,
+                int success,
+                struct GNUNET_TIME_Absolute min_expiration,
+                const char *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   pc->qre = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Reservation complete (%d)!\n",
-             success);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Reservation complete (%d)!\n",
+              success);
   if ((msg != NULL) || (success <= 0))
-    {
-      GNUNET_asprintf(&pc->fi->emsg,
-                      _("Datastore failure: %s"),
-                      msg);
-      signal_publish_error(pc->fi, pc, pc->fi->emsg);
-      return;
-    }
+  {
+    GNUNET_asprintf (&pc->fi->emsg,
+                     _ ("Datastore failure: %s"),
+                     msg);
+    signal_publish_error (pc->fi, pc, pc->fi->emsg);
+    return;
+  }
   pc->rid = success;
-  GNUNET_assert(NULL == pc->upload_task);
+  GNUNET_assert (NULL == pc->upload_task);
   pc->upload_task =
-    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                       &GNUNET_FS_publish_main_, pc);
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                        &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -1398,7 +1412,7 @@ finish_reserve(void *cls,
  * @param fi file structure to traverse
  */
 static uint64_t
-compute_contents_size(struct GNUNET_FS_FileInformation *fi)
+compute_contents_size (struct GNUNET_FS_FileInformation *fi)
 {
   struct GNUNET_FS_FileInformation *ent;
 
@@ -1406,7 +1420,7 @@ compute_contents_size(struct GNUNET_FS_FileInformation *fi)
     return fi->data.file.file_size;
   fi->data.dir.contents_size = 0;
   for (ent = fi->data.dir.entries; NULL != ent; ent = ent->next)
-    fi->data.dir.contents_size += compute_contents_size(ent);
+    fi->data.dir.contents_size += compute_contents_size (ent);
   return fi->data.dir.contents_size;
 }
 
@@ -1425,67 +1439,68 @@ compute_contents_size(struct GNUNET_FS_FileInformation *fi)
  * @return context that can be used to control the publish operation
  */
 struct GNUNET_FS_PublishContext *
-GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h,
-                        struct GNUNET_FS_FileInformation *fi,
-                        const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
-                        const char *nid,
-                        const char *nuid,
-                        enum GNUNET_FS_PublishOptions options)
+GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h,
+                         struct GNUNET_FS_FileInformation *fi,
+                         const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
+                         const char *nid,
+                         const char *nuid,
+                         enum GNUNET_FS_PublishOptions options)
 {
   struct GNUNET_FS_PublishContext *ret;
   struct GNUNET_DATASTORE_Handle *dsh;
 
-  GNUNET_assert(NULL != h);
-  compute_contents_size(fi);
+  GNUNET_assert (NULL != h);
+  compute_contents_size (fi);
   if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
-    {
-      dsh = GNUNET_DATASTORE_connect(h->cfg);
-      if (NULL == dsh)
-        return NULL;
-    }
+  {
+    dsh = GNUNET_DATASTORE_connect (h->cfg);
+    if (NULL == dsh)
+      return NULL;
+  }
   else
-    {
-      dsh = NULL;
-    }
-  ret = GNUNET_new(struct GNUNET_FS_PublishContext);
+  {
+    dsh = NULL;
+  }
+  ret = GNUNET_new (struct GNUNET_FS_PublishContext);
   ret->dsh = dsh;
   ret->h = h;
   ret->fi = fi;
   if (NULL != ns)
-    {
-      ret->ns = GNUNET_new(struct GNUNET_CRYPTO_EcdsaPrivateKey);
-      *ret->ns = *ns;
-      GNUNET_assert(NULL != nid);
-      ret->nid = GNUNET_strdup(nid);
-      if (NULL != nuid)
-        ret->nuid = GNUNET_strdup(nuid);
-    }
+  {
+    ret->ns = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
+    *ret->ns = *ns;
+    GNUNET_assert (NULL != nid);
+    ret->nid = GNUNET_strdup (nid);
+    if (NULL != nuid)
+      ret->nuid = GNUNET_strdup (nuid);
+  }
   ret->options = options;
   /* signal start */
-  GNUNET_FS_file_information_inspect(ret->fi, &fip_signal_start, ret);
+  GNUNET_FS_file_information_inspect (ret->fi, &fip_signal_start, ret);
   ret->fi_pos = ret->fi;
-  ret->top = GNUNET_FS_make_top(h, &GNUNET_FS_publish_signal_suspend_, ret);
-  GNUNET_FS_publish_sync_(ret);
+  ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_publish_signal_suspend_, ret);
+  GNUNET_FS_publish_sync_ (ret);
   if (NULL != ret->dsh)
-    {
-      GNUNET_assert(NULL == ret->qre);
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("Reserving space for %u entries and %llu bytes for publication\n"),
-                 (unsigned int)ret->reserve_entries,
-                 (unsigned long long)ret->reserve_space);
-      ret->qre =
-        GNUNET_DATASTORE_reserve(ret->dsh, ret->reserve_space,
-                                 ret->reserve_entries,
-                                 &finish_reserve,
-                                 ret);
-    }
+  {
+    GNUNET_assert (NULL == ret->qre);
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ (
+                  "Reserving space for %u entries and %llu bytes for publication\n"),
+                (unsigned int) ret->reserve_entries,
+                (unsigned long long) ret->reserve_space);
+    ret->qre =
+      GNUNET_DATASTORE_reserve (ret->dsh, ret->reserve_space,
+                                ret->reserve_entries,
+                                &finish_reserve,
+                                ret);
+  }
   else
-    {
-      GNUNET_assert(NULL == ret->upload_task);
-      ret->upload_task =
-        GNUNET_SCHEDULER_add_with_priority
-          (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, ret);
-    }
+  {
+    GNUNET_assert (NULL == ret->upload_task);
+    ret->upload_task =
+      GNUNET_SCHEDULER_add_with_priority
+        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, ret);
+  }
   return ret;
 }
 
@@ -1505,39 +1520,39 @@ GNUNET_FS_publish_start(struct GNUNET_FS_Handle *h,
  * @return #GNUNET_OK to continue (always)
  */
 static int
-fip_signal_stop(void *cls,
-                struct GNUNET_FS_FileInformation *fi,
-                uint64_t length,
-                struct GNUNET_CONTAINER_MetaData *meta,
-                struct GNUNET_FS_Uri **uri,
-                struct GNUNET_FS_BlockOptions *bo,
-                int *do_index, void **client_info)
+fip_signal_stop (void *cls,
+                 struct GNUNET_FS_FileInformation *fi,
+                 uint64_t length,
+                 struct GNUNET_CONTAINER_MetaData *meta,
+                 struct GNUNET_FS_Uri **uri,
+                 struct GNUNET_FS_BlockOptions *bo,
+                 int *do_index, void **client_info)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t off;
 
   if (GNUNET_YES == pc->skip_next_fi_callback)
-    {
-      pc->skip_next_fi_callback = GNUNET_NO;
-      return GNUNET_OK;
-    }
-  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(meta))
-    {
-      /* process entries in directory first */
-      pc->skip_next_fi_callback = GNUNET_YES;
-      GNUNET_FS_file_information_inspect(fi, &fip_signal_stop, pc);
-    }
+  {
+    pc->skip_next_fi_callback = GNUNET_NO;
+    return GNUNET_OK;
+  }
+  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (meta))
+  {
+    /* process entries in directory first */
+    pc->skip_next_fi_callback = GNUNET_YES;
+    GNUNET_FS_file_information_inspect (fi, &fip_signal_stop, pc);
+  }
   if (NULL != fi->serialization)
-    {
-      GNUNET_FS_remove_sync_file_(pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO,
-                                  fi->serialization);
-      GNUNET_free(fi->serialization);
-      fi->serialization = NULL;
-    }
+  {
+    GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO,
+                                 fi->serialization);
+    GNUNET_free (fi->serialization);
+    fi->serialization = NULL;
+  }
   off = (fi->chk_uri == NULL) ? 0 : length;
   pi.status = GNUNET_FS_STATUS_PUBLISH_STOPPED;
-  GNUNET_break(NULL == GNUNET_FS_publish_make_status_(&pi, pc, fi, off));
+  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, fi, off));
   *client_info = NULL;
   return GNUNET_OK;
 }
@@ -1552,56 +1567,57 @@ fip_signal_stop(void *cls,
  * @param pc context for the upload to stop
  */
 void
-GNUNET_FS_publish_stop(struct GNUNET_FS_PublishContext *pc)
+GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t off;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Publish stop called\n");
-  GNUNET_FS_end_top(pc->h, pc->top);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Publish stop called\n");
+  GNUNET_FS_end_top (pc->h, pc->top);
   if (NULL != pc->ksk_pc)
-    {
-      GNUNET_FS_publish_ksk_cancel(pc->ksk_pc);
-      pc->ksk_pc = NULL;
-    }
+  {
+    GNUNET_FS_publish_ksk_cancel (pc->ksk_pc);
+    pc->ksk_pc = NULL;
+  }
   if (NULL != pc->sks_pc)
-    {
-      GNUNET_FS_publish_sks_cancel(pc->sks_pc);
-      pc->sks_pc = NULL;
-    }
+  {
+    GNUNET_FS_publish_sks_cancel (pc->sks_pc);
+    pc->sks_pc = NULL;
+  }
   if (NULL != pc->upload_task)
-    {
-      GNUNET_SCHEDULER_cancel(pc->upload_task);
-      pc->upload_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pc->upload_task);
+    pc->upload_task = NULL;
+  }
   pc->skip_next_fi_callback = GNUNET_YES;
-  GNUNET_FS_file_information_inspect(pc->fi, &fip_signal_stop, pc);
+  GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_stop, pc);
 
   if (NULL != pc->fi->serialization)
-    {
-      GNUNET_FS_remove_sync_file_(pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO,
-                                  pc->fi->serialization);
-      GNUNET_free(pc->fi->serialization);
-      pc->fi->serialization = NULL;
-    }
-  off = (NULL == pc->fi->chk_uri) ? 0 : GNUNET_ntohll(pc->fi->chk_uri->data.chk.file_length);
+  {
+    GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO,
+                                 pc->fi->serialization);
+    GNUNET_free (pc->fi->serialization);
+    pc->fi->serialization = NULL;
+  }
+  off = (NULL == pc->fi->chk_uri) ? 0 : GNUNET_ntohll (
+    pc->fi->chk_uri->data.chk.file_length);
 
   if (NULL != pc->serialization)
-    {
-      GNUNET_FS_remove_sync_file_(pc->h, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
-                                  pc->serialization);
-      GNUNET_free(pc->serialization);
-      pc->serialization = NULL;
-    }
+  {
+    GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
+                                 pc->serialization);
+    GNUNET_free (pc->serialization);
+    pc->serialization = NULL;
+  }
   if (NULL != pc->qre)
-    {
-      GNUNET_DATASTORE_cancel(pc->qre);
-      pc->qre = NULL;
-    }
+  {
+    GNUNET_DATASTORE_cancel (pc->qre);
+    pc->qre = NULL;
+  }
   pi.status = GNUNET_FS_STATUS_PUBLISH_STOPPED;
-  GNUNET_break(NULL == GNUNET_FS_publish_make_status_(&pi, pc, pc->fi, off));
-  publish_cleanup(pc);
+  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi, off));
+  publish_cleanup (pc);
 }
 
 
diff --git a/src/fs/fs_publish_ksk.c b/src/fs/fs_publish_ksk.c
index 151b8256c..372ac705d 100644
--- a/src/fs/fs_publish_ksk.c
+++ b/src/fs/fs_publish_ksk.c
@@ -38,7 +38,8 @@
 /**
  * Context for the KSK publication.
  */
-struct GNUNET_FS_PublishKskContext {
+struct GNUNET_FS_PublishKskContext
+{
   /**
    * Keywords to use.
    */
@@ -72,7 +73,7 @@ struct GNUNET_FS_PublishKskContext {
   /**
    * Current task.
    */
-  struct GNUNET_SCHEDULER_Task * ksk_task;
+  struct GNUNET_SCHEDULER_Task *ksk_task;
 
   /**
    * Function to call once we're done.
@@ -109,7 +110,7 @@ struct GNUNET_FS_PublishKskContext {
  * @param cls closure of type `struct PublishKskContext *`
  */
 static void
-publish_ksk_cont(void *cls);
+publish_ksk_cont (void *cls);
 
 
 /**
@@ -120,21 +121,21 @@ publish_ksk_cont(void *cls);
  * @param msg error message (or NULL)
  */
 static void
-kb_put_cont(void *cls,
-            const char *msg)
+kb_put_cont (void *cls,
+             const char *msg)
 {
   struct GNUNET_FS_PublishKskContext *pkc = cls;
 
   pkc->uc = NULL;
   if (NULL != msg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "KBlock PUT operation failed: %s\n", msg);
-      pkc->cont(pkc->cont_cls, NULL, msg);
-      GNUNET_FS_publish_ksk_cancel(pkc);
-      return;
-    }
-  pkc->ksk_task = GNUNET_SCHEDULER_add_now(&publish_ksk_cont, pkc);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "KBlock PUT operation failed: %s\n", msg);
+    pkc->cont (pkc->cont_cls, NULL, msg);
+    GNUNET_FS_publish_ksk_cancel (pkc);
+    return;
+  }
+  pkc->ksk_task = GNUNET_SCHEDULER_add_now (&publish_ksk_cont, pkc);
 }
 
 
@@ -145,7 +146,7 @@ kb_put_cont(void *cls,
  * @param cls closure of type `struct GNUNET_FS_PublishKskContext *`
  */
 static void
-publish_ksk_cont(void *cls)
+publish_ksk_cont (void *cls)
 {
   struct GNUNET_FS_PublishKskContext *pkc = cls;
   const char *keyword;
@@ -153,25 +154,25 @@ publish_ksk_cont(void *cls)
   pkc->ksk_task = NULL;
   if ((pkc->i == pkc->ksk_uri->data.ksk.keywordCount) ||
       (NULL == pkc->dsh))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "KSK PUT operation complete\n");
-      pkc->cont(pkc->cont_cls, pkc->ksk_uri,
-                NULL);
-      GNUNET_FS_publish_ksk_cancel(pkc);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "KSK PUT operation complete\n");
+    pkc->cont (pkc->cont_cls, pkc->ksk_uri,
+               NULL);
+    GNUNET_FS_publish_ksk_cancel (pkc);
+    return;
+  }
   keyword = pkc->ksk_uri->data.ksk.keywords[pkc->i++];
-  pkc->uc = GNUNET_FS_publish_ublock_(pkc->h,
-                                      pkc->dsh,
-                                      keyword + 1 /* skip '+' */,
-                                      NULL,
-                                      GNUNET_CRYPTO_ecdsa_key_get_anonymous(),
-                                      pkc->meta,
-                                      pkc->uri,
-                                      &pkc->bo,
-                                      pkc->options,
-                                      &kb_put_cont, pkc);
+  pkc->uc = GNUNET_FS_publish_ublock_ (pkc->h,
+                                       pkc->dsh,
+                                       keyword + 1 /* skip '+' */,
+                                       NULL,
+                                       GNUNET_CRYPTO_ecdsa_key_get_anonymous (),
+                                       pkc->meta,
+                                       pkc->uri,
+                                       &pkc->bo,
+                                       pkc->options,
+                                       &kb_put_cont, pkc);
 }
 
 
@@ -189,39 +190,39 @@ publish_ksk_cont(void *cls)
  * @return NULL on error ('cont' will still be called)
  */
 struct GNUNET_FS_PublishKskContext *
-GNUNET_FS_publish_ksk(struct GNUNET_FS_Handle *h,
-                      const struct GNUNET_FS_Uri *ksk_uri,
-                      const struct GNUNET_CONTAINER_MetaData *meta,
-                      const struct GNUNET_FS_Uri *uri,
-                      const struct GNUNET_FS_BlockOptions *bo,
-                      enum GNUNET_FS_PublishOptions options,
-                      GNUNET_FS_PublishContinuation cont, void *cont_cls)
+GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
+                       const struct GNUNET_FS_Uri *ksk_uri,
+                       const struct GNUNET_CONTAINER_MetaData *meta,
+                       const struct GNUNET_FS_Uri *uri,
+                       const struct GNUNET_FS_BlockOptions *bo,
+                       enum GNUNET_FS_PublishOptions options,
+                       GNUNET_FS_PublishContinuation cont, void *cont_cls)
 {
   struct GNUNET_FS_PublishKskContext *pkc;
 
-  GNUNET_assert(NULL != uri);
-  pkc = GNUNET_new(struct GNUNET_FS_PublishKskContext);
+  GNUNET_assert (NULL != uri);
+  pkc = GNUNET_new (struct GNUNET_FS_PublishKskContext);
   pkc->h = h;
   pkc->bo = *bo;
   pkc->options = options;
   pkc->cont = cont;
   pkc->cont_cls = cont_cls;
-  pkc->meta = GNUNET_CONTAINER_meta_data_duplicate(meta);
+  pkc->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
   if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
+  {
+    pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
+    if (NULL == pkc->dsh)
     {
-      pkc->dsh = GNUNET_DATASTORE_connect(h->cfg);
-      if (NULL == pkc->dsh)
-        {
-          cont(cont_cls,
-               NULL,
-               _("Could not connect to datastore."));
-          GNUNET_free(pkc);
-          return NULL;
-        }
+      cont (cont_cls,
+            NULL,
+            _ ("Could not connect to datastore."));
+      GNUNET_free (pkc);
+      return NULL;
     }
-  pkc->uri = GNUNET_FS_uri_dup(uri);
-  pkc->ksk_uri = GNUNET_FS_uri_dup(ksk_uri);
-  pkc->ksk_task = GNUNET_SCHEDULER_add_now(&publish_ksk_cont, pkc);
+  }
+  pkc->uri = GNUNET_FS_uri_dup (uri);
+  pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri);
+  pkc->ksk_task = GNUNET_SCHEDULER_add_now (&publish_ksk_cont, pkc);
   return pkc;
 }
 
@@ -232,27 +233,27 @@ GNUNET_FS_publish_ksk(struct GNUNET_FS_Handle *h,
  * @param pkc context of the operation to abort.
  */
 void
-GNUNET_FS_publish_ksk_cancel(struct GNUNET_FS_PublishKskContext *pkc)
+GNUNET_FS_publish_ksk_cancel (struct GNUNET_FS_PublishKskContext *pkc)
 {
   if (NULL != pkc->ksk_task)
-    {
-      GNUNET_SCHEDULER_cancel(pkc->ksk_task);
-      pkc->ksk_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pkc->ksk_task);
+    pkc->ksk_task = NULL;
+  }
   if (NULL != pkc->uc)
-    {
-      GNUNET_FS_publish_ublock_cancel_(pkc->uc);
-      pkc->uc = NULL;
-    }
+  {
+    GNUNET_FS_publish_ublock_cancel_ (pkc->uc);
+    pkc->uc = NULL;
+  }
   if (NULL != pkc->dsh)
-    {
-      GNUNET_DATASTORE_disconnect(pkc->dsh, GNUNET_NO);
-      pkc->dsh = NULL;
-    }
-  GNUNET_CONTAINER_meta_data_destroy(pkc->meta);
-  GNUNET_FS_uri_destroy(pkc->ksk_uri);
-  GNUNET_FS_uri_destroy(pkc->uri);
-  GNUNET_free(pkc);
+  {
+    GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+    pkc->dsh = NULL;
+  }
+  GNUNET_CONTAINER_meta_data_destroy (pkc->meta);
+  GNUNET_FS_uri_destroy (pkc->ksk_uri);
+  GNUNET_FS_uri_destroy (pkc->uri);
+  GNUNET_free (pkc);
 }
 
 
diff --git a/src/fs/fs_publish_ublock.c b/src/fs/fs_publish_ublock.c
index 4dfb4a585..c50e71f0b 100644
--- a/src/fs/fs_publish_ublock.c
+++ b/src/fs/fs_publish_ublock.c
@@ -43,21 +43,22 @@
  * @param pub public key to use for key derivation
  */
 static void
-derive_ublock_encryption_key(struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
-                             struct GNUNET_CRYPTO_SymmetricInitializationVector *iv,
-                             const char *label,
-                             const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
+derive_ublock_encryption_key (struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
+                              struct GNUNET_CRYPTO_SymmetricInitializationVector
+                              *iv,
+                              const char *label,
+                              const struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
 {
   struct GNUNET_HashCode key;
 
   /* derive key from 'label' and public key of the namespace */
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CRYPTO_kdf(&key, sizeof(key),
-                                  "UBLOCK-ENC", strlen("UBLOCK-ENC"),
-                                  label, strlen(label),
-                                  pub, sizeof(*pub),
-                                  NULL, 0));
-  GNUNET_CRYPTO_hash_to_aes_key(&key, skey, iv);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CRYPTO_kdf (&key, sizeof(key),
+                                    "UBLOCK-ENC", strlen ("UBLOCK-ENC"),
+                                    label, strlen (label),
+                                    pub, sizeof(*pub),
+                                    NULL, 0));
+  GNUNET_CRYPTO_hash_to_aes_key (&key, skey, iv);
 }
 
 
@@ -71,27 +72,28 @@ derive_ublock_encryption_key(struct GNUNET_CRYPTO_SymmetricSessionKey *skey,
  * @param output where to write the result, has input_len bytes
  */
 void
-GNUNET_FS_ublock_decrypt_(const void *input,
-                          size_t input_len,
-                          const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
-                          const char *label,
-                          void *output)
+GNUNET_FS_ublock_decrypt_ (const void *input,
+                           size_t input_len,
+                           const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
+                           const char *label,
+                           void *output)
 {
   struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
   struct GNUNET_CRYPTO_SymmetricSessionKey skey;
 
-  derive_ublock_encryption_key(&skey, &iv,
-                               label, ns);
-  GNUNET_CRYPTO_symmetric_decrypt(input, input_len,
-                                  &skey, &iv,
-                                  output);
+  derive_ublock_encryption_key (&skey, &iv,
+                                label, ns);
+  GNUNET_CRYPTO_symmetric_decrypt (input, input_len,
+                                   &skey, &iv,
+                                   output);
 }
 
 
 /**
  * Context for 'ublock_put_cont'.
  */
-struct GNUNET_FS_PublishUblockContext {
+struct GNUNET_FS_PublishUblockContext
+{
   /**
    * Function to call when done.
    */
@@ -110,7 +112,7 @@ struct GNUNET_FS_PublishUblockContext {
   /**
    * Task to run continuation asynchronously.
    */
-  struct GNUNET_SCHEDULER_Task * task;
+  struct GNUNET_SCHEDULER_Task *task;
 };
 
 
@@ -127,16 +129,16 @@ struct GNUNET_FS_PublishUblockContext {
  * @param msg NULL on success, otherwise an error message
  */
 static void
-ublock_put_cont(void *cls,
-                int32_t success,
-                struct GNUNET_TIME_Absolute min_expiration,
-                const char *msg)
+ublock_put_cont (void *cls,
+                 int32_t success,
+                 struct GNUNET_TIME_Absolute min_expiration,
+                 const char *msg)
 {
   struct GNUNET_FS_PublishUblockContext *uc = cls;
 
   uc->qre = NULL;
-  uc->cont(uc->cont_cls, msg);
-  GNUNET_free(uc);
+  uc->cont (uc->cont_cls, msg);
+  GNUNET_free (uc);
 }
 
 
@@ -146,13 +148,13 @@ ublock_put_cont(void *cls,
  * @param cls the `struct GNUNET_FS_PublishUblockContext *`
  */
 static void
-run_cont(void *cls)
+run_cont (void *cls)
 {
   struct GNUNET_FS_PublishUblockContext *uc = cls;
 
   uc->task = NULL;
-  uc->cont(uc->cont_cls, NULL);
-  GNUNET_free(uc);
+  uc->cont (uc->cont_cls, NULL);
+  GNUNET_free (uc);
 }
 
 
@@ -173,16 +175,16 @@ run_cont(void *cls)
  * @return NULL on error (@a cont will still be called)
  */
 struct GNUNET_FS_PublishUblockContext *
-GNUNET_FS_publish_ublock_(struct GNUNET_FS_Handle *h,
-                          struct GNUNET_DATASTORE_Handle *dsh,
-                          const char *label,
-                          const char *ulabel,
-                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
-                          const struct GNUNET_CONTAINER_MetaData *meta,
-                          const struct GNUNET_FS_Uri *uri,
-                          const struct GNUNET_FS_BlockOptions *bo,
-                          enum GNUNET_FS_PublishOptions options,
-                          GNUNET_FS_UBlockContinuation cont, void *cont_cls)
+GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
+                           struct GNUNET_DATASTORE_Handle *dsh,
+                           const char *label,
+                           const char *ulabel,
+                           const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
+                           const struct GNUNET_CONTAINER_MetaData *meta,
+                           const struct GNUNET_FS_Uri *uri,
+                           const struct GNUNET_FS_BlockOptions *bo,
+                           enum GNUNET_FS_PublishOptions options,
+                           GNUNET_FS_UBlockContinuation cont, void *cont_cls)
 {
   struct GNUNET_FS_PublishUblockContext *uc;
   struct GNUNET_HashCode query;
@@ -204,101 +206,101 @@ GNUNET_FS_publish_ublock_(struct GNUNET_FS_Handle *h,
   if (NULL == meta)
     mdsize = 0;
   else
-    mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size(meta);
-  GNUNET_assert(mdsize >= 0);
-  uris = GNUNET_FS_uri_to_string(uri);
-  slen = strlen(uris) + 1;
+    mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
+  GNUNET_assert (mdsize >= 0);
+  uris = GNUNET_FS_uri_to_string (uri);
+  slen = strlen (uris) + 1;
   if (NULL == ulabel)
     ulen = 1;
   else
-    ulen = strlen(ulabel) + 1;
+    ulen = strlen (ulabel) + 1;
   size = mdsize + sizeof(struct UBlock) + slen + ulen;
   if (size > MAX_UBLOCK_SIZE)
-    {
-      size = MAX_UBLOCK_SIZE;
-      mdsize = size - sizeof(struct UBlock) - (slen + ulen);
-    }
-  ub_plain = GNUNET_malloc(size);
-  kbe = (char *)&ub_plain[1];
+  {
+    size = MAX_UBLOCK_SIZE;
+    mdsize = size - sizeof(struct UBlock) - (slen + ulen);
+  }
+  ub_plain = GNUNET_malloc (size);
+  kbe = (char *) &ub_plain[1];
   if (NULL != ulabel)
-    GNUNET_memcpy(kbe, ulabel, ulen);
+    GNUNET_memcpy (kbe, ulabel, ulen);
   kbe += ulen;
-  GNUNET_memcpy(kbe, uris, slen);
+  GNUNET_memcpy (kbe, uris, slen);
   kbe += slen;
-  GNUNET_free(uris);
+  GNUNET_free (uris);
   sptr = kbe;
   if (NULL != meta)
     mdsize =
-      GNUNET_CONTAINER_meta_data_serialize(meta, &sptr, mdsize,
-                                           GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+      GNUNET_CONTAINER_meta_data_serialize (meta, &sptr, mdsize,
+                                            GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (-1 == mdsize)
-    {
-      GNUNET_break(0);
-      GNUNET_free(ub_plain);
-      cont(cont_cls, _("Internal error."));
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_free (ub_plain);
+    cont (cont_cls, _ ("Internal error."));
+    return NULL;
+  }
   size = sizeof(struct UBlock) + slen + mdsize + ulen;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Publishing under identifier `%s'\n",
-             label);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Publishing under identifier `%s'\n",
+              label);
   /* get public key of the namespace */
-  GNUNET_CRYPTO_ecdsa_key_get_public(ns,
-                                     &pub);
-  derive_ublock_encryption_key(&skey, &iv,
-                               label, &pub);
+  GNUNET_CRYPTO_ecdsa_key_get_public (ns,
+                                      &pub);
+  derive_ublock_encryption_key (&skey, &iv,
+                                label, &pub);
 
   /* encrypt ublock */
-  ub_enc = GNUNET_malloc(size);
-  GNUNET_CRYPTO_symmetric_encrypt(&ub_plain[1],
-                                  ulen + slen + mdsize,
-                                  &skey, &iv,
-                                  &ub_enc[1]);
-  GNUNET_free(ub_plain);
-  ub_enc->purpose.size = htonl(ulen + slen + mdsize +
-                               sizeof(struct UBlock)
-                               - sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
-  ub_enc->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK);
+  ub_enc = GNUNET_malloc (size);
+  GNUNET_CRYPTO_symmetric_encrypt (&ub_plain[1],
+                                   ulen + slen + mdsize,
+                                   &skey, &iv,
+                                   &ub_enc[1]);
+  GNUNET_free (ub_plain);
+  ub_enc->purpose.size = htonl (ulen + slen + mdsize
+                                + sizeof(struct UBlock)
+                                - sizeof(struct GNUNET_CRYPTO_EcdsaSignature));
+  ub_enc->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK);
 
   /* derive signing-key from 'label' and public key of the namespace */
-  nsd = GNUNET_CRYPTO_ecdsa_private_key_derive(ns, label, "fs-ublock");
-  GNUNET_CRYPTO_ecdsa_key_get_public(nsd,
-                                     &ub_enc->verification_key);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CRYPTO_ecdsa_sign(nsd,
-                                         &ub_enc->purpose,
-                                         &ub_enc->signature));
-  GNUNET_CRYPTO_hash(&ub_enc->verification_key,
-                     sizeof(ub_enc->verification_key),
-                     &query);
-  GNUNET_free(nsd);
-
-  uc = GNUNET_new(struct GNUNET_FS_PublishUblockContext);
+  nsd = GNUNET_CRYPTO_ecdsa_private_key_derive (ns, label, "fs-ublock");
+  GNUNET_CRYPTO_ecdsa_key_get_public (nsd,
+                                      &ub_enc->verification_key);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_ecdsa_sign (nsd,
+                                           &ub_enc->purpose,
+                                           &ub_enc->signature));
+  GNUNET_CRYPTO_hash (&ub_enc->verification_key,
+                      sizeof(ub_enc->verification_key),
+                      &query);
+  GNUNET_free (nsd);
+
+  uc = GNUNET_new (struct GNUNET_FS_PublishUblockContext);
   uc->cont = cont;
   uc->cont_cls = cont_cls;
   if (NULL != dsh)
-    {
-      uc->qre =
-        GNUNET_DATASTORE_put(dsh,
-                             0,
-                             &query,
-                             ulen + slen + mdsize + sizeof(struct UBlock),
-                             ub_enc,
-                             GNUNET_BLOCK_TYPE_FS_UBLOCK,
-                             bo->content_priority,
-                             bo->anonymity_level,
-                             bo->replication_level,
-                             bo->expiration_time,
-                             -2, 1,
-                             &ublock_put_cont, uc);
-    }
+  {
+    uc->qre =
+      GNUNET_DATASTORE_put (dsh,
+                            0,
+                            &query,
+                            ulen + slen + mdsize + sizeof(struct UBlock),
+                            ub_enc,
+                            GNUNET_BLOCK_TYPE_FS_UBLOCK,
+                            bo->content_priority,
+                            bo->anonymity_level,
+                            bo->replication_level,
+                            bo->expiration_time,
+                            -2, 1,
+                            &ublock_put_cont, uc);
+  }
   else
-    {
-      uc->task = GNUNET_SCHEDULER_add_now(&run_cont,
-                                          uc);
-    }
-  GNUNET_free(ub_enc);
+  {
+    uc->task = GNUNET_SCHEDULER_add_now (&run_cont,
+                                         uc);
+  }
+  GNUNET_free (ub_enc);
   return uc;
 }
 
@@ -309,13 +311,13 @@ GNUNET_FS_publish_ublock_(struct GNUNET_FS_Handle *h,
  * @param uc operation to abort.
  */
 void
-GNUNET_FS_publish_ublock_cancel_(struct GNUNET_FS_PublishUblockContext *uc)
+GNUNET_FS_publish_ublock_cancel_ (struct GNUNET_FS_PublishUblockContext *uc)
 {
   if (NULL != uc->qre)
-    GNUNET_DATASTORE_cancel(uc->qre);
+    GNUNET_DATASTORE_cancel (uc->qre);
   if (NULL != uc->task)
-    GNUNET_SCHEDULER_cancel(uc->task);
-  GNUNET_free(uc);
+    GNUNET_SCHEDULER_cancel (uc->task);
+  GNUNET_free (uc);
 }
 
 /* end of fs_publish_ublock.c */
diff --git a/src/fs/fs_publish_ublock.h b/src/fs/fs_publish_ublock.h
index 9d0a518c6..83c6a50aa 100644
--- a/src/fs/fs_publish_ublock.h
+++ b/src/fs/fs_publish_ublock.h
@@ -44,11 +44,11 @@
  * @param output where to write the result, has input_len bytes
  */
 void
-GNUNET_FS_ublock_decrypt_(const void *input,
-                          size_t input_len,
-                          const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
-                          const char *label,
-                          void *output);
+GNUNET_FS_ublock_decrypt_ (const void *input,
+                           size_t input_len,
+                           const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
+                           const char *label,
+                           void *output);
 
 
 /**
@@ -85,16 +85,16 @@ typedef void (*GNUNET_FS_UBlockContinuation) (void *cls,
  * @return NULL on error ('cont' will still be called)
  */
 struct GNUNET_FS_PublishUblockContext *
-GNUNET_FS_publish_ublock_(struct GNUNET_FS_Handle *h,
-                          struct GNUNET_DATASTORE_Handle *dsh,
-                          const char *label,
-                          const char *ulabel,
-                          const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
-                          const struct GNUNET_CONTAINER_MetaData *meta,
-                          const struct GNUNET_FS_Uri *uri,
-                          const struct GNUNET_FS_BlockOptions *bo,
-                          enum GNUNET_FS_PublishOptions options,
-                          GNUNET_FS_UBlockContinuation cont, void *cont_cls);
+GNUNET_FS_publish_ublock_ (struct GNUNET_FS_Handle *h,
+                           struct GNUNET_DATASTORE_Handle *dsh,
+                           const char *label,
+                           const char *ulabel,
+                           const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns,
+                           const struct GNUNET_CONTAINER_MetaData *meta,
+                           const struct GNUNET_FS_Uri *uri,
+                           const struct GNUNET_FS_BlockOptions *bo,
+                           enum GNUNET_FS_PublishOptions options,
+                           GNUNET_FS_UBlockContinuation cont, void *cont_cls);
 
 
 /**
@@ -103,6 +103,6 @@ GNUNET_FS_publish_ublock_(struct GNUNET_FS_Handle *h,
  * @param uc operation to abort.
  */
 void
-GNUNET_FS_publish_ublock_cancel_(struct GNUNET_FS_PublishUblockContext *uc);
+GNUNET_FS_publish_ublock_cancel_ (struct GNUNET_FS_PublishUblockContext *uc);
 
 #endif
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index 662bc1619..62ff4e90d 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -45,9 +45,9 @@
  * @return value returned by the callback
  */
 void *
-GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                              struct GNUNET_FS_Handle *h,
-                              struct GNUNET_FS_SearchContext *sc)
+GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                               struct GNUNET_FS_Handle *h,
+                               struct GNUNET_FS_SearchContext *sc)
 {
   void *ret;
 
@@ -59,11 +59,12 @@ GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi,
     : sc->psearch_result->client_info;
   pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
   pi->value.search.duration = (NULL != sc)
-                              ? GNUNET_TIME_absolute_get_duration(sc->start_time)
+                              ? GNUNET_TIME_absolute_get_duration (
+    sc->start_time)
                               : GNUNET_TIME_UNIT_ZERO;
   pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0;
   pi->fsh = h;
-  ret = h->upcb(h->upcb_cls, pi);
+  ret = h->upcb (h->upcb_cls, pi);
   return ret;
 }
 
@@ -79,14 +80,14 @@ GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi,
  *         #GNUNET_OK otherwise
  */
 static int
-test_result_present(void *cls,
-                    const struct GNUNET_HashCode * key,
-                    void *value)
+test_result_present (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     void *value)
 {
   const struct GNUNET_FS_Uri *uri = cls;
   struct GNUNET_FS_SearchResult *sr = value;
 
-  if (GNUNET_FS_uri_test_equal(uri, sr->uri))
+  if (GNUNET_FS_uri_test_equal (uri, sr->uri))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -100,8 +101,8 @@ test_result_present(void *cls,
  * @param sr the specific result
  */
 static void
-notify_client_chk_result(struct GNUNET_FS_SearchContext *sc,
-                         struct GNUNET_FS_SearchResult *sr)
+notify_client_chk_result (struct GNUNET_FS_SearchContext *sc,
+                          struct GNUNET_FS_SearchResult *sr)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
@@ -110,7 +111,7 @@ notify_client_chk_result(struct GNUNET_FS_SearchContext *sc,
   pi.value.search.specifics.result.uri = sr->uri;
   pi.value.search.specifics.result.result = sr;
   pi.value.search.specifics.result.applicability_rank = sr->optional_support;
-  sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
+  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
 }
 
 
@@ -122,8 +123,8 @@ notify_client_chk_result(struct GNUNET_FS_SearchContext *sc,
  * @param sr the specific result
  */
 static void
-notify_client_chk_update(struct GNUNET_FS_SearchContext *sc,
-                         struct GNUNET_FS_SearchResult *sr)
+notify_client_chk_update (struct GNUNET_FS_SearchContext *sc,
+                          struct GNUNET_FS_SearchResult *sr)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
@@ -137,15 +138,16 @@ notify_client_chk_update(struct GNUNET_FS_SearchContext *sc,
     sr->availability_trials;
   pi.value.search.specifics.update.applicability_rank = sr->optional_support;
   pi.value.search.specifics.update.current_probe_time
-    = GNUNET_TIME_absolute_get_duration(sr->probe_active_time);
-  sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
+    = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
+  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
 }
 
 
 /**
  * Context for "get_result_present".
  */
-struct GetResultContext {
+struct GetResultContext
+{
   /**
    * The URI we're looking for.
    */
@@ -170,14 +172,14 @@ struct GetResultContext {
  * @return #GNUNET_OK
  */
 static int
-get_result_present(void *cls,
-                   const struct GNUNET_HashCode *key,
-                   void *value)
+get_result_present (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
 {
   struct GetResultContext *grc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
 
-  if (GNUNET_FS_uri_test_equal(grc->uri, sr->uri))
+  if (GNUNET_FS_uri_test_equal (grc->uri, sr->uri))
     grc->sr = sr;
   return GNUNET_OK;
 }
@@ -190,7 +192,7 @@ get_result_present(void *cls,
  * @param sr search result to signal for
  */
 static void
-signal_probe_result(struct GNUNET_FS_SearchResult *sr)
+signal_probe_result (struct GNUNET_FS_SearchResult *sr)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
@@ -204,9 +206,9 @@ signal_probe_result(struct GNUNET_FS_SearchResult *sr)
     = sr->availability_trials;
   pi.value.search.specifics.update.applicability_rank = sr->optional_support;
   pi.value.search.specifics.update.current_probe_time
-    = GNUNET_TIME_absolute_get_duration(sr->probe_active_time);
-  sr->client_info = GNUNET_FS_search_make_status_(&pi, sr->h, sr->sc);
-  GNUNET_FS_search_start_probe_(sr);
+    = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
+  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sr->sc);
+  GNUNET_FS_search_start_probe_ (sr);
 }
 
 
@@ -216,21 +218,21 @@ signal_probe_result(struct GNUNET_FS_SearchResult *sr)
  * @param cls our `struct GNUNET_FS_SearchResult *`
  */
 static void
-probe_failure_handler(void *cls)
+probe_failure_handler (void *cls)
 {
   struct GNUNET_FS_SearchResult *sr = cls;
 
   sr->probe_cancel_task = NULL;
   sr->availability_trials++;
-  GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES);
+  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
   sr->probe_ctx = NULL;
-  GNUNET_FS_stop_probe_ping_task_(sr);
-  GNUNET_FS_search_result_sync_(sr);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Probe #%u for search result %p failed\n",
-             sr->availability_trials,
-             sr);
-  signal_probe_result(sr);
+  GNUNET_FS_stop_probe_ping_task_ (sr);
+  GNUNET_FS_search_result_sync_ (sr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Probe #%u for search result %p failed\n",
+              sr->availability_trials,
+              sr);
+  signal_probe_result (sr);
 }
 
 
@@ -240,22 +242,22 @@ probe_failure_handler(void *cls)
  * @param cls our `struct GNUNET_FS_SearchResult *`
  */
 static void
-probe_success_handler(void *cls)
+probe_success_handler (void *cls)
 {
   struct GNUNET_FS_SearchResult *sr = cls;
 
   sr->probe_cancel_task = NULL;
   sr->availability_trials++;
   sr->availability_success++;
-  GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES);
+  GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
   sr->probe_ctx = NULL;
-  GNUNET_FS_stop_probe_ping_task_(sr);
-  GNUNET_FS_search_result_sync_(sr);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Probe #%u for search result %p succeeded\n",
-             sr->availability_trials,
-             sr);
-  signal_probe_result(sr);
+  GNUNET_FS_stop_probe_ping_task_ (sr);
+  GNUNET_FS_search_result_sync_ (sr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Probe #%u for search result %p succeeded\n",
+              sr->availability_trials,
+              sr);
+  signal_probe_result (sr);
 }
 
 
@@ -275,91 +277,83 @@ probe_success_handler(void *cls)
  *         field in the `struct GNUNET_FS_ProgressInfo`.
  */
 void *
-GNUNET_FS_search_probe_progress_(void *cls,
-                                 const struct GNUNET_FS_ProgressInfo *info)
+GNUNET_FS_search_probe_progress_ (void *cls,
+                                  const struct GNUNET_FS_ProgressInfo *info)
 {
   struct GNUNET_FS_SearchResult *sr = info->value.download.cctx;
   struct GNUNET_TIME_Relative dur;
 
   switch (info->status)
+  {
+  case GNUNET_FS_STATUS_DOWNLOAD_START:
+    /* ignore */
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
+    /* probes should never be resumed */
+    GNUNET_assert (0);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
+    /* probes should never be suspended */
+    GNUNET_break (0);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    /* ignore */
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+    if (NULL != sr->probe_cancel_task)
     {
-    case GNUNET_FS_STATUS_DOWNLOAD_START:
-      /* ignore */
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
-      /* probes should never be resumed */
-      GNUNET_assert(0);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
-      /* probes should never be suspended */
-      GNUNET_break(0);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
-      /* ignore */
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
-      if (NULL != sr->probe_cancel_task)
-        {
-          GNUNET_SCHEDULER_cancel(sr->probe_cancel_task);
-          sr->probe_cancel_task = NULL;
-        }
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = NULL;
+    }
+    sr->probe_cancel_task =
+      GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
+                                    &probe_failure_handler, sr);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    if (NULL != sr->probe_cancel_task)
+    {
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = NULL;
+    }
+    sr->probe_cancel_task =
+      GNUNET_SCHEDULER_add_now (&probe_success_handler, sr);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+    if (NULL != sr->probe_cancel_task)
+    {
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = NULL;
+    }
+    sr = NULL;
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+    if (NULL == sr->probe_cancel_task)
+    {
+      sr->probe_active_time = GNUNET_TIME_absolute_get ();
       sr->probe_cancel_task =
-        GNUNET_SCHEDULER_add_delayed(sr->remaining_probe_time,
-                                     &probe_failure_handler, sr);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      if (NULL != sr->probe_cancel_task)
-        {
-          GNUNET_SCHEDULER_cancel(sr->probe_cancel_task);
-          sr->probe_cancel_task = NULL;
-        }
+        GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
+                                      &probe_failure_handler, sr);
+    }
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+    if (NULL != sr->probe_cancel_task)
+    {
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = NULL;
+    }
+    dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
+    sr->remaining_probe_time =
+      GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur);
+    if (0 == sr->remaining_probe_time.rel_value_us)
       sr->probe_cancel_task =
-        GNUNET_SCHEDULER_add_now(&probe_success_handler, sr);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
-      if (NULL != sr->probe_cancel_task)
-        {
-          GNUNET_SCHEDULER_cancel(sr->probe_cancel_task);
-          sr->probe_cancel_task = NULL;
-        }
-      sr = NULL;
-      break;
+        GNUNET_SCHEDULER_add_now (&probe_failure_handler, sr);
+    GNUNET_FS_search_result_sync_ (sr);
+    break;
 
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-      if (NULL == sr->probe_cancel_task)
-        {
-          sr->probe_active_time = GNUNET_TIME_absolute_get();
-          sr->probe_cancel_task =
-            GNUNET_SCHEDULER_add_delayed(sr->remaining_probe_time,
-                                         &probe_failure_handler, sr);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
-      if (NULL != sr->probe_cancel_task)
-        {
-          GNUNET_SCHEDULER_cancel(sr->probe_cancel_task);
-          sr->probe_cancel_task = NULL;
-        }
-      dur = GNUNET_TIME_absolute_get_duration(sr->probe_active_time);
-      sr->remaining_probe_time =
-        GNUNET_TIME_relative_subtract(sr->remaining_probe_time, dur);
-      if (0 == sr->remaining_probe_time.rel_value_us)
-        sr->probe_cancel_task =
-          GNUNET_SCHEDULER_add_now(&probe_failure_handler, sr);
-      GNUNET_FS_search_result_sync_(sr);
-      break;
-
-    default:
-      GNUNET_break(0);
-      return NULL;
-    }
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
   return sr;
 }
 
@@ -370,18 +364,19 @@ GNUNET_FS_search_probe_progress_(void *cls,
  * @param cls the `struct GNUNET_FS_SearchResult` that we are probing for
  */
 static void
-probe_ping_task_cb(void *cls)
+probe_ping_task_cb (void *cls)
 {
   struct GNUNET_FS_Handle *h = cls;
-  struct GNUNET_FS_SearchResult *sr;
 
-  for (sr = h->probes_head; NULL != sr; sr = sr->next)
+  for (struct GNUNET_FS_SearchResult *sr = h->probes_head;
+       NULL != sr;
+       sr = sr->next)
     if (NULL != sr->probe_ctx->mq)
-      signal_probe_result(sr);
+      signal_probe_result (sr);
   h->probe_ping_task
-    = GNUNET_SCHEDULER_add_delayed(GNUNET_FS_PROBE_UPDATE_FREQUENCY,
-                                   &probe_ping_task_cb,
-                                   h);
+    = GNUNET_SCHEDULER_add_delayed (GNUNET_FS_PROBE_UPDATE_FREQUENCY,
+                                    &probe_ping_task_cb,
+                                    h);
 }
 
 
@@ -391,17 +386,17 @@ probe_ping_task_cb(void *cls)
  * @param sr result to start pinging for.
  */
 static void
-start_probe_ping_task(struct GNUNET_FS_SearchResult *sr)
+start_probe_ping_task (struct GNUNET_FS_SearchResult *sr)
 {
   struct GNUNET_FS_Handle *h = sr->h;
 
-  GNUNET_CONTAINER_DLL_insert(h->probes_head,
-                              h->probes_tail,
-                              sr);
+  GNUNET_CONTAINER_DLL_insert (h->probes_head,
+                               h->probes_tail,
+                               sr);
   if (NULL == h->probe_ping_task)
     h->probe_ping_task
-      = GNUNET_SCHEDULER_add_now(&probe_ping_task_cb,
-                                 h);
+      = GNUNET_SCHEDULER_add_now (&probe_ping_task_cb,
+                                  h);
 }
 
 
@@ -411,18 +406,18 @@ start_probe_ping_task(struct GNUNET_FS_SearchResult *sr)
  * @param sr result to start pinging for.
  */
 void
-GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
+GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr)
 {
   struct GNUNET_FS_Handle *h = sr->h;
 
-  GNUNET_CONTAINER_DLL_remove(h->probes_head,
-                              h->probes_tail,
-                              sr);
+  GNUNET_CONTAINER_DLL_remove (h->probes_head,
+                               h->probes_tail,
+                               sr);
   if (NULL == h->probes_head)
-    {
-      GNUNET_SCHEDULER_cancel(h->probe_ping_task);
-      h->probe_ping_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (h->probe_ping_task);
+    h->probe_ping_task = NULL;
+  }
 }
 
 
@@ -432,7 +427,7 @@ GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
  * @param sr the search result
  */
 void
-GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
+GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
 {
   uint64_t off;
   uint64_t len;
@@ -445,35 +440,37 @@ GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
     return;
   if (sr->availability_trials > AVAILABILITY_TRIALS_MAX)
     return;
-  if ((GNUNET_FS_URI_CHK != sr->uri->type) && (GNUNET_FS_URI_LOC != sr->uri->type))
+  if ( (GNUNET_FS_URI_CHK != sr->uri->type) &&
+       (GNUNET_FS_URI_LOC != sr->uri->type) )
     return;
-  len = GNUNET_FS_uri_chk_get_file_size(sr->uri);
+  len = GNUNET_FS_uri_chk_get_file_size (sr->uri);
   if (0 == len)
     return;
   if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
     return;
   off = len / DBLOCK_SIZE;
   if (off > 0)
-    off = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, off);
+    off = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, off);
   off *= DBLOCK_SIZE;
   if (len - off < DBLOCK_SIZE)
     len = len - off;
   else
     len = DBLOCK_SIZE;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Starting probe #%u (at offset %llu) for search result %p\n",
-             sr->availability_trials + 1,
-             (unsigned long long)off,
-             sr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting probe #%u (at offset %llu) for search result %p\n",
+              sr->availability_trials + 1,
+              (unsigned long long) off,
+              sr);
   sr->remaining_probe_time =
-    GNUNET_TIME_relative_saturating_multiply(sr->h->avg_block_latency,
-                                             2 * (1 + sr->availability_trials));
+    GNUNET_TIME_relative_saturating_multiply (sr->h->avg_block_latency,
+                                              2 * (1
+                                                   + sr->availability_trials));
   sr->probe_ctx =
-    GNUNET_FS_download_start(sr->h, sr->uri, sr->meta, NULL, NULL, off,
-                             len, sr->anonymity,
-                             GNUNET_FS_DOWNLOAD_NO_TEMPORARIES |
-                             GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
-  start_probe_ping_task(sr);
+    GNUNET_FS_download_start (sr->h, sr->uri, sr->meta, NULL, NULL, off,
+                              len, sr->anonymity,
+                              GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
+                              | GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
+  start_probe_ping_task (sr);
 }
 
 
@@ -488,23 +485,23 @@ GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
  * @return the search result handle to access the probe activity
  */
 struct GNUNET_FS_SearchResult *
-GNUNET_FS_probe(struct GNUNET_FS_Handle *h,
-                const struct GNUNET_FS_Uri *uri,
-                const struct GNUNET_CONTAINER_MetaData *meta,
-                void *client_info,
-                uint32_t anonymity)
+GNUNET_FS_probe (struct GNUNET_FS_Handle *h,
+                 const struct GNUNET_FS_Uri *uri,
+                 const struct GNUNET_CONTAINER_MetaData *meta,
+                 void *client_info,
+                 uint32_t anonymity)
 {
   struct GNUNET_FS_SearchResult *sr;
 
-  GNUNET_assert(NULL != h);
-  GNUNET_assert(NULL != uri);
-  sr = GNUNET_new(struct GNUNET_FS_SearchResult);
+  GNUNET_assert (NULL != h);
+  GNUNET_assert (NULL != uri);
+  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
   sr->h = h;
-  sr->uri = GNUNET_FS_uri_dup(uri);
-  sr->meta = GNUNET_CONTAINER_meta_data_duplicate(meta);
+  sr->uri = GNUNET_FS_uri_dup (uri);
+  sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
   sr->client_info = client_info;
   sr->anonymity = anonymity;
-  GNUNET_FS_search_start_probe_(sr);
+  GNUNET_FS_search_start_probe_ (sr);
   return sr;
 }
 
@@ -515,19 +512,19 @@ GNUNET_FS_probe(struct GNUNET_FS_Handle *h,
  * @param sr search result
  */
 static void
-GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
+GNUNET_FS_search_stop_probe_ (struct GNUNET_FS_SearchResult *sr)
 {
   if (NULL != sr->probe_ctx)
-    {
-      GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES);
-      sr->probe_ctx = NULL;
-      GNUNET_FS_stop_probe_ping_task_(sr);
-    }
+  {
+    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
+    sr->probe_ctx = NULL;
+    GNUNET_FS_stop_probe_ping_task_ (sr);
+  }
   if (NULL != sr->probe_cancel_task)
-    {
-      GNUNET_SCHEDULER_cancel(sr->probe_cancel_task);
-      sr->probe_cancel_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+    sr->probe_cancel_task = NULL;
+  }
 }
 
 
@@ -539,16 +536,16 @@ GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
  * @return the value of the 'client_info' pointer
  */
 void *
-GNUNET_FS_probe_stop(struct GNUNET_FS_SearchResult *sr)
+GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr)
 {
   void *client_info;
 
-  GNUNET_assert(NULL == sr->sc);
-  GNUNET_FS_search_stop_probe_(sr);
-  GNUNET_FS_uri_destroy(sr->uri);
-  GNUNET_CONTAINER_meta_data_destroy(sr->meta);
+  GNUNET_assert (NULL == sr->sc);
+  GNUNET_FS_search_stop_probe_ (sr);
+  GNUNET_FS_uri_destroy (sr->uri);
+  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
   client_info = sr->client_info;
-  GNUNET_free(sr);
+  GNUNET_free (sr);
   return client_info;
 }
 
@@ -564,10 +561,10 @@ GNUNET_FS_probe_stop(struct GNUNET_FS_SearchResult *sr)
  *        under the @a ent keyword
  */
 static void
-process_ksk_result(struct GNUNET_FS_SearchContext *sc,
-                   struct SearchRequestEntry *ent,
-                   const struct GNUNET_FS_Uri *uri,
-                   const struct GNUNET_CONTAINER_MetaData *meta)
+process_ksk_result (struct GNUNET_FS_SearchContext *sc,
+                    struct SearchRequestEntry *ent,
+                    const struct GNUNET_FS_Uri *uri,
+                    const struct GNUNET_CONTAINER_MetaData *meta)
 {
   struct GNUNET_HashCode key;
   struct GNUNET_FS_SearchResult *sr;
@@ -576,80 +573,81 @@ process_ksk_result(struct GNUNET_FS_SearchContext *sc,
   unsigned int koff;
 
   /* check if new */
-  GNUNET_assert(NULL != sc);
+  GNUNET_assert (NULL != sc);
   if (GNUNET_OK !=
-      GNUNET_FS_uri_to_key(uri,
-                           &key))
-    {
-      GNUNET_break_op(0);
-      return;
-    }
+      GNUNET_FS_uri_to_key (uri,
+                            &key))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   if (GNUNET_SYSERR ==
-      GNUNET_CONTAINER_multihashmap_get_multiple(ent->results,
-                                                 &key,
-                                                 &test_result_present,
-                                                 (void *)uri))
+      GNUNET_CONTAINER_multihashmap_get_multiple (ent->results,
+                                                  &key,
+                                                  &test_result_present,
+                                                  (void *) uri))
     return;                     /* duplicate result */
   /* try to find search result in master map */
   grc.sr = NULL;
   grc.uri = uri;
-  GNUNET_CONTAINER_multihashmap_get_multiple(sc->master_result_map,
-                                             &key,
-                                             &get_result_present, &grc);
+  GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map,
+                                              &key,
+                                              &get_result_present, &grc);
   sr = grc.sr;
   is_new = (NULL == sr) || (sr->mandatory_missing > 0);
   if (NULL == sr)
-    {
-      sr = GNUNET_new(struct GNUNET_FS_SearchResult);
-      sr->h = sc->h;
-      sr->sc = sc;
-      sr->anonymity = sc->anonymity;
-      sr->uri = GNUNET_FS_uri_dup(uri);
-      sr->meta = GNUNET_CONTAINER_meta_data_duplicate(meta);
-      sr->mandatory_missing = sc->mandatory_count;
-      sr->key = key;
-      sr->keyword_bitmap = GNUNET_malloc((sc->uri->data.ksk.keywordCount + 7) / 8); /* round up, count bits */
-      GNUNET_CONTAINER_multihashmap_put(sc->master_result_map, &key, sr,
-                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-    }
+  {
+    sr = GNUNET_new (struct GNUNET_FS_SearchResult);
+    sr->h = sc->h;
+    sr->sc = sc;
+    sr->anonymity = sc->anonymity;
+    sr->uri = GNUNET_FS_uri_dup (uri);
+    sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+    sr->mandatory_missing = sc->mandatory_count;
+    sr->key = key;
+    sr->keyword_bitmap = GNUNET_malloc ((sc->uri->data.ksk.keywordCount + 7)
+                                        / 8);                                       /* round up, count bits */
+    GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  }
   else
-    {
-      GNUNET_CONTAINER_meta_data_merge(sr->meta, meta);
-    }
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_CONTAINER_multihashmap_put(ent->results,
-                                                 &sr->key,
-                                                 sr,
-                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  {
+    GNUNET_CONTAINER_meta_data_merge (sr->meta, meta);
+  }
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap_put (ent->results,
+                                                   &sr->key,
+                                                   sr,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
 
   koff = ent - sc->requests;
-  GNUNET_assert((ent >= sc->requests) &&
-                (koff < sc->uri->data.ksk.keywordCount));
+  GNUNET_assert ((ent >= sc->requests) &&
+                 (koff < sc->uri->data.ksk.keywordCount));
   sr->keyword_bitmap[koff / 8] |= (1 << (koff % 8));
   /* check if mandatory satisfied */
-  if (1 <= GNUNET_CONTAINER_multihashmap_size(ent->results))
+  if (1 <= GNUNET_CONTAINER_multihashmap_size (ent->results))
+  {
+    if (ent->mandatory)
     {
-      if (ent->mandatory)
-        {
-          GNUNET_break(sr->mandatory_missing > 0);
-          sr->mandatory_missing--;
-        }
-      else
-        {
-          sr->optional_support++;
-        }
+      GNUNET_break (sr->mandatory_missing > 0);
+      sr->mandatory_missing--;
     }
-  if (0 != sr->mandatory_missing)
+    else
     {
-      GNUNET_break(NULL == sr->client_info);
-      return;
+      sr->optional_support++;
     }
+  }
+  if (0 != sr->mandatory_missing)
+  {
+    GNUNET_break (NULL == sr->client_info);
+    return;
+  }
   if (is_new)
-    notify_client_chk_result(sc, sr);
+    notify_client_chk_result (sc, sr);
   else
-    notify_client_chk_update(sc, sr);
-  GNUNET_FS_search_result_sync_(sr);
-  GNUNET_FS_search_start_probe_(sr);
+    notify_client_chk_update (sc, sr);
+  GNUNET_FS_search_result_sync_ (sr);
+  GNUNET_FS_search_start_probe_ (sr);
 }
 
 
@@ -666,12 +664,12 @@ process_ksk_result(struct GNUNET_FS_SearchContext *sc,
  * @return context that can be used to control the search
  */
 static struct GNUNET_FS_SearchContext *
-search_start(struct GNUNET_FS_Handle *h,
-             const struct GNUNET_FS_Uri *uri,
-             uint32_t anonymity,
-             enum GNUNET_FS_SearchOptions options,
-             void *cctx,
-             struct GNUNET_FS_SearchResult *psearch);
+search_start (struct GNUNET_FS_Handle *h,
+              const struct GNUNET_FS_Uri *uri,
+              uint32_t anonymity,
+              enum GNUNET_FS_SearchOptions options,
+              void *cctx,
+              struct GNUNET_FS_SearchResult *psearch);
 
 
 /**
@@ -684,56 +682,56 @@ search_start(struct GNUNET_FS_Handle *h,
  * @param meta metadata associated with the URI
  */
 static void
-process_sks_result(struct GNUNET_FS_SearchContext *sc,
-                   const char *id_update,
-                   const struct GNUNET_FS_Uri *uri,
-                   const struct GNUNET_CONTAINER_MetaData *meta)
+process_sks_result (struct GNUNET_FS_SearchContext *sc,
+                    const char *id_update,
+                    const struct GNUNET_FS_Uri *uri,
+                    const struct GNUNET_CONTAINER_MetaData *meta)
 {
   struct GNUNET_FS_Uri uu;
   struct GNUNET_HashCode key;
   struct GNUNET_FS_SearchResult *sr;
 
   /* check if new */
-  GNUNET_assert(NULL != sc);
+  GNUNET_assert (NULL != sc);
   if (GNUNET_OK !=
-      GNUNET_FS_uri_to_key(uri,
-                           &key))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_CRYPTO_hash_xor(&uri->data.chk.chk.key,
-                         &uri->data.chk.chk.query,
-                         &key);
+      GNUNET_FS_uri_to_key (uri,
+                            &key))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key,
+                          &uri->data.chk.chk.query,
+                          &key);
   if (GNUNET_SYSERR ==
-      GNUNET_CONTAINER_multihashmap_get_multiple(sc->master_result_map, &key,
-                                                 &test_result_present,
-                                                 (void *)uri))
+      GNUNET_CONTAINER_multihashmap_get_multiple (sc->master_result_map, &key,
+                                                  &test_result_present,
+                                                  (void *) uri))
     return;                     /* duplicate result */
-  sr = GNUNET_new(struct GNUNET_FS_SearchResult);
+  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
   sr->h = sc->h;
   sr->sc = sc;
   sr->anonymity = sc->anonymity;
-  sr->uri = GNUNET_FS_uri_dup(uri);
-  sr->meta = GNUNET_CONTAINER_meta_data_duplicate(meta);
+  sr->uri = GNUNET_FS_uri_dup (uri);
+  sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
   sr->key = key;
-  GNUNET_CONTAINER_multihashmap_put(sc->master_result_map, &key, sr,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-  GNUNET_FS_search_result_sync_(sr);
-  GNUNET_FS_search_start_probe_(sr);
+  GNUNET_CONTAINER_multihashmap_put (sc->master_result_map, &key, sr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  GNUNET_FS_search_result_sync_ (sr);
+  GNUNET_FS_search_start_probe_ (sr);
   /* notify client */
   if (0 == sr->mandatory_missing)
-    notify_client_chk_result(sc, sr);
+    notify_client_chk_result (sc, sr);
   else
-    GNUNET_break(NULL == sr->client_info);
+    GNUNET_break (NULL == sr->client_info);
   /* search for updates */
-  if (0 == strlen(id_update))
+  if (0 == strlen (id_update))
     return;                     /* no updates */
   uu.type = GNUNET_FS_URI_SKS;
   uu.data.sks.ns = sc->uri->data.sks.ns;
-  uu.data.sks.identifier = GNUNET_strdup(id_update);
-  (void)search_start(sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
-  GNUNET_free(uu.data.sks.identifier);
+  uu.data.sks.identifier = GNUNET_strdup (id_update);
+  (void) search_start (sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
+  GNUNET_free (uu.data.sks.identifier);
 }
 
 
@@ -752,11 +750,11 @@ process_sks_result(struct GNUNET_FS_SearchContext *sc,
  *         keyword, internal error)
  */
 static int
-decrypt_block_with_keyword(const struct GNUNET_FS_SearchContext *sc,
-                           const struct GNUNET_CRYPTO_EcdsaPublicKey *dpub,
-                           const void *edata,
-                           size_t edata_size,
-                           char *data)
+decrypt_block_with_keyword (const struct GNUNET_FS_SearchContext *sc,
+                            const struct GNUNET_CRYPTO_EcdsaPublicKey *dpub,
+                            const void *edata,
+                            size_t edata_size,
+                            char *data)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
   struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
@@ -764,23 +762,23 @@ decrypt_block_with_keyword(const struct GNUNET_FS_SearchContext *sc,
 
   /* find key */
   for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
-    if (0 == memcmp(dpub,
-                    &sc->requests[i].dpub,
-                    sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
+    if (0 == memcmp (dpub,
+                     &sc->requests[i].dpub,
+                     sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)))
       break;
   if (i == sc->uri->data.ksk.keywordCount)
-    {
-      /* oops, does not match any of our keywords!? */
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    /* oops, does not match any of our keywords!? */
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   /* decrypt */
-  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous();
-  GNUNET_CRYPTO_ecdsa_key_get_public(anon, &anon_pub);
-  GNUNET_FS_ublock_decrypt_(edata, edata_size,
-                            &anon_pub,
-                            sc->requests[i].keyword,
-                            data);
+  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
+  GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
+  GNUNET_FS_ublock_decrypt_ (edata, edata_size,
+                             &anon_pub,
+                             sc->requests[i].keyword,
+                             data);
   return i;
 }
 
@@ -795,9 +793,9 @@ decrypt_block_with_keyword(const struct GNUNET_FS_SearchContext *sc,
  * @param size size of @a ub
  */
 static void
-process_kblock(struct GNUNET_FS_SearchContext *sc,
-               const struct UBlock *ub,
-               size_t size)
+process_kblock (struct GNUNET_FS_SearchContext *sc,
+                const struct UBlock *ub,
+                size_t size)
 {
   size_t j;
   char pt[size - sizeof(struct UBlock)];
@@ -807,53 +805,53 @@ process_kblock(struct GNUNET_FS_SearchContext *sc,
   char *emsg;
   int i;
 
-  if (-1 == (i = decrypt_block_with_keyword(sc,
-                                            &ub->verification_key,
-                                            &ub[1],
-                                            size - sizeof(struct UBlock),
-                                            pt)))
+  if (-1 == (i = decrypt_block_with_keyword (sc,
+                                             &ub->verification_key,
+                                             &ub[1],
+                                             size - sizeof(struct UBlock),
+                                             pt)))
     return;
   /* parse; pt[0] is just '\0', so we skip over that */
-  eos = memchr(&pt[1], '\0', sizeof(pt) - 1);
+  eos = memchr (&pt[1], '\0', sizeof(pt) - 1);
   if (NULL == eos)
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  if (NULL == (uri = GNUNET_FS_uri_parse (&pt[1], &emsg)))
+  {
+    if (GNUNET_FS_VERSION > 0x00090400)
     {
-      GNUNET_break_op(0);
-      return;
-    }
-  if (NULL == (uri = GNUNET_FS_uri_parse(&pt[1], &emsg)))
-    {
-      if (GNUNET_FS_VERSION > 0x00090400)
-        {
-          /* we broke this in 0x00090300, so don't bitch
-             too loudly just one version up... */
-          GNUNET_break_op(0);     /* ublock malformed */
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     _("Failed to parse URI `%s': %s\n"),
-                     &pt[1],
-                     emsg);
-        }
-      GNUNET_free_non_null(emsg);
-      return;
+      /* we broke this in 0x00090300, so don't bitch
+         too loudly just one version up... */
+      GNUNET_break_op (0);        /* ublock malformed */
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Failed to parse URI `%s': %s\n"),
+                  &pt[1],
+                  emsg);
     }
+    GNUNET_free_non_null (emsg);
+    return;
+  }
   j = eos - pt + 1;
   if (sizeof(pt) == j)
-    meta = GNUNET_CONTAINER_meta_data_create();
+    meta = GNUNET_CONTAINER_meta_data_create ();
   else
-    meta = GNUNET_CONTAINER_meta_data_deserialize(&pt[j], sizeof(pt) - j);
+    meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[j], sizeof(pt) - j);
   if (NULL == meta)
-    {
-      GNUNET_break_op(0);       /* ublock malformed */
-      GNUNET_FS_uri_destroy(uri);
-      return;
-    }
-  process_ksk_result(sc,
-                     &sc->requests[i],
-                     uri,
-                     meta);
+  {
+    GNUNET_break_op (0);        /* ublock malformed */
+    GNUNET_FS_uri_destroy (uri);
+    return;
+  }
+  process_ksk_result (sc,
+                      &sc->requests[i],
+                      uri,
+                      meta);
 
   /* clean up */
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_FS_uri_destroy(uri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_FS_uri_destroy (uri);
 }
 
 
@@ -867,9 +865,9 @@ process_kblock(struct GNUNET_FS_SearchContext *sc,
  * @param size size of @a ub
  */
 static void
-process_sblock(struct GNUNET_FS_SearchContext *sc,
-               const struct UBlock *ub,
-               size_t size)
+process_sblock (struct GNUNET_FS_SearchContext *sc,
+                const struct UBlock *ub,
+                size_t size)
 {
   size_t len = size - sizeof(struct UBlock);
   char pt[len];
@@ -880,36 +878,37 @@ process_sblock(struct GNUNET_FS_SearchContext *sc,
   size_t off;
   char *emsg;
 
-  GNUNET_FS_ublock_decrypt_(&ub[1], len,
-                            &sc->uri->data.sks.ns,
-                            sc->uri->data.sks.identifier,
-                            pt);
+  GNUNET_FS_ublock_decrypt_ (&ub[1], len,
+                             &sc->uri->data.sks.ns,
+                             sc->uri->data.sks.identifier,
+                             pt);
   /* parse */
-  if (0 == (off = GNUNET_STRINGS_buffer_tokenize(pt, len, 2, &id, &uris)))
-    {
-      GNUNET_break_op(0);       /* ublock malformed */
-      return;
-    }
-  if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize(&pt[off], len - off)))
-    {
-      GNUNET_break_op(0);       /* ublock malformed */
-      return;
-    }
-  if (NULL == (uri = GNUNET_FS_uri_parse(uris, &emsg)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to parse URI `%s': %s\n"),
-                 uris, emsg);
-      GNUNET_break_op(0);       /* ublock malformed */
-      GNUNET_free_non_null(emsg);
-      GNUNET_CONTAINER_meta_data_destroy(meta);
-      return;
-    }
+  if (0 == (off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris)))
+  {
+    GNUNET_break_op (0);        /* ublock malformed */
+    return;
+  }
+  if (NULL == (meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[off], len
+                                                              - off)))
+  {
+    GNUNET_break_op (0);        /* ublock malformed */
+    return;
+  }
+  if (NULL == (uri = GNUNET_FS_uri_parse (uris, &emsg)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to parse URI `%s': %s\n"),
+                uris, emsg);
+    GNUNET_break_op (0);        /* ublock malformed */
+    GNUNET_free_non_null (emsg);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    return;
+  }
   /* process */
-  process_sks_result(sc, id, uri, meta);
+  process_sks_result (sc, id, uri, meta);
   /* clean up */
-  GNUNET_FS_uri_destroy(uri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
+  GNUNET_FS_uri_destroy (uri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
 }
 
 
@@ -921,7 +920,7 @@ process_sblock(struct GNUNET_FS_SearchContext *sc,
  * @param sc the search to reconnec
  */
 static void
-try_reconnect(struct GNUNET_FS_SearchContext *sc);
+try_reconnect (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -931,8 +930,8 @@ try_reconnect(struct GNUNET_FS_SearchContext *sc);
  * @param msg result message received
  */
 static int
-check_result(void *cls,
-             const struct ClientPutMessage *cm)
+check_result (void *cls,
+              const struct ClientPutMessage *cm)
 {
   /* payload of any variable size is OK */
   return GNUNET_OK;
@@ -946,54 +945,55 @@ check_result(void *cls,
  * @param msg result message received
  */
 static void
-handle_result(void *cls,
-              const struct ClientPutMessage *cm)
+handle_result (void *cls,
+               const struct ClientPutMessage *cm)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
-  uint16_t msize = ntohs(cm->header.size) - sizeof(*cm);
-  enum GNUNET_BLOCK_Type type = ntohl(cm->type);
-
-  if (GNUNET_TIME_absolute_get_duration(GNUNET_TIME_absolute_ntoh(cm->expiration)).rel_value_us > 0)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Result received has already expired.\n");
-      return;                   /* result expired */
-    }
+  uint16_t msize = ntohs (cm->header.size) - sizeof(*cm);
+  enum GNUNET_BLOCK_Type type = ntohl (cm->type);
+
+  if (GNUNET_TIME_absolute_get_duration (GNUNET_TIME_absolute_ntoh (
+                                           cm->expiration)).rel_value_us > 0)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Result received has already expired.\n");
+    return;                     /* result expired */
+  }
   switch (type)
-    {
-    case GNUNET_BLOCK_TYPE_FS_UBLOCK:
-      if (GNUNET_FS_URI_SKS == sc->uri->type)
-        process_sblock(sc,
-                       (const struct UBlock *)&cm[1],
-                       msize);
-      else
-        process_kblock(sc,
-                       (const struct UBlock *)&cm[1],
-                       msize);
-      break;
-
-    case GNUNET_BLOCK_TYPE_ANY:
-      GNUNET_break(0);
-      break;
-
-    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
-      GNUNET_break(0);
-      break;
-
-    case GNUNET_BLOCK_TYPE_FS_ONDEMAND:
-      GNUNET_break(0);
-      break;
-
-    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
-      GNUNET_break(0);
-      break;
-
-    default:
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Got result with unknown block type `%d', ignoring"),
-                 type);
-      break;
-    }
+  {
+  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
+    if (GNUNET_FS_URI_SKS == sc->uri->type)
+      process_sblock (sc,
+                      (const struct UBlock *) &cm[1],
+                      msize);
+    else
+      process_kblock (sc,
+                      (const struct UBlock *) &cm[1],
+                      msize);
+    break;
+
+  case GNUNET_BLOCK_TYPE_ANY:
+    GNUNET_break (0);
+    break;
+
+  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
+    GNUNET_break (0);
+    break;
+
+  case GNUNET_BLOCK_TYPE_FS_ONDEMAND:
+    GNUNET_break (0);
+    break;
+
+  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
+    GNUNET_break (0);
+    break;
+
+  default:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Got result with unknown block type `%d', ignoring"),
+                type);
+    break;
+  }
 }
 
 
@@ -1004,13 +1004,14 @@ handle_result(void *cls,
  * @param sc context for the search
  */
 static void
-schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc);
+schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
  * Closure for #build_result_set().
  */
-struct MessageBuilderContext {
+struct MessageBuilderContext
+{
   /**
    * How many entries can we store to xoff.
    */
@@ -1048,21 +1049,24 @@ struct MessageBuilderContext {
  * @return #GNUNET_OK to continue iterating
  */
 static int
-build_result_set(void *cls,
-                 const struct GNUNET_HashCode *key,
-                 void *value)
+build_result_set (void *cls,
+                  const struct GNUNET_HashCode *key,
+                  void *value)
 {
   struct MessageBuilderContext *mbc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
 
   if ((NULL != sr->keyword_bitmap) &&
-      (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))))
+      (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1
+                                                            << (mbc->
+                                                                keyword_offset
+                                                                % 8)))))
     return GNUNET_OK; /* have no match for this keyword yet */
   if (mbc->skip_cnt > 0)
-    {
-      mbc->skip_cnt--;
-      return GNUNET_OK;
-    }
+  {
+    mbc->skip_cnt--;
+    return GNUNET_OK;
+  }
   if (0 == mbc->put_cnt)
     return GNUNET_SYSERR;
   mbc->xoff[--mbc->put_cnt] = *key;
@@ -1081,15 +1085,18 @@ build_result_set(void *cls,
  * @return #GNUNET_OK to continue iterating
  */
 static int
-find_result_set(void *cls,
-                const struct GNUNET_HashCode *key,
-                void *value)
+find_result_set (void *cls,
+                 const struct GNUNET_HashCode *key,
+                 void *value)
 {
   struct MessageBuilderContext *mbc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
 
   if ((NULL != sr->keyword_bitmap) &&
-      (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1 << (mbc->keyword_offset % 8)))))
+      (0 == (sr->keyword_bitmap[mbc->keyword_offset / 8] & (1
+                                                            << (mbc->
+                                                                keyword_offset
+                                                                % 8)))))
     return GNUNET_OK; /* have no match for this keyword yet */
   mbc->put_cnt++;
   return GNUNET_OK;
@@ -1103,7 +1110,7 @@ find_result_set(void *cls,
  * @param sc context for the search
  */
 static void
-schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc)
+schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
 {
   struct MessageBuilderContext mbc;
   struct GNUNET_MQ_Envelope *env;
@@ -1118,115 +1125,116 @@ schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc)
   unsigned int keyword_offset;
   int first_call;
 
-  memset(&mbc, 0, sizeof(mbc));
+  memset (&mbc, 0, sizeof(mbc));
   mbc.sc = sc;
-  if (GNUNET_FS_uri_test_ksk(sc->uri))
-    {
-      /* This will calculate the result set size ONLY for
-         "keyword_offset == 0", so we will have to recalculate
-         it for the other keywords later! */
-      GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                            &find_result_set,
-                                            &mbc);
-      total_seen_results = mbc.put_cnt;
-    }
+  if (GNUNET_FS_uri_test_ksk (sc->uri))
+  {
+    /* This will calculate the result set size ONLY for
+       "keyword_offset == 0", so we will have to recalculate
+       it for the other keywords later! */
+    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                           &find_result_set,
+                                           &mbc);
+    total_seen_results = mbc.put_cnt;
+  }
   else
-    {
-      total_seen_results
-        = GNUNET_CONTAINER_multihashmap_size(sc->master_result_map);
-    }
+  {
+    total_seen_results
+      = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
+  }
   search_request_map_offset = 0;
   keyword_offset = 0;
   first_call = GNUNET_YES;
   while ((0 != (left =
                   (total_seen_results - search_request_map_offset))) ||
          (GNUNET_YES == first_call))
+  {
+    first_call = GNUNET_NO;
+    options = SEARCH_MESSAGE_OPTION_NONE;
+    if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
+      options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY;
+
+    fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct
+                                                               GNUNET_HashCode);
+    todo = GNUNET_MIN (fit,
+                       left);
+    env = GNUNET_MQ_msg_extra (sm,
+                               sizeof(struct GNUNET_HashCode) * todo,
+                               GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
+    mbc.skip_cnt = search_request_map_offset;
+    mbc.xoff = (struct GNUNET_HashCode *) &sm[1];
+    sm->type = htonl (GNUNET_BLOCK_TYPE_FS_UBLOCK);
+    sm->anonymity_level = htonl (sc->anonymity);
+    memset (&sm->target,
+            0,
+            sizeof(struct GNUNET_PeerIdentity));
+
+    if (GNUNET_FS_uri_test_ksk (sc->uri))
     {
-      first_call = GNUNET_NO;
-      options = SEARCH_MESSAGE_OPTION_NONE;
-      if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
-        options |= SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY;
-
-      fit = (GNUNET_MAX_MESSAGE_SIZE - 1 - sizeof(*sm)) / sizeof(struct GNUNET_HashCode);
-      todo = GNUNET_MIN(fit,
-                        left);
-      env = GNUNET_MQ_msg_extra(sm,
-                                sizeof(struct GNUNET_HashCode) * todo,
-                                GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
-      mbc.skip_cnt = search_request_map_offset;
-      mbc.xoff = (struct GNUNET_HashCode *)&sm[1];
-      sm->type = htonl(GNUNET_BLOCK_TYPE_FS_UBLOCK);
-      sm->anonymity_level = htonl(sc->anonymity);
-      memset(&sm->target,
-             0,
-             sizeof(struct GNUNET_PeerIdentity));
-
-      if (GNUNET_FS_uri_test_ksk(sc->uri))
+      mbc.keyword_offset = keyword_offset;
+      /* calculate how many results we can send in this message */
+      mbc.put_cnt = todo;
+      /* now build message */
+      sm->query = sc->requests[keyword_offset].uquery;
+      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                             &build_result_set,
+                                             &mbc);
+      search_request_map_offset += todo;
+      GNUNET_assert (0 == mbc.put_cnt);
+      GNUNET_assert (total_seen_results >= search_request_map_offset);
+      if (total_seen_results != search_request_map_offset)
+      {
+        /* more requesting to be done... */
+        sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
+      }
+      else
+      {
+        sm->options = htonl (options);
+        keyword_offset++;
+        if (sc->uri->data.ksk.keywordCount != keyword_offset)
         {
+          /* more keywords => more requesting to be done... */
+          first_call = GNUNET_YES;
+          search_request_map_offset = 0;
+          mbc.put_cnt = 0;
           mbc.keyword_offset = keyword_offset;
-          /* calculate how many results we can send in this message */
-          mbc.put_cnt = todo;
-          /* now build message */
-          sm->query = sc->requests[keyword_offset].uquery;
-          GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                                &build_result_set,
-                                                &mbc);
-          search_request_map_offset += todo;
-          GNUNET_assert(0 == mbc.put_cnt);
-          GNUNET_assert(total_seen_results >= search_request_map_offset);
-          if (total_seen_results != search_request_map_offset)
-            {
-              /* more requesting to be done... */
-              sm->options = htonl(options | SEARCH_MESSAGE_OPTION_CONTINUED);
-            }
-          else
-            {
-              sm->options = htonl(options);
-              keyword_offset++;
-              if (sc->uri->data.ksk.keywordCount != keyword_offset)
-                {
-                  /* more keywords => more requesting to be done... */
-                  first_call = GNUNET_YES;
-                  search_request_map_offset = 0;
-                  mbc.put_cnt = 0;
-                  mbc.keyword_offset = keyword_offset;
-                  GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                                        &find_result_set,
-                                                        &mbc);
-                  total_seen_results = mbc.put_cnt;
-                }
-            }
+          GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                                 &find_result_set,
+                                                 &mbc);
+          total_seen_results = mbc.put_cnt;
         }
+      }
+    }
+    else
+    {
+      GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri));
+
+      GNUNET_CRYPTO_ecdsa_public_key_derive (&sc->uri->data.sks.ns,
+                                             sc->uri->data.sks.identifier,
+                                             "fs-ublock",
+                                             &dpub);
+      GNUNET_CRYPTO_hash (&dpub,
+                          sizeof(dpub),
+                          &sm->query);
+      mbc.put_cnt = todo;
+      mbc.keyword_offset = 0;
+      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                             &build_result_set,
+                                             &mbc);
+      GNUNET_assert (total_seen_results >= search_request_map_offset);
+      if (total_seen_results != search_request_map_offset)
+      {
+        /* more requesting to be done... */
+        sm->options = htonl (options | SEARCH_MESSAGE_OPTION_CONTINUED);
+      }
       else
-        {
-          GNUNET_assert(GNUNET_FS_uri_test_sks(sc->uri));
-
-          GNUNET_CRYPTO_ecdsa_public_key_derive(&sc->uri->data.sks.ns,
-                                                sc->uri->data.sks.identifier,
-                                                "fs-ublock",
-                                                &dpub);
-          GNUNET_CRYPTO_hash(&dpub,
-                             sizeof(dpub),
-                             &sm->query);
-          mbc.put_cnt = todo;
-          mbc.keyword_offset = 0;
-          GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                                &build_result_set,
-                                                &mbc);
-          GNUNET_assert(total_seen_results >= search_request_map_offset);
-          if (total_seen_results != search_request_map_offset)
-            {
-              /* more requesting to be done... */
-              sm->options = htonl(options | SEARCH_MESSAGE_OPTION_CONTINUED);
-            }
-          else
-            {
-              sm->options = htonl(options);
-            }
-        }
-      GNUNET_MQ_send(sc->mq,
-                     env);
+      {
+        sm->options = htonl (options);
+      }
     }
+    GNUNET_MQ_send (sc->mq,
+                    env);
+  }
 }
 
 
@@ -1239,17 +1247,17 @@ schedule_transmit_search_request(struct GNUNET_FS_SearchContext *sc)
  * @param error error code
  */
 static void
-search_mq_error_handler(void *cls,
-                        enum GNUNET_MQ_Error error)
+search_mq_error_handler (void *cls,
+                         enum GNUNET_MQ_Error error)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
 
   if (NULL != sc->mq)
-    {
-      GNUNET_MQ_destroy(sc->mq);
-      sc->mq = NULL;
-    }
-  try_reconnect(sc);
+  {
+    GNUNET_MQ_destroy (sc->mq);
+    sc->mq = NULL;
+  }
+  try_reconnect (sc);
 }
 
 
@@ -1260,29 +1268,29 @@ search_mq_error_handler(void *cls,
  * @param cls our search context
  */
 static void
-do_reconnect(void *cls)
+do_reconnect (void *cls)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_var_size(result,
-                          GNUNET_MESSAGE_TYPE_FS_PUT,
-                          struct ClientPutMessage,
-                          sc),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (result,
+                           GNUNET_MESSAGE_TYPE_FS_PUT,
+                           struct ClientPutMessage,
+                           sc),
+    GNUNET_MQ_handler_end ()
   };
 
   sc->task = NULL;
-  sc->mq = GNUNET_CLIENT_connect(sc->h->cfg,
-                                 "fs",
-                                 handlers,
-                                 &search_mq_error_handler,
-                                 sc);
+  sc->mq = GNUNET_CLIENT_connect (sc->h->cfg,
+                                  "fs",
+                                  handlers,
+                                  &search_mq_error_handler,
+                                  sc);
   if (NULL == sc->mq)
-    {
-      try_reconnect(sc);
-      return;
-    }
-  schedule_transmit_search_request(sc);
+  {
+    try_reconnect (sc);
+    return;
+  }
+  schedule_transmit_search_request (sc);
 }
 
 
@@ -1294,18 +1302,18 @@ do_reconnect(void *cls)
  * @param sc the search to reconnec
  */
 static void
-try_reconnect(struct GNUNET_FS_SearchContext *sc)
+try_reconnect (struct GNUNET_FS_SearchContext *sc)
 {
   if (NULL != sc->mq)
-    {
-      GNUNET_MQ_destroy(sc->mq);
-      sc->mq = NULL;
-    }
-  sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF(sc->reconnect_backoff);
+  {
+    GNUNET_MQ_destroy (sc->mq);
+    sc->mq = NULL;
+  }
+  sc->reconnect_backoff = GNUNET_TIME_STD_BACKOFF (sc->reconnect_backoff);
   sc->task =
-    GNUNET_SCHEDULER_add_delayed(sc->reconnect_backoff,
-                                 &do_reconnect,
-                                 sc);
+    GNUNET_SCHEDULER_add_delayed (sc->reconnect_backoff,
+                                  &do_reconnect,
+                                  sc);
 }
 
 
@@ -1322,39 +1330,39 @@ try_reconnect(struct GNUNET_FS_SearchContext *sc)
  * @return context that can be used to control the search
  */
 static struct GNUNET_FS_SearchContext *
-search_start(struct GNUNET_FS_Handle *h,
-             const struct GNUNET_FS_Uri *uri,
-             uint32_t anonymity,
-             enum GNUNET_FS_SearchOptions options,
-             void *cctx,
-             struct GNUNET_FS_SearchResult *psearch)
+search_start (struct GNUNET_FS_Handle *h,
+              const struct GNUNET_FS_Uri *uri,
+              uint32_t anonymity,
+              enum GNUNET_FS_SearchOptions options,
+              void *cctx,
+              struct GNUNET_FS_SearchResult *psearch)
 {
   struct GNUNET_FS_SearchContext *sc;
   struct GNUNET_FS_ProgressInfo pi;
 
-  sc = GNUNET_new(struct GNUNET_FS_SearchContext);
+  sc = GNUNET_new (struct GNUNET_FS_SearchContext);
   sc->h = h;
   sc->options = options;
-  sc->uri = GNUNET_FS_uri_dup(uri);
+  sc->uri = GNUNET_FS_uri_dup (uri);
   sc->anonymity = anonymity;
-  sc->start_time = GNUNET_TIME_absolute_get();
+  sc->start_time = GNUNET_TIME_absolute_get ();
   if (NULL != psearch)
-    {
-      sc->psearch_result = psearch;
-      psearch->update_search = sc;
-    }
-  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create(16, GNUNET_NO);
+  {
+    sc->psearch_result = psearch;
+    psearch->update_search = sc;
+  }
+  sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_NO);
   sc->client_info = cctx;
-  if (GNUNET_OK != GNUNET_FS_search_start_searching_(sc))
-    {
-      GNUNET_FS_uri_destroy(sc->uri);
-      GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map);
-      GNUNET_free(sc);
-      return NULL;
-    }
-  GNUNET_FS_search_sync_(sc);
+  if (GNUNET_OK != GNUNET_FS_search_start_searching_ (sc))
+  {
+    GNUNET_FS_uri_destroy (sc->uri);
+    GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
+    GNUNET_free (sc);
+    return NULL;
+  }
+  GNUNET_FS_search_sync_ (sc);
   pi.status = GNUNET_FS_STATUS_SEARCH_START;
-  sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
+  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
   return sc;
 }
 
@@ -1369,22 +1377,22 @@ search_start(struct GNUNET_FS_Handle *h,
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-update_sre_result_maps(void *cls,
-                       const struct GNUNET_HashCode *key,
-                       void *value)
+update_sre_result_maps (void *cls,
+                        const struct GNUNET_HashCode *key,
+                        void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
-  unsigned int i;
 
-  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
+  for (unsigned int i = 0; i < sc->uri->data.ksk.keywordCount; i++)
+  {
     if (0 != (sr->keyword_bitmap[i / 8] & (1 << (i % 8))))
-      GNUNET_break(GNUNET_OK ==
-                   GNUNET_CONTAINER_multihashmap_put(sc->requests[i].results,
-                                                     &sr->key,
-                                                     sr,
-                                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-
+      GNUNET_break (GNUNET_OK ==
+                    GNUNET_CONTAINER_multihashmap_put (sc->requests[i].results,
+                                                       &sr->key,
+                                                       sr,
+                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
   return GNUNET_YES;
 }
 
@@ -1397,7 +1405,7 @@ update_sre_result_maps(void *cls,
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 int
-GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc)
+GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
 {
   unsigned int i;
   const char *keyword;
@@ -1405,45 +1413,45 @@ GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc)
   struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
   struct SearchRequestEntry *sre;
 
-  GNUNET_assert(NULL == sc->mq);
-  if (GNUNET_FS_uri_test_ksk(sc->uri))
+  GNUNET_assert (NULL == sc->mq);
+  if (GNUNET_FS_uri_test_ksk (sc->uri))
+  {
+    GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
+    anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
+    GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
+    sc->requests
+      = GNUNET_new_array (sc->uri->data.ksk.keywordCount,
+                          struct SearchRequestEntry);
+
+    for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
     {
-      GNUNET_assert(0 != sc->uri->data.ksk.keywordCount);
-      anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous();
-      GNUNET_CRYPTO_ecdsa_key_get_public(anon, &anon_pub);
-      sc->requests
-        = GNUNET_new_array(sc->uri->data.ksk.keywordCount,
-                           struct SearchRequestEntry);
-
-      for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
-        {
-          keyword = &sc->uri->data.ksk.keywords[i][1];
-          sre = &sc->requests[i];
-          sre->keyword = GNUNET_strdup(keyword);
-          GNUNET_CRYPTO_ecdsa_public_key_derive(&anon_pub,
-                                                keyword,
-                                                "fs-ublock",
-                                                &sre->dpub);
-          GNUNET_CRYPTO_hash(&sre->dpub,
-                             sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
-                             &sre->uquery);
-          sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
-          if (sre->mandatory)
-            sc->mandatory_count++;
-          sre->results = GNUNET_CONTAINER_multihashmap_create(4, GNUNET_NO);
-        }
-      GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                            &update_sre_result_maps,
-                                            sc);
+      keyword = &sc->uri->data.ksk.keywords[i][1];
+      sre = &sc->requests[i];
+      sre->keyword = GNUNET_strdup (keyword);
+      GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub,
+                                             keyword,
+                                             "fs-ublock",
+                                             &sre->dpub);
+      GNUNET_CRYPTO_hash (&sre->dpub,
+                          sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
+                          &sre->uquery);
+      sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
+      if (sre->mandatory)
+        sc->mandatory_count++;
+      sre->results = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
     }
-  GNUNET_assert(NULL == sc->task);
-  do_reconnect(sc);
+    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                           &update_sre_result_maps,
+                                           sc);
+  }
+  GNUNET_assert (NULL == sc->task);
+  do_reconnect (sc);
   if (NULL == sc->mq)
-    {
-      GNUNET_SCHEDULER_cancel(sc->task);
-      sc->task = NULL;
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sc->task);
+    sc->task = NULL;
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -1457,25 +1465,25 @@ GNUNET_FS_search_start_searching_(struct GNUNET_FS_SearchContext *sc)
  * @return #GNUNET_OK
  */
 static int
-search_result_freeze_probes(void *cls,
-                            const struct GNUNET_HashCode *key,
-                            void *value)
+search_result_freeze_probes (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
   if (NULL != sr->probe_ctx)
-    {
-      GNUNET_FS_download_stop(sr->probe_ctx, GNUNET_YES);
-      sr->probe_ctx = NULL;
-      GNUNET_FS_stop_probe_ping_task_(sr);
-    }
+  {
+    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
+    sr->probe_ctx = NULL;
+    GNUNET_FS_stop_probe_ping_task_ (sr);
+  }
   if (NULL != sr->probe_cancel_task)
-    {
-      GNUNET_SCHEDULER_cancel(sr->probe_cancel_task);
-      sr->probe_cancel_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+    sr->probe_cancel_task = NULL;
+  }
   if (NULL != sr->update_search)
-    GNUNET_FS_search_pause(sr->update_search);
+    GNUNET_FS_search_pause (sr->update_search);
   return GNUNET_OK;
 }
 
@@ -1489,15 +1497,15 @@ search_result_freeze_probes(void *cls,
  * @return #GNUNET_OK
  */
 static int
-search_result_resume_probes(void *cls,
-                            const struct GNUNET_HashCode * key,
-                            void *value)
+search_result_resume_probes (void *cls,
+                             const struct GNUNET_HashCode *key,
+                             void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
-  GNUNET_FS_search_start_probe_(sr);
+  GNUNET_FS_search_start_probe_ (sr);
   if (NULL != sr->update_search)
-    GNUNET_FS_search_continue(sr->update_search);
+    GNUNET_FS_search_continue (sr->update_search);
   return GNUNET_OK;
 }
 
@@ -1511,40 +1519,40 @@ search_result_resume_probes(void *cls,
  * @return #GNUNET_OK
  */
 static int
-search_result_suspend(void *cls,
-                      const struct GNUNET_HashCode *key,
-                      void *value)
+search_result_suspend (void *cls,
+                       const struct GNUNET_HashCode *key,
+                       void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
   struct GNUNET_FS_ProgressInfo pi;
 
   if (NULL != sr->download)
-    {
-      GNUNET_FS_download_signal_suspend_(sr->download);
-      sr->download = NULL;
-    }
+  {
+    GNUNET_FS_download_signal_suspend_ (sr->download);
+    sr->download = NULL;
+  }
   if (NULL != sr->update_search)
-    {
-      GNUNET_FS_search_signal_suspend_(sr->update_search);
-      sr->update_search = NULL;
-    }
-  GNUNET_FS_search_stop_probe_(sr);
+  {
+    GNUNET_FS_search_signal_suspend_ (sr->update_search);
+    sr->update_search = NULL;
+  }
+  GNUNET_FS_search_stop_probe_ (sr);
   if (0 == sr->mandatory_missing)
-    {
-      /* client is aware of search result, notify about suspension event */
-      pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND;
-      pi.value.search.specifics.result_suspend.cctx = sr->client_info;
-      pi.value.search.specifics.result_suspend.meta = sr->meta;
-      pi.value.search.specifics.result_suspend.uri = sr->uri;
-      sr->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
-    }
-  GNUNET_break(NULL == sr->client_info);
-  GNUNET_free_non_null(sr->serialization);
-  GNUNET_FS_uri_destroy(sr->uri);
-  GNUNET_CONTAINER_meta_data_destroy(sr->meta);
-  GNUNET_free_non_null(sr->keyword_bitmap);
-  GNUNET_free(sr);
+  {
+    /* client is aware of search result, notify about suspension event */
+    pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND;
+    pi.value.search.specifics.result_suspend.cctx = sr->client_info;
+    pi.value.search.specifics.result_suspend.meta = sr->meta;
+    pi.value.search.specifics.result_suspend.uri = sr->uri;
+    sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
+  }
+  GNUNET_break (NULL == sr->client_info);
+  GNUNET_free_non_null (sr->serialization);
+  GNUNET_FS_uri_destroy (sr->uri);
+  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_free_non_null (sr->keyword_bitmap);
+  GNUNET_free (sr);
   return GNUNET_OK;
 }
 
@@ -1556,43 +1564,43 @@ search_result_suspend(void *cls,
  * @param cls the `struct GNUNET_FS_SearchContext` to signal for
  */
 void
-GNUNET_FS_search_signal_suspend_(void *cls)
+GNUNET_FS_search_signal_suspend_ (void *cls)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   unsigned int i;
 
-  GNUNET_FS_end_top(sc->h, sc->top);
-  GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                        &search_result_suspend, sc);
+  GNUNET_FS_end_top (sc->h, sc->top);
+  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                         &search_result_suspend, sc);
   pi.status = GNUNET_FS_STATUS_SEARCH_SUSPEND;
-  sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
-  GNUNET_break(NULL == sc->client_info);
+  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
+  GNUNET_break (NULL == sc->client_info);
   if (sc->task != NULL)
-    {
-      GNUNET_SCHEDULER_cancel(sc->task);
-      sc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sc->task);
+    sc->task = NULL;
+  }
   if (NULL != sc->mq)
-    {
-      GNUNET_MQ_destroy(sc->mq);
-      sc->mq = NULL;
-    }
-  GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map);
+  {
+    GNUNET_MQ_destroy (sc->mq);
+    sc->mq = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
   if (NULL != sc->requests)
+  {
+    GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
+    for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
     {
-      GNUNET_assert(GNUNET_FS_uri_test_ksk(sc->uri));
-      for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
-        {
-          GNUNET_CONTAINER_multihashmap_destroy(sc->requests[i].results);
-          GNUNET_free(sc->requests[i].keyword);
-        }
+      GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
+      GNUNET_free (sc->requests[i].keyword);
     }
-  GNUNET_free_non_null(sc->requests);
-  GNUNET_free_non_null(sc->emsg);
-  GNUNET_FS_uri_destroy(sc->uri);
-  GNUNET_free_non_null(sc->serialization);
-  GNUNET_free(sc);
+  }
+  GNUNET_free_non_null (sc->requests);
+  GNUNET_free_non_null (sc->emsg);
+  GNUNET_FS_uri_destroy (sc->uri);
+  GNUNET_free_non_null (sc->serialization);
+  GNUNET_free (sc);
 }
 
 
@@ -1608,16 +1616,16 @@ GNUNET_FS_search_signal_suspend_(void *cls)
  * @return context that can be used to control the search
  */
 struct GNUNET_FS_SearchContext *
-GNUNET_FS_search_start(struct GNUNET_FS_Handle *h,
-                       const struct GNUNET_FS_Uri *uri, uint32_t anonymity,
-                       enum GNUNET_FS_SearchOptions options, void *cctx)
+GNUNET_FS_search_start (struct GNUNET_FS_Handle *h,
+                        const struct GNUNET_FS_Uri *uri, uint32_t anonymity,
+                        enum GNUNET_FS_SearchOptions options, void *cctx)
 {
   struct GNUNET_FS_SearchContext *ret;
 
-  ret = search_start(h, uri, anonymity, options, cctx, NULL);
+  ret = search_start (h, uri, anonymity, options, cctx, NULL);
   if (NULL == ret)
     return NULL;
-  ret->top = GNUNET_FS_make_top(h, &GNUNET_FS_search_signal_suspend_, ret);
+  ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, ret);
   return ret;
 }
 
@@ -1628,28 +1636,28 @@ GNUNET_FS_search_start(struct GNUNET_FS_Handle *h,
  * @param sc context for the search that should be paused
  */
 void
-GNUNET_FS_search_pause(struct GNUNET_FS_SearchContext *sc)
+GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
   if (NULL != sc->task)
-    {
-      GNUNET_SCHEDULER_cancel(sc->task);
-      sc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sc->task);
+    sc->task = NULL;
+  }
   if (NULL != sc->mq)
-    {
-      GNUNET_MQ_destroy(sc->mq);
-      sc->mq = NULL;
-    }
-  GNUNET_FS_search_sync_(sc);
-  GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                        &search_result_freeze_probes,
-                                        sc);
+  {
+    GNUNET_MQ_destroy (sc->mq);
+    sc->mq = NULL;
+  }
+  GNUNET_FS_search_sync_ (sc);
+  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                         &search_result_freeze_probes,
+                                         sc);
   pi.status = GNUNET_FS_STATUS_SEARCH_PAUSED;
-  sc->client_info = GNUNET_FS_search_make_status_(&pi,
-                                                  sc->h,
-                                                  sc);
+  sc->client_info = GNUNET_FS_search_make_status_ (&pi,
+                                                   sc->h,
+                                                   sc);
 }
 
 
@@ -1659,18 +1667,18 @@ GNUNET_FS_search_pause(struct GNUNET_FS_SearchContext *sc)
  * @param sc context for the search that should be resumed
  */
 void
-GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc)
+GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
-  GNUNET_assert(NULL == sc->mq);
-  GNUNET_assert(NULL == sc->task);
-  do_reconnect(sc);
-  GNUNET_FS_search_sync_(sc);
+  GNUNET_assert (NULL == sc->mq);
+  GNUNET_assert (NULL == sc->task);
+  do_reconnect (sc);
+  GNUNET_FS_search_sync_ (sc);
   pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED;
-  sc->client_info = GNUNET_FS_search_make_status_(&pi, sc->h, sc);
-  GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                        &search_result_resume_probes, sc);
+  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
+  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                         &search_result_resume_probes, sc);
 }
 
 
@@ -1683,48 +1691,48 @@ GNUNET_FS_search_continue(struct GNUNET_FS_SearchContext *sc)
  * @return #GNUNET_OK
  */
 static int
-search_result_stop(void *cls,
-                   const struct GNUNET_HashCode *key,
-                   void *value)
+search_result_stop (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
   struct GNUNET_FS_ProgressInfo pi;
 
-  GNUNET_FS_search_stop_probe_(sr);
+  GNUNET_FS_search_stop_probe_ (sr);
   if (NULL != sr->download)
+  {
+    sr->download->search = NULL;
+    sr->download->top
+      = GNUNET_FS_make_top (sr->download->h,
+                            &GNUNET_FS_download_signal_suspend_,
+                            sr->download);
+    if (NULL != sr->download->serialization)
     {
-      sr->download->search = NULL;
-      sr->download->top
-        = GNUNET_FS_make_top(sr->download->h,
-                             &GNUNET_FS_download_signal_suspend_,
-                             sr->download);
-      if (NULL != sr->download->serialization)
-        {
-          GNUNET_FS_remove_sync_file_(sc->h,
-                                      GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
-                                      sr->download->serialization);
-          GNUNET_free(sr->download->serialization);
-          sr->download->serialization = NULL;
-        }
-      pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT;
-      GNUNET_FS_download_make_status_(&pi,
-                                      sr->download);
-      GNUNET_FS_download_sync_(sr->download);
-      sr->download = NULL;
+      GNUNET_FS_remove_sync_file_ (sc->h,
+                                   GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
+                                   sr->download->serialization);
+      GNUNET_free (sr->download->serialization);
+      sr->download->serialization = NULL;
     }
+    pi.status = GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT;
+    GNUNET_FS_download_make_status_ (&pi,
+                                     sr->download);
+    GNUNET_FS_download_sync_ (sr->download);
+    sr->download = NULL;
+  }
   if (0 != sr->mandatory_missing)
-    {
-      /* client is unaware of search result as
-         it does not match required keywords */
-      GNUNET_break(NULL == sr->client_info);
-      return GNUNET_OK;
-    }
+  {
+    /* client is unaware of search result as
+       it does not match required keywords */
+    GNUNET_break (NULL == sr->client_info);
+    return GNUNET_OK;
+  }
   pi.status = GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED;
   pi.value.search.specifics.result_stopped.cctx = sr->client_info;
   pi.value.search.specifics.result_stopped.meta = sr->meta;
   pi.value.search.specifics.result_stopped.uri = sr->uri;
-  sr->client_info = GNUNET_FS_search_make_status_(&pi, sr->h, sc);
+  sr->client_info = GNUNET_FS_search_make_status_ (&pi, sr->h, sc);
   return GNUNET_OK;
 }
 
@@ -1738,25 +1746,25 @@ search_result_stop(void *cls,
  * @return #GNUNET_OK
  */
 static int
-search_result_free(void *cls,
-                   const struct GNUNET_HashCode *key,
-                   void *value)
+search_result_free (void *cls,
+                    const struct GNUNET_HashCode *key,
+                    void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
   if (NULL != sr->update_search)
-    {
-      GNUNET_FS_search_stop(sr->update_search);
-      GNUNET_assert(NULL == sr->update_search);
-    }
-  GNUNET_break(NULL == sr->probe_ctx);
-  GNUNET_break(NULL == sr->probe_cancel_task);
-  GNUNET_break(NULL == sr->client_info);
-  GNUNET_free_non_null(sr->serialization);
-  GNUNET_FS_uri_destroy(sr->uri);
-  GNUNET_CONTAINER_meta_data_destroy(sr->meta);
-  GNUNET_free_non_null(sr->keyword_bitmap);
-  GNUNET_free(sr);
+  {
+    GNUNET_FS_search_stop (sr->update_search);
+    GNUNET_assert (NULL == sr->update_search);
+  }
+  GNUNET_break (NULL == sr->probe_ctx);
+  GNUNET_break (NULL == sr->probe_cancel_task);
+  GNUNET_break (NULL == sr->client_info);
+  GNUNET_free_non_null (sr->serialization);
+  GNUNET_FS_uri_destroy (sr->uri);
+  GNUNET_CONTAINER_meta_data_destroy (sr->meta);
+  GNUNET_free_non_null (sr->keyword_bitmap);
+  GNUNET_free (sr);
   return GNUNET_OK;
 }
 
@@ -1767,60 +1775,60 @@ search_result_free(void *cls,
  * @param sc context for the search that should be stopped
  */
 void
-GNUNET_FS_search_stop(struct GNUNET_FS_SearchContext *sc)
+GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_FS_ProgressInfo pi;
   unsigned int i;
 
   if (NULL != sc->top)
-    GNUNET_FS_end_top(sc->h, sc->top);
-  GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                        &search_result_stop,
-                                        sc);
+    GNUNET_FS_end_top (sc->h, sc->top);
+  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                         &search_result_stop,
+                                         sc);
   if (NULL != sc->psearch_result)
     sc->psearch_result->update_search = NULL;
   if (NULL != sc->serialization)
-    {
-      GNUNET_FS_remove_sync_file_(sc->h,
-                                  (NULL != sc->psearch_result)
-                                  ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH
-                                  : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
-                                  sc->serialization);
-      GNUNET_FS_remove_sync_dir_(sc->h,
+  {
+    GNUNET_FS_remove_sync_file_ (sc->h,
                                  (NULL != sc->psearch_result)
                                  ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH
                                  : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
                                  sc->serialization);
-      GNUNET_free(sc->serialization);
-    }
+    GNUNET_FS_remove_sync_dir_ (sc->h,
+                                (NULL != sc->psearch_result)
+                                ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH
+                                : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
+                                sc->serialization);
+    GNUNET_free (sc->serialization);
+  }
   pi.status = GNUNET_FS_STATUS_SEARCH_STOPPED;
-  sc->client_info = GNUNET_FS_search_make_status_(&pi,
-                                                  sc->h,
-                                                  sc);
-  GNUNET_break(NULL == sc->client_info);
+  sc->client_info = GNUNET_FS_search_make_status_ (&pi,
+                                                   sc->h,
+                                                   sc);
+  GNUNET_break (NULL == sc->client_info);
   if (NULL != sc->task)
-    {
-      GNUNET_SCHEDULER_cancel(sc->task);
-      sc->task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sc->task);
+    sc->task = NULL;
+  }
   if (NULL != sc->mq)
-    {
-      GNUNET_MQ_destroy(sc->mq);
-      sc->mq = NULL;
-    }
-  GNUNET_CONTAINER_multihashmap_iterate(sc->master_result_map,
-                                        &search_result_free, sc);
-  GNUNET_CONTAINER_multihashmap_destroy(sc->master_result_map);
+  {
+    GNUNET_MQ_destroy (sc->mq);
+    sc->mq = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                         &search_result_free, sc);
+  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
   if (NULL != sc->requests)
-    {
-      GNUNET_assert(GNUNET_FS_uri_test_ksk(sc->uri));
-      for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
-        GNUNET_CONTAINER_multihashmap_destroy(sc->requests[i].results);
-    }
-  GNUNET_free_non_null(sc->requests);
-  GNUNET_free_non_null(sc->emsg);
-  GNUNET_FS_uri_destroy(sc->uri);
-  GNUNET_free(sc);
+  {
+    GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
+    for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
+      GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
+  }
+  GNUNET_free_non_null (sc->requests);
+  GNUNET_free_non_null (sc->emsg);
+  GNUNET_FS_uri_destroy (sc->uri);
+  GNUNET_free (sc);
 }
 
 /* end of fs_search.c */
diff --git a/src/fs/fs_sharetree.c b/src/fs/fs_sharetree.c
index a2cc37170..dab5d00a0 100644
--- a/src/fs/fs_sharetree.c
+++ b/src/fs/fs_sharetree.c
@@ -34,7 +34,8 @@
  * Entry for each unique keyword to track how often
  * it occured.  Contains the keyword and the counter.
  */
-struct KeywordCounter {
+struct KeywordCounter
+{
   /**
    * This is a doubly-linked list
    */
@@ -60,7 +61,8 @@ struct KeywordCounter {
 /**
  * Aggregate information we keep for meta data in each directory.
  */
-struct MetaCounter {
+struct MetaCounter
+{
   /**
    * This is a doubly-linked list
    */
@@ -113,7 +115,8 @@ struct MetaCounter {
  * A structure that forms a singly-linked list that serves as a stack
  * for metadata-processing function.
  */
-struct TrimContext {
+struct TrimContext
+{
   /**
    * Map from the hash over the keyword to an 'struct KeywordCounter *'
    * counter that says how often this keyword was
@@ -149,26 +152,26 @@ struct TrimContext {
  * @return always GNUNET_OK
  */
 static int
-add_to_keyword_counter(void *cls, const char *keyword, int is_mandatory)
+add_to_keyword_counter (void *cls, const char *keyword, int is_mandatory)
 {
   struct GNUNET_CONTAINER_MultiHashMap *mcm = cls;
   struct KeywordCounter *cnt;
   struct GNUNET_HashCode hc;
   size_t klen;
 
-  klen = strlen(keyword) + 1;
-  GNUNET_CRYPTO_hash(keyword, klen - 1, &hc);
-  cnt = GNUNET_CONTAINER_multihashmap_get(mcm, &hc);
+  klen = strlen (keyword) + 1;
+  GNUNET_CRYPTO_hash (keyword, klen - 1, &hc);
+  cnt = GNUNET_CONTAINER_multihashmap_get (mcm, &hc);
   if (cnt == NULL)
-    {
-      cnt = GNUNET_malloc(sizeof(struct KeywordCounter) + klen);
-      cnt->value = (const char *)&cnt[1];
-      GNUNET_memcpy(&cnt[1], keyword, klen);
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONTAINER_multihashmap_put(mcm,
+  {
+    cnt = GNUNET_malloc (sizeof(struct KeywordCounter) + klen);
+    cnt->value = (const char *) &cnt[1];
+    GNUNET_memcpy (&cnt[1], keyword, klen);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (mcm,
                                                       &hc, cnt,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
+  }
   cnt->count++;
   return GNUNET_OK;
 }
@@ -192,30 +195,32 @@ add_to_keyword_counter(void *cls, const char *keyword, int is_mandatory)
  * @return 0 to continue extracting / iterating
  */
 static int
-add_to_meta_counter(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)
+add_to_meta_counter (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;
   struct GNUNET_HashCode key;
   struct MetaCounter *cnt;
 
-  GNUNET_CRYPTO_hash(data, data_len, &key);
-  cnt = GNUNET_CONTAINER_multihashmap_get(map, &key);
+  GNUNET_CRYPTO_hash (data, data_len, &key);
+  cnt = GNUNET_CONTAINER_multihashmap_get (map, &key);
   if (NULL == cnt)
-    {
-      cnt = GNUNET_new(struct MetaCounter);
-      cnt->data = data;
-      cnt->data_size = data_len;
-      cnt->plugin_name = plugin_name;
-      cnt->type = type;
-      cnt->format = format;
-      cnt->data_mime_type = data_mime_type;
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONTAINER_multihashmap_put(map,
+  {
+    cnt = GNUNET_new (struct MetaCounter);
+    cnt->data = data;
+    cnt->data_size = data_len;
+    cnt->plugin_name = plugin_name;
+    cnt->type = type;
+    cnt->format = format;
+    cnt->data_mime_type = data_mime_type;
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multihashmap_put (map,
                                                       &key, cnt,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
+  }
   cnt->count++;
   return 0;
 }
@@ -230,21 +235,22 @@ add_to_meta_counter(void *cls, const char *plugin_name,
  * @return always GNUNET_OK
  */
 static int
-remove_high_frequency_keywords(void *cls, const char *keyword, int is_mandatory)
+remove_high_frequency_keywords (void *cls, const char *keyword, int
+                                is_mandatory)
 {
   struct TrimContext *tc = cls;
   struct KeywordCounter *counter;
   struct GNUNET_HashCode hc;
   size_t klen;
 
-  klen = strlen(keyword) + 1;
-  GNUNET_CRYPTO_hash(keyword, klen - 1, &hc);
-  counter = GNUNET_CONTAINER_multihashmap_get(tc->keywordcounter, &hc);
-  GNUNET_assert(NULL != counter);
+  klen = strlen (keyword) + 1;
+  GNUNET_CRYPTO_hash (keyword, klen - 1, &hc);
+  counter = GNUNET_CONTAINER_multihashmap_get (tc->keywordcounter, &hc);
+  GNUNET_assert (NULL != counter);
   if (counter->count < tc->move_threshold)
     return GNUNET_OK;
-  GNUNET_FS_uri_ksk_remove_keyword(tc->pos->ksk_uri,
-                                   counter->value);
+  GNUNET_FS_uri_ksk_remove_keyword (tc->pos->ksk_uri,
+                                    counter->value);
   return GNUNET_OK;
 }
 
@@ -259,23 +265,26 @@ remove_high_frequency_keywords(void *cls, const char *keyword, int is_mandatory)
  * @return GNUNET_YES (always)
  */
 static int
-migrate_and_drop_keywords(void *cls, const struct GNUNET_HashCode * key, void *value)
+migrate_and_drop_keywords (void *cls, const struct GNUNET_HashCode *key,
+                           void *value)
 {
   struct TrimContext *tc = cls;
   struct KeywordCounter *counter = value;
 
   if (counter->count >= tc->move_threshold)
-    {
-      if (NULL == tc->pos->ksk_uri)
-        tc->pos->ksk_uri = GNUNET_FS_uri_ksk_create_from_args(1, &counter->value);
-      else
-        GNUNET_FS_uri_ksk_add_keyword(tc->pos->ksk_uri, counter->value, GNUNET_NO);
-    }
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap_remove(tc->keywordcounter,
-                                                     key,
-                                                     counter));
-  GNUNET_free(counter);
+  {
+    if (NULL == tc->pos->ksk_uri)
+      tc->pos->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1,
+                                                             &counter->value);
+    else
+      GNUNET_FS_uri_ksk_add_keyword (tc->pos->ksk_uri, counter->value,
+                                     GNUNET_NO);
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (tc->keywordcounter,
+                                                       key,
+                                                       counter));
+  GNUNET_free (counter);
   return GNUNET_YES;
 }
 
@@ -290,27 +299,28 @@ migrate_and_drop_keywords(void *cls, const struct GNUNET_HashCode * key, void *v
  * @return GNUNET_YES (always)
  */
 static int
-migrate_and_drop_metadata(void *cls, const struct GNUNET_HashCode * key, void *value)
+migrate_and_drop_metadata (void *cls, const struct GNUNET_HashCode *key,
+                           void *value)
 {
   struct TrimContext *tc = cls;
   struct MetaCounter *counter = value;
 
   if (counter->count >= tc->move_threshold)
-    {
-      if (NULL == tc->pos->meta)
-        tc->pos->meta = GNUNET_CONTAINER_meta_data_create();
-      GNUNET_CONTAINER_meta_data_insert(tc->pos->meta,
-                                        counter->plugin_name,
-                                        counter->type,
-                                        counter->format,
-                                        counter->data_mime_type, counter->data,
-                                        counter->data_size);
-    }
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap_remove(tc->metacounter,
-                                                     key,
-                                                     counter));
-  GNUNET_free(counter);
+  {
+    if (NULL == tc->pos->meta)
+      tc->pos->meta = GNUNET_CONTAINER_meta_data_create ();
+    GNUNET_CONTAINER_meta_data_insert (tc->pos->meta,
+                                       counter->plugin_name,
+                                       counter->type,
+                                       counter->format,
+                                       counter->data_mime_type, counter->data,
+                                       counter->data_size);
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_remove (tc->metacounter,
+                                                       key,
+                                                       counter));
+  GNUNET_free (counter);
   return GNUNET_YES;
 }
 
@@ -323,8 +333,8 @@ migrate_and_drop_metadata(void *cls, const struct GNUNET_HashCode * key, void *v
  * @param tree tree to trim
  */
 static void
-share_tree_trim(struct TrimContext *tc,
-                struct GNUNET_FS_ShareTreeItem *tree)
+share_tree_trim (struct TrimContext *tc,
+                 struct GNUNET_FS_ShareTreeItem *tree)
 {
   struct GNUNET_FS_ShareTreeItem *pos;
   unsigned int num_children;
@@ -332,64 +342,67 @@ share_tree_trim(struct TrimContext *tc,
   /* first, trim all children */
   num_children = 0;
   for (pos = tree->children_head; NULL != pos; pos = pos->next)
-    {
-      share_tree_trim(tc, pos);
-      num_children++;
-    }
+  {
+    share_tree_trim (tc, pos);
+    num_children++;
+  }
 
   /* consider adding filename to directory meta data */
   if (tree->is_directory == GNUNET_YES)
+  {
+    const char *user = getenv ("USER");
+    if ((user == NULL) ||
+        (0 != strncasecmp (user, tree->short_filename, strlen (user))))
     {
-      const char *user = getenv("USER");
-      if ((user == NULL) ||
-          (0 != strncasecmp(user, tree->short_filename, strlen(user))))
-        {
-          /* only use filename if it doesn't match $USER */
-          if (NULL == tree->meta)
-            tree->meta = GNUNET_CONTAINER_meta_data_create();
-          GNUNET_CONTAINER_meta_data_insert(tree->meta, "<libgnunetfs>",
-                                            EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                            EXTRACTOR_METAFORMAT_UTF8,
-                                            "text/plain", tree->short_filename,
-                                            strlen(tree->short_filename) + 1);
-        }
+      /* only use filename if it doesn't match $USER */
+      if (NULL == tree->meta)
+        tree->meta = GNUNET_CONTAINER_meta_data_create ();
+      GNUNET_CONTAINER_meta_data_insert (tree->meta, "<libgnunetfs>",
+                                         EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                                         EXTRACTOR_METAFORMAT_UTF8,
+                                         "text/plain", tree->short_filename,
+                                         strlen (tree->short_filename) + 1);
     }
+  }
 
   if (1 >= num_children)
     return; /* nothing to trim */
 
   /* now, count keywords and meta data in children */
   for (pos = tree->children_head; NULL != pos; pos = pos->next)
-    {
-      if (NULL != pos->meta)
-        GNUNET_CONTAINER_meta_data_iterate(pos->meta, &add_to_meta_counter, tc->metacounter);
-      if (NULL != pos->ksk_uri)
-        GNUNET_FS_uri_ksk_get_keywords(pos->ksk_uri, &add_to_keyword_counter, tc->keywordcounter);
-    }
+  {
+    if (NULL != pos->meta)
+      GNUNET_CONTAINER_meta_data_iterate (pos->meta, &add_to_meta_counter,
+                                          tc->metacounter);
+    if (NULL != pos->ksk_uri)
+      GNUNET_FS_uri_ksk_get_keywords (pos->ksk_uri, &add_to_keyword_counter,
+                                      tc->keywordcounter);
+  }
 
   /* calculate threshold for moving keywords / meta data */
   tc->move_threshold = 1 + (num_children / 2);
 
   /* remove high-frequency keywords from children */
   for (pos = tree->children_head; NULL != pos; pos = pos->next)
+  {
+    tc->pos = pos;
+    if (NULL != pos->ksk_uri)
     {
-      tc->pos = pos;
-      if (NULL != pos->ksk_uri)
-        {
-          struct GNUNET_FS_Uri *ksk_uri_copy = GNUNET_FS_uri_dup(pos->ksk_uri);
-          GNUNET_FS_uri_ksk_get_keywords(ksk_uri_copy, &remove_high_frequency_keywords, tc);
-          GNUNET_FS_uri_destroy(ksk_uri_copy);
-        }
+      struct GNUNET_FS_Uri *ksk_uri_copy = GNUNET_FS_uri_dup (pos->ksk_uri);
+      GNUNET_FS_uri_ksk_get_keywords (ksk_uri_copy,
+                                      &remove_high_frequency_keywords, tc);
+      GNUNET_FS_uri_destroy (ksk_uri_copy);
     }
+  }
 
   /* add high-frequency meta data and keywords to parent */
   tc->pos = tree;
-  GNUNET_CONTAINER_multihashmap_iterate(tc->keywordcounter,
-                                        &migrate_and_drop_keywords,
-                                        tc);
-  GNUNET_CONTAINER_multihashmap_iterate(tc->metacounter,
-                                        &migrate_and_drop_metadata,
-                                        tc);
+  GNUNET_CONTAINER_multihashmap_iterate (tc->keywordcounter,
+                                         &migrate_and_drop_keywords,
+                                         tc);
+  GNUNET_CONTAINER_multihashmap_iterate (tc->metacounter,
+                                         &migrate_and_drop_metadata,
+                                         tc);
 }
 
 
@@ -400,17 +413,17 @@ share_tree_trim(struct TrimContext *tc,
  * @param toplevel toplevel directory in the tree, returned by the scanner
  */
 void
-GNUNET_FS_share_tree_trim(struct GNUNET_FS_ShareTreeItem *toplevel)
+GNUNET_FS_share_tree_trim (struct GNUNET_FS_ShareTreeItem *toplevel)
 {
   struct TrimContext tc;
 
   if (toplevel == NULL)
     return;
-  tc.keywordcounter = GNUNET_CONTAINER_multihashmap_create(1024, GNUNET_NO);
-  tc.metacounter = GNUNET_CONTAINER_multihashmap_create(1024, GNUNET_NO);
-  share_tree_trim(&tc, toplevel);
-  GNUNET_CONTAINER_multihashmap_destroy(tc.keywordcounter);
-  GNUNET_CONTAINER_multihashmap_destroy(tc.metacounter);
+  tc.keywordcounter = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
+  tc.metacounter = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
+  share_tree_trim (&tc, toplevel);
+  GNUNET_CONTAINER_multihashmap_destroy (tc.keywordcounter);
+  GNUNET_CONTAINER_multihashmap_destroy (tc.metacounter);
 }
 
 
@@ -420,24 +433,23 @@ GNUNET_FS_share_tree_trim(struct GNUNET_FS_ShareTreeItem *toplevel)
  * @param toplevel toplevel of the tree to be freed
  */
 void
-GNUNET_FS_share_tree_free(struct GNUNET_FS_ShareTreeItem *toplevel)
+GNUNET_FS_share_tree_free (struct GNUNET_FS_ShareTreeItem *toplevel)
 {
   struct GNUNET_FS_ShareTreeItem *pos;
 
   while (NULL != (pos = toplevel->children_head))
-    GNUNET_FS_share_tree_free(pos);
+    GNUNET_FS_share_tree_free (pos);
   if (NULL != toplevel->parent)
-    GNUNET_CONTAINER_DLL_remove(toplevel->parent->children_head,
-                                toplevel->parent->children_tail,
-                                toplevel);
+    GNUNET_CONTAINER_DLL_remove (toplevel->parent->children_head,
+                                 toplevel->parent->children_tail,
+                                 toplevel);
   if (NULL != toplevel->meta)
-    GNUNET_CONTAINER_meta_data_destroy(toplevel->meta);
+    GNUNET_CONTAINER_meta_data_destroy (toplevel->meta);
   if (NULL != toplevel->ksk_uri)
-    GNUNET_FS_uri_destroy(toplevel->ksk_uri);
-  GNUNET_free_non_null(toplevel->filename);
-  GNUNET_free_non_null(toplevel->short_filename);
-  GNUNET_free(toplevel);
+    GNUNET_FS_uri_destroy (toplevel->ksk_uri);
+  GNUNET_free_non_null (toplevel->filename);
+  GNUNET_free_non_null (toplevel->short_filename);
+  GNUNET_free (toplevel);
 }
 
 /* end fs_sharetree.c */
-
diff --git a/src/fs/fs_test_lib.c b/src/fs/fs_test_lib.c
index e3ab0ec88..a0fe336df 100644
--- a/src/fs/fs_test_lib.c
+++ b/src/fs/fs_test_lib.c
@@ -37,7 +37,8 @@
 /**
  * Handle for a publishing operation started for testing FS.
  */
-struct TestPublishOperation {
+struct TestPublishOperation
+{
   /**
    * Handle for the operation to connect to the peer's 'fs' service.
    */
@@ -61,7 +62,7 @@ struct TestPublishOperation {
   /**
    * Task to abort publishing (timeout).
    */
-  struct GNUNET_SCHEDULER_Task * publish_timeout_task;
+  struct GNUNET_SCHEDULER_Task *publish_timeout_task;
 
   /**
    * Seed for file generation.
@@ -108,7 +109,8 @@ struct TestPublishOperation {
 /**
  * Handle for a download operation started for testing FS.
  */
-struct TestDownloadOperation {
+struct TestDownloadOperation
+{
   /**
    * Handle for the operation to connect to the peer's 'fs' service.
    */
@@ -142,7 +144,7 @@ struct TestDownloadOperation {
   /**
    * Task to abort downloading (timeout).
    */
-  struct GNUNET_SCHEDULER_Task * download_timeout_task;
+  struct GNUNET_SCHEDULER_Task *download_timeout_task;
 
   /**
    * Context for current download operation.
@@ -178,23 +180,23 @@ struct TestDownloadOperation {
  * @param tc scheduler context (unused)
  */
 static void
-report_uri(void *cls)
+report_uri (void *cls)
 {
   struct TestPublishOperation *po = cls;
 
-  GNUNET_FS_publish_stop(po->publish_context);
-  GNUNET_TESTBED_operation_done(po->fs_op);
-  po->publish_cont(po->publish_cont_cls,
-                   po->publish_uri,
-                   (GNUNET_YES == po->do_index)
-                   ? po->publish_tmp_file
-                   : NULL);
-  GNUNET_FS_uri_destroy(po->publish_uri);
+  GNUNET_FS_publish_stop (po->publish_context);
+  GNUNET_TESTBED_operation_done (po->fs_op);
+  po->publish_cont (po->publish_cont_cls,
+                    po->publish_uri,
+                    (GNUNET_YES == po->do_index)
+                    ? po->publish_tmp_file
+                    : NULL);
+  GNUNET_FS_uri_destroy (po->publish_uri);
   if ((GNUNET_YES != po->do_index) &&
       (NULL != po->publish_tmp_file))
-    (void)GNUNET_DISK_directory_remove(po->publish_tmp_file);
-  GNUNET_free_non_null(po->publish_tmp_file);
-  GNUNET_free(po);
+    (void) GNUNET_DISK_directory_remove (po->publish_tmp_file);
+  GNUNET_free_non_null (po->publish_tmp_file);
+  GNUNET_free (po);
 }
 
 
@@ -204,19 +206,19 @@ report_uri(void *cls)
  * @param cls the publish operation context
  */
 static void
-publish_timeout(void *cls)
+publish_timeout (void *cls)
 {
   struct TestPublishOperation *po = cls;
 
   po->publish_timeout_task = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Timeout while trying to publish data\n");
-  GNUNET_TESTBED_operation_done(po->fs_op);
-  GNUNET_FS_publish_stop(po->publish_context);
-  po->publish_cont(po->publish_cont_cls, NULL, NULL);
-  (void)GNUNET_DISK_directory_remove(po->publish_tmp_file);
-  GNUNET_free_non_null(po->publish_tmp_file);
-  GNUNET_free(po);
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout while trying to publish data\n");
+  GNUNET_TESTBED_operation_done (po->fs_op);
+  GNUNET_FS_publish_stop (po->publish_context);
+  po->publish_cont (po->publish_cont_cls, NULL, NULL);
+  (void) GNUNET_DISK_directory_remove (po->publish_tmp_file);
+  GNUNET_free_non_null (po->publish_tmp_file);
+  GNUNET_free (po);
 }
 
 
@@ -227,41 +229,41 @@ publish_timeout(void *cls)
  * @param info information about the event
  */
 static void *
-publish_progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
+publish_progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   struct TestPublishOperation *po = cls;
 
   switch (info->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      GNUNET_SCHEDULER_cancel(po->publish_timeout_task);
-      po->publish_timeout_task = NULL;
-      po->publish_uri =
-        GNUNET_FS_uri_dup(info->value.publish.specifics.completed.chk_uri);
-      GNUNET_SCHEDULER_add_now(&report_uri,
-                               po);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      if (po->verbose)
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n",
-                   (unsigned long long)info->value.publish.completed,
-                   (unsigned long long)info->value.publish.size);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
-      if (po->verbose)
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n",
-                   (unsigned long long)info->value.download.completed,
-                   (unsigned long long)info->value.download.size);
-      break;
-
-    default:
-      break;
-    }
+  {
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    GNUNET_SCHEDULER_cancel (po->publish_timeout_task);
+    po->publish_timeout_task = NULL;
+    po->publish_uri =
+      GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
+    GNUNET_SCHEDULER_add_now (&report_uri,
+                              po);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    if (po->verbose)
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Publishing at %llu/%llu bytes\n",
+                  (unsigned long long) info->value.publish.completed,
+                  (unsigned long long) info->value.publish.size);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    if (po->verbose)
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Download at %llu/%llu bytes\n",
+                  (unsigned long long) info->value.download.completed,
+                  (unsigned long long) info->value.download.size);
+    break;
+
+  default:
+    break;
+  }
   return NULL;
 }
 
@@ -277,11 +279,11 @@ publish_progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
  * @return number of bytes written to buf
  */
 static size_t
-file_generator(void *cls,
-               uint64_t offset,
-               size_t max,
-               void *buf,
-               char **emsg)
+file_generator (void *cls,
+                uint64_t offset,
+                size_t max,
+                void *buf,
+                char **emsg)
 {
   uint32_t *publish_seed = cls;
   uint64_t pos;
@@ -293,14 +295,14 @@ file_generator(void *cls,
   if (buf == NULL)
     return 0;
   for (pos = 0; pos < 8; pos++)
-    cbuf[pos] = (uint8_t)(offset >> pos * 8);
+    cbuf[pos] = (uint8_t) (offset >> pos * 8);
   for (pos = 8; pos < max; pos++)
-    {
-      mod = (255 - (offset / 1024 / 32));
-      if (mod == 0)
-        mod = 1;
-      cbuf[pos] = (uint8_t)((offset * (*publish_seed)) % mod);
-    }
+  {
+    mod = (255 - (offset / 1024 / 32));
+    if (mod == 0)
+      mod = 1;
+    cbuf[pos] = (uint8_t) ((offset * (*publish_seed)) % mod);
+  }
   return max;
 }
 
@@ -315,16 +317,16 @@ file_generator(void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-publish_connect_adapter(void *cls,
-                        const struct GNUNET_CONFIGURATION_Handle *cfg)
+publish_connect_adapter (void *cls,
+                         const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct TestPublishOperation *po = cls;
 
-  return GNUNET_FS_start(cfg,
-                         "fs-test-publish",
-                         &publish_progress_cb, po,
-                         GNUNET_FS_FLAGS_NONE,
-                         GNUNET_FS_OPTIONS_END);
+  return GNUNET_FS_start (cfg,
+                          "fs-test-publish",
+                          &publish_progress_cb, po,
+                          GNUNET_FS_FLAGS_NONE,
+                          GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -335,12 +337,12 @@ publish_connect_adapter(void *cls,
  * @param op_result unused (different for publish/download!)
  */
 static void
-fs_disconnect_adapter(void *cls,
-                      void *op_result)
+fs_disconnect_adapter (void *cls,
+                       void *op_result)
 {
   struct GNUNET_FS_Handle *fs = op_result;
 
-  GNUNET_FS_stop(fs);
+  GNUNET_FS_stop (fs);
 }
 
 
@@ -354,10 +356,10 @@ fs_disconnect_adapter(void *cls,
  *          operation has executed successfully.
  */
 static void
-publish_fs_connect_complete_cb(void *cls,
-                               struct GNUNET_TESTBED_Operation *op,
-                               void *ca_result,
-                               const char *emsg)
+publish_fs_connect_complete_cb (void *cls,
+                                struct GNUNET_TESTBED_Operation *op,
+                                void *ca_result,
+                                const char *emsg)
 {
   struct TestPublishOperation *po = cls;
   struct GNUNET_FS_FileInformation *fi;
@@ -369,59 +371,62 @@ publish_fs_connect_complete_cb(void *cls,
   struct GNUNET_FS_BlockOptions bo;
 
   if (NULL == ca_result)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to FS for publishing: %s\n", emsg);
-      po->publish_cont(po->publish_cont_cls,
-                       NULL, NULL);
-      GNUNET_TESTBED_operation_done(po->fs_op);
-      GNUNET_free(po);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to connect to FS for publishing: %s\n", emsg);
+    po->publish_cont (po->publish_cont_cls,
+                      NULL, NULL);
+    GNUNET_TESTBED_operation_done (po->fs_op);
+    GNUNET_free (po);
+    return;
+  }
   po->fs = ca_result;
 
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(CONTENT_LIFETIME);
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (CONTENT_LIFETIME);
   bo.anonymity_level = po->anonymity;
   bo.content_priority = 42;
   bo.replication_level = 1;
   if (GNUNET_YES == po->do_index)
+  {
+    po->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index");
+    GNUNET_assert (po->publish_tmp_file != NULL);
+    fh = GNUNET_DISK_file_open (po->publish_tmp_file,
+                                GNUNET_DISK_OPEN_WRITE
+                                | GNUNET_DISK_OPEN_CREATE,
+                                GNUNET_DISK_PERM_USER_READ
+                                | GNUNET_DISK_PERM_USER_WRITE);
+    GNUNET_assert (NULL != fh);
+    off = 0;
+    while (off < po->size)
     {
-      po->publish_tmp_file = GNUNET_DISK_mktemp("fs-test-publish-index");
-      GNUNET_assert(po->publish_tmp_file != NULL);
-      fh = GNUNET_DISK_file_open(po->publish_tmp_file,
-                                 GNUNET_DISK_OPEN_WRITE |
-                                 GNUNET_DISK_OPEN_CREATE,
-                                 GNUNET_DISK_PERM_USER_READ |
-                                 GNUNET_DISK_PERM_USER_WRITE);
-      GNUNET_assert(NULL != fh);
-      off = 0;
-      while (off < po->size)
-        {
-          bsize = GNUNET_MIN(sizeof(buf), po->size - off);
-          emsg = NULL;
-          GNUNET_assert(bsize == file_generator(&po->publish_seed, off, bsize, buf, &em));
-          GNUNET_assert(em == NULL);
-          GNUNET_assert(bsize == GNUNET_DISK_file_write(fh, buf, bsize));
-          off += bsize;
-        }
-      GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_close(fh));
-      fi = GNUNET_FS_file_information_create_from_file(po->fs, po,
-                                                       po->publish_tmp_file,
-                                                       NULL, NULL, po->do_index,
-                                                       &bo);
-      GNUNET_assert(NULL != fi);
+      bsize = GNUNET_MIN (sizeof(buf), po->size - off);
+      emsg = NULL;
+      GNUNET_assert (bsize == file_generator (&po->publish_seed, off, bsize,
+                                              buf, &em));
+      GNUNET_assert (em == NULL);
+      GNUNET_assert (bsize == GNUNET_DISK_file_write (fh, buf, bsize));
+      off += bsize;
     }
+    GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+    fi = GNUNET_FS_file_information_create_from_file (po->fs, po,
+                                                      po->publish_tmp_file,
+                                                      NULL, NULL, po->do_index,
+                                                      &bo);
+    GNUNET_assert (NULL != fi);
+  }
   else
-    {
-      fi = GNUNET_FS_file_information_create_from_reader(po->fs, po,
-                                                         po->size,
-                                                         &file_generator, &po->publish_seed,
-                                                         NULL, NULL,
-                                                         po->do_index, &bo);
-      GNUNET_assert(NULL != fi);
-    }
+  {
+    fi = GNUNET_FS_file_information_create_from_reader (po->fs, po,
+                                                        po->size,
+                                                        &file_generator,
+                                                        &po->publish_seed,
+                                                        NULL, NULL,
+                                                        po->do_index, &bo);
+    GNUNET_assert (NULL != fi);
+  }
   po->publish_context =
-    GNUNET_FS_publish_start(po->fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
+    GNUNET_FS_publish_start (po->fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
 }
 
 
@@ -441,15 +446,15 @@ publish_fs_connect_complete_cb(void *cls,
  * @param cont_cls closure for cont
  */
 void
-GNUNET_FS_TEST_publish(struct GNUNET_TESTBED_Peer *peer,
-                       struct GNUNET_TIME_Relative timeout, uint32_t anonymity,
-                       int do_index, uint64_t size, uint32_t seed,
-                       unsigned int verbose,
-                       GNUNET_FS_TEST_UriContinuation cont, void *cont_cls)
+GNUNET_FS_TEST_publish (struct GNUNET_TESTBED_Peer *peer,
+                        struct GNUNET_TIME_Relative timeout, uint32_t anonymity,
+                        int do_index, uint64_t size, uint32_t seed,
+                        unsigned int verbose,
+                        GNUNET_FS_TEST_UriContinuation cont, void *cont_cls)
 {
   struct TestPublishOperation *po;
 
-  po = GNUNET_new(struct TestPublishOperation);
+  po = GNUNET_new (struct TestPublishOperation);
   po->publish_cont = cont;
   po->publish_cont_cls = cont_cls;
   po->publish_seed = seed;
@@ -457,16 +462,16 @@ GNUNET_FS_TEST_publish(struct GNUNET_TESTBED_Peer *peer,
   po->size = size;
   po->verbose = verbose;
   po->do_index = do_index;
-  po->fs_op = GNUNET_TESTBED_service_connect(po,
-                                             peer,
-                                             "fs",
-                                             &publish_fs_connect_complete_cb,
-                                             po,
-                                             &publish_connect_adapter,
-                                             &fs_disconnect_adapter,
-                                             po);
+  po->fs_op = GNUNET_TESTBED_service_connect (po,
+                                              peer,
+                                              "fs",
+                                              &publish_fs_connect_complete_cb,
+                                              po,
+                                              &publish_connect_adapter,
+                                              &fs_disconnect_adapter,
+                                              po);
   po->publish_timeout_task =
-    GNUNET_SCHEDULER_add_delayed(timeout, &publish_timeout, po);
+    GNUNET_SCHEDULER_add_delayed (timeout, &publish_timeout, po);
 }
 
 
@@ -479,20 +484,20 @@ GNUNET_FS_TEST_publish(struct GNUNET_TESTBED_Peer *peer,
  * @param cls the download operation context
  */
 static void
-download_timeout(void *cls)
+download_timeout (void *cls)
 {
   struct TestDownloadOperation *dop = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Timeout while trying to download file\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout while trying to download file\n");
   dop->download_timeout_task = NULL;
-  GNUNET_FS_download_stop(dop->download_context,
-                          GNUNET_YES);
-  GNUNET_SCHEDULER_add_now(dop->download_cont,
-                           dop->download_cont_cls);
-  GNUNET_TESTBED_operation_done(dop->fs_op);
-  GNUNET_FS_uri_destroy(dop->uri);
-  GNUNET_free(dop);
+  GNUNET_FS_download_stop (dop->download_context,
+                           GNUNET_YES);
+  GNUNET_SCHEDULER_add_now (dop->download_cont,
+                            dop->download_cont_cls);
+  GNUNET_TESTBED_operation_done (dop->fs_op);
+  GNUNET_FS_uri_destroy (dop->uri);
+  GNUNET_free (dop);
 }
 
 
@@ -502,17 +507,17 @@ download_timeout(void *cls)
  * @param cls the download operation context
  */
 static void
-report_success(void *cls)
+report_success (void *cls)
 {
   struct TestDownloadOperation *dop = cls;
 
-  GNUNET_FS_download_stop(dop->download_context,
-                          GNUNET_YES);
-  GNUNET_SCHEDULER_add_now(dop->download_cont,
-                           dop->download_cont_cls);
-  GNUNET_TESTBED_operation_done(dop->fs_op);
-  GNUNET_FS_uri_destroy(dop->uri);
-  GNUNET_free(dop);
+  GNUNET_FS_download_stop (dop->download_context,
+                           GNUNET_YES);
+  GNUNET_SCHEDULER_add_now (dop->download_cont,
+                            dop->download_cont_cls);
+  GNUNET_TESTBED_operation_done (dop->fs_op);
+  GNUNET_FS_uri_destroy (dop->uri);
+  GNUNET_free (dop);
 }
 
 
@@ -523,37 +528,37 @@ report_success(void *cls)
  * @param info information about the event
  */
 static void *
-download_progress_cb(void *cls,
-                     const struct GNUNET_FS_ProgressInfo *info)
+download_progress_cb (void *cls,
+                      const struct GNUNET_FS_ProgressInfo *info)
 {
   struct TestDownloadOperation *dop = cls;
 
   switch (info->status)
-    {
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
-      if (dop->verbose)
-        GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                   "Download at %llu/%llu bytes\n",
-                   (unsigned long long)info->value.download.completed,
-                   (unsigned long long)info->value.download.size);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      GNUNET_SCHEDULER_cancel(dop->download_timeout_task);
-      dop->download_timeout_task = NULL;
-      GNUNET_SCHEDULER_add_now(&report_success, dop);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-    case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
-      break;
-
-    /* FIXME: monitor data correctness during download progress */
-    /* FIXME: do performance reports given sufficient verbosity */
-    /* FIXME: advance timeout task to "immediate" on error */
-    default:
-      break;
-    }
+  {
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    if (dop->verbose)
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Download at %llu/%llu bytes\n",
+                  (unsigned long long) info->value.download.completed,
+                  (unsigned long long) info->value.download.size);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    GNUNET_SCHEDULER_cancel (dop->download_timeout_task);
+    dop->download_timeout_task = NULL;
+    GNUNET_SCHEDULER_add_now (&report_success, dop);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+    break;
+
+  /* FIXME: monitor data correctness during download progress */
+  /* FIXME: do performance reports given sufficient verbosity */
+  /* FIXME: advance timeout task to "immediate" on error */
+  default:
+    break;
+  }
   return NULL;
 }
 
@@ -568,16 +573,16 @@ download_progress_cb(void *cls,
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-download_connect_adapter(void *cls,
-                         const struct GNUNET_CONFIGURATION_Handle *cfg)
+download_connect_adapter (void *cls,
+                          const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct TestPublishOperation *po = cls;
 
-  return GNUNET_FS_start(cfg,
-                         "fs-test-download",
-                         &download_progress_cb, po,
-                         GNUNET_FS_FLAGS_NONE,
-                         GNUNET_FS_OPTIONS_END);
+  return GNUNET_FS_start (cfg,
+                          "fs-test-download",
+                          &download_progress_cb, po,
+                          GNUNET_FS_FLAGS_NONE,
+                          GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -591,19 +596,19 @@ download_connect_adapter(void *cls,
  *          operation has executed successfully.
  */
 static void
-download_fs_connect_complete_cb(void *cls,
-                                struct GNUNET_TESTBED_Operation *op,
-                                void *ca_result,
-                                const char *emsg)
+download_fs_connect_complete_cb (void *cls,
+                                 struct GNUNET_TESTBED_Operation *op,
+                                 void *ca_result,
+                                 const char *emsg)
 {
   struct TestDownloadOperation *dop = cls;
 
   dop->fs = ca_result;
-  GNUNET_assert(NULL != dop->fs);
+  GNUNET_assert (NULL != dop->fs);
   dop->download_context =
-    GNUNET_FS_download_start(dop->fs, dop->uri, NULL, NULL, NULL, 0, dop->size,
-                             dop->anonymity, GNUNET_FS_DOWNLOAD_OPTION_NONE,
-                             NULL, NULL);
+    GNUNET_FS_download_start (dop->fs, dop->uri, NULL, NULL, NULL, 0, dop->size,
+                              dop->anonymity, GNUNET_FS_DOWNLOAD_OPTION_NONE,
+                              NULL, NULL);
 }
 
 
@@ -621,33 +626,33 @@ download_fs_connect_complete_cb(void *cls,
  * @param cont_cls closure for cont
  */
 void
-GNUNET_FS_TEST_download(struct GNUNET_TESTBED_Peer *peer,
-                        struct GNUNET_TIME_Relative timeout,
-                        uint32_t anonymity, uint32_t seed,
-                        const struct GNUNET_FS_Uri *uri, unsigned int verbose,
-                        GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
+GNUNET_FS_TEST_download (struct GNUNET_TESTBED_Peer *peer,
+                         struct GNUNET_TIME_Relative timeout,
+                         uint32_t anonymity, uint32_t seed,
+                         const struct GNUNET_FS_Uri *uri, unsigned int verbose,
+                         GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
 {
   struct TestDownloadOperation *dop;
 
-  dop = GNUNET_new(struct TestDownloadOperation);
-  dop->uri = GNUNET_FS_uri_dup(uri);
-  dop->size = GNUNET_FS_uri_chk_get_file_size(uri);
+  dop = GNUNET_new (struct TestDownloadOperation);
+  dop->uri = GNUNET_FS_uri_dup (uri);
+  dop->size = GNUNET_FS_uri_chk_get_file_size (uri);
   dop->verbose = verbose;
   dop->anonymity = anonymity;
   dop->download_cont = cont;
   dop->download_cont_cls = cont_cls;
   dop->download_seed = seed;
 
-  dop->fs_op = GNUNET_TESTBED_service_connect(dop,
-                                              peer,
-                                              "fs",
-                                              &download_fs_connect_complete_cb,
-                                              dop,
-                                              &download_connect_adapter,
-                                              &fs_disconnect_adapter,
-                                              dop);
+  dop->fs_op = GNUNET_TESTBED_service_connect (dop,
+                                               peer,
+                                               "fs",
+                                               &download_fs_connect_complete_cb,
+                                               dop,
+                                               &download_connect_adapter,
+                                               &fs_disconnect_adapter,
+                                               dop);
   dop->download_timeout_task =
-    GNUNET_SCHEDULER_add_delayed(timeout, &download_timeout, dop);
+    GNUNET_SCHEDULER_add_delayed (timeout, &download_timeout, dop);
 }
 
 
diff --git a/src/fs/fs_test_lib.h b/src/fs/fs_test_lib.h
index e1c43bea7..87bc90bd6 100644
--- a/src/fs/fs_test_lib.h
+++ b/src/fs/fs_test_lib.h
@@ -64,15 +64,15 @@ typedef void
  * @param cont_cls closure for @a cont
  */
 void
-GNUNET_FS_TEST_publish(struct GNUNET_TESTBED_Peer *peer,
-                       struct GNUNET_TIME_Relative timeout,
-                       uint32_t anonymity,
-                       int do_index,
-                       uint64_t size,
-                       uint32_t seed,
-                       unsigned int verbose,
-                       GNUNET_FS_TEST_UriContinuation cont,
-                       void *cont_cls);
+GNUNET_FS_TEST_publish (struct GNUNET_TESTBED_Peer *peer,
+                        struct GNUNET_TIME_Relative timeout,
+                        uint32_t anonymity,
+                        int do_index,
+                        uint64_t size,
+                        uint32_t seed,
+                        unsigned int verbose,
+                        GNUNET_FS_TEST_UriContinuation cont,
+                        void *cont_cls);
 
 
 /**
@@ -89,14 +89,14 @@ GNUNET_FS_TEST_publish(struct GNUNET_TESTBED_Peer *peer,
  * @param cont_cls closure for @a cont
  */
 void
-GNUNET_FS_TEST_download(struct GNUNET_TESTBED_Peer *peer,
-                        struct GNUNET_TIME_Relative timeout,
-                        uint32_t anonymity,
-                        uint32_t seed,
-                        const struct GNUNET_FS_Uri *uri,
-                        unsigned int verbose,
-                        GNUNET_SCHEDULER_TaskCallback cont,
-                        void *cont_cls);
+GNUNET_FS_TEST_download (struct GNUNET_TESTBED_Peer *peer,
+                         struct GNUNET_TIME_Relative timeout,
+                         uint32_t anonymity,
+                         uint32_t seed,
+                         const struct GNUNET_FS_Uri *uri,
+                         unsigned int verbose,
+                         GNUNET_SCHEDULER_TaskCallback cont,
+                         void *cont_cls);
 
 
 
diff --git a/src/fs/fs_tree.c b/src/fs/fs_tree.c
index 5d486a8c9..177f151f2 100644
--- a/src/fs/fs_tree.c
+++ b/src/fs/fs_tree.c
@@ -32,7 +32,8 @@
  * Context for an ECRS-based file encoder that computes
  * the Merkle-ish-CHK tree.
  */
-struct GNUNET_FS_TreeEncoder {
+struct GNUNET_FS_TreeEncoder
+{
   /**
    * Global FS context.
    */
@@ -121,7 +122,7 @@ struct GNUNET_FS_TreeEncoder {
  * @return depth of the tree, always > 0.  A depth of 1 means only a DBLOCK.
  */
 unsigned int
-GNUNET_FS_compute_depth(uint64_t flen)
+GNUNET_FS_compute_depth (uint64_t flen)
 {
   unsigned int treeDepth;
   uint64_t fl;
@@ -129,15 +130,15 @@ GNUNET_FS_compute_depth(uint64_t flen)
   treeDepth = 1;
   fl = DBLOCK_SIZE;
   while (fl < flen)
+  {
+    treeDepth++;
+    if (fl * CHK_PER_INODE < fl)
     {
-      treeDepth++;
-      if (fl * CHK_PER_INODE < fl)
-        {
-          /* integer overflow, this is a HUGE file... */
-          return treeDepth;
-        }
-      fl = fl * CHK_PER_INODE;
+      /* integer overflow, this is a HUGE file... */
+      return treeDepth;
     }
+    fl = fl * CHK_PER_INODE;
+  }
   return treeDepth;
 }
 
@@ -152,7 +153,7 @@ GNUNET_FS_compute_depth(uint64_t flen)
  * @return number of bytes of payload a subtree of this depth may correspond to
  */
 uint64_t
-GNUNET_FS_tree_compute_tree_size(unsigned int depth)
+GNUNET_FS_tree_compute_tree_size (unsigned int depth)
 {
   uint64_t rsize;
   unsigned int i;
@@ -179,30 +180,30 @@ GNUNET_FS_tree_compute_tree_size(unsigned int depth)
  * @return size of the corresponding IBlock
  */
 static uint16_t
-GNUNET_FS_tree_compute_iblock_size(unsigned int depth, uint64_t end_offset)
+GNUNET_FS_tree_compute_iblock_size (unsigned int depth, uint64_t end_offset)
 {
   unsigned int ret;
   uint64_t mod;
   uint64_t bds;
 
-  GNUNET_assert(depth > 0);
-  GNUNET_assert(end_offset > 0);
-  bds = GNUNET_FS_tree_compute_tree_size(depth);
+  GNUNET_assert (depth > 0);
+  GNUNET_assert (end_offset > 0);
+  bds = GNUNET_FS_tree_compute_tree_size (depth);
   mod = end_offset % bds;
   if (0 == mod)
-    {
-      /* we were triggered at the end of a full block */
-      ret = CHK_PER_INODE;
-    }
+  {
+    /* we were triggered at the end of a full block */
+    ret = CHK_PER_INODE;
+  }
   else
-    {
-      /* we were triggered at the end of the file */
-      bds /= CHK_PER_INODE;
-      ret = mod / bds;
-      if (0 != mod % bds)
-        ret++;
-    }
-  return (uint16_t)(ret * sizeof(struct ContentHashKey));
+  {
+    /* we were triggered at the end of the file */
+    bds /= CHK_PER_INODE;
+    ret = mod / bds;
+    if (0 != mod % bds)
+      ret++;
+  }
+  return (uint16_t) (ret * sizeof(struct ContentHashKey));
 }
 
 
@@ -218,31 +219,31 @@ GNUNET_FS_tree_compute_iblock_size(unsigned int depth, uint64_t end_offset)
  * @return number of bytes stored in this node
  */
 size_t
-GNUNET_FS_tree_calculate_block_size(uint64_t fsize, uint64_t offset,
-                                    unsigned int depth)
+GNUNET_FS_tree_calculate_block_size (uint64_t fsize, uint64_t offset,
+                                     unsigned int depth)
 {
   size_t ret;
   uint64_t rsize;
   uint64_t epos;
   unsigned int chks;
 
-  GNUNET_assert(fsize > 0);
-  GNUNET_assert(offset <= fsize);
+  GNUNET_assert (fsize > 0);
+  GNUNET_assert (offset <= fsize);
   if (depth == 0)
-    {
-      ret = DBLOCK_SIZE;
-      if ((offset + ret > fsize) || (offset + ret < offset))
-        ret = (size_t)(fsize - offset);
-      return ret;
-    }
-
-  rsize = GNUNET_FS_tree_compute_tree_size(depth - 1);
+  {
+    ret = DBLOCK_SIZE;
+    if ((offset + ret > fsize) || (offset + ret < offset))
+      ret = (size_t) (fsize - offset);
+    return ret;
+  }
+
+  rsize = GNUNET_FS_tree_compute_tree_size (depth - 1);
   epos = offset + rsize * CHK_PER_INODE;
   if ((epos < offset) || (epos > fsize))
     epos = fsize;
   /* round up when computing #CHKs in our IBlock */
   chks = (epos - offset + rsize - 1) / rsize;
-  GNUNET_assert(chks <= CHK_PER_INODE);
+  GNUNET_assert (chks <= CHK_PER_INODE);
   return chks * sizeof(struct ContentHashKey);
 }
 
@@ -265,16 +266,16 @@ GNUNET_FS_tree_calculate_block_size(uint64_t fsize, uint64_t offset,
  * @param cont function to call when done
  */
 struct GNUNET_FS_TreeEncoder *
-GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size,
-                              void *cls,
-                              GNUNET_FS_DataReader reader,
-                              GNUNET_FS_TreeBlockProcessor proc,
-                              GNUNET_FS_TreeProgressCallback progress,
-                              GNUNET_SCHEDULER_TaskCallback cont)
+GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h, uint64_t size,
+                               void *cls,
+                               GNUNET_FS_DataReader reader,
+                               GNUNET_FS_TreeBlockProcessor proc,
+                               GNUNET_FS_TreeProgressCallback progress,
+                               GNUNET_SCHEDULER_TaskCallback cont)
 {
   struct GNUNET_FS_TreeEncoder *te;
 
-  te = GNUNET_new(struct GNUNET_FS_TreeEncoder);
+  te = GNUNET_new (struct GNUNET_FS_TreeEncoder);
   te->h = h;
   te->size = size;
   te->cls = cls;
@@ -282,14 +283,14 @@ GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size,
   te->proc = proc;
   te->progress = progress;
   te->cont = cont;
-  te->chk_tree_depth = GNUNET_FS_compute_depth(size);
+  te->chk_tree_depth = GNUNET_FS_compute_depth (size);
   te->chk_tree
-    = GNUNET_new_array(te->chk_tree_depth * CHK_PER_INODE,
-                       struct ContentHashKey);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Created tree encoder for file with %llu bytes and depth %u\n",
-             (unsigned long long)size,
-             te->chk_tree_depth);
+    = GNUNET_new_array (te->chk_tree_depth * CHK_PER_INODE,
+                        struct ContentHashKey);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Created tree encoder for file with %llu bytes and depth %u\n",
+              (unsigned long long) size,
+              te->chk_tree_depth);
   return te;
 }
 
@@ -306,12 +307,12 @@ GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size,
  * @return (array of CHKs') offset in the above IBlock
  */
 static unsigned int
-compute_chk_offset(unsigned int depth, uint64_t end_offset)
+compute_chk_offset (unsigned int depth, uint64_t end_offset)
 {
   uint64_t bds;
   unsigned int ret;
 
-  bds = GNUNET_FS_tree_compute_tree_size(depth);
+  bds = GNUNET_FS_tree_compute_tree_size (depth);
   if (depth > 0)
     end_offset--;               /* round down since for depth > 0 offset is at the END of the block */
   ret = end_offset / bds;
@@ -327,7 +328,7 @@ compute_chk_offset(unsigned int depth, uint64_t end_offset)
  * @param te tree encoder to use
  */
 void
-GNUNET_FS_tree_encoder_next(struct GNUNET_FS_TreeEncoder *te)
+GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te)
 {
   struct ContentHashKey *mychk;
   const void *pt_block;
@@ -338,77 +339,77 @@ GNUNET_FS_tree_encoder_next(struct GNUNET_FS_TreeEncoder *te)
   struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
   unsigned int off;
 
-  GNUNET_assert(GNUNET_NO == te->in_next);
+  GNUNET_assert (GNUNET_NO == te->in_next);
   te->in_next = GNUNET_YES;
   if (te->chk_tree_depth == te->current_depth)
+  {
+    off = CHK_PER_INODE * (te->chk_tree_depth - 1);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TE done, reading CHK `%s' from %u\n",
+                GNUNET_h2s (&te->chk_tree[off].query), off);
+    te->uri = GNUNET_new (struct GNUNET_FS_Uri);
+    te->uri->type = GNUNET_FS_URI_CHK;
+    te->uri->data.chk.chk = te->chk_tree[off];
+    te->uri->data.chk.file_length = GNUNET_htonll (te->size);
+    te->in_next = GNUNET_NO;
+    te->cont (te->cls);
+    return;
+  }
+  if (0 == te->current_depth)
+  {
+    /* read DBLOCK */
+    pt_size = GNUNET_MIN (DBLOCK_SIZE, te->size - te->publish_offset);
+    if (pt_size !=
+        te->reader (te->cls, te->publish_offset, pt_size, iob, &te->emsg))
     {
-      off = CHK_PER_INODE * (te->chk_tree_depth - 1);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "TE done, reading CHK `%s' from %u\n",
-                 GNUNET_h2s(&te->chk_tree[off].query), off);
-      te->uri = GNUNET_new(struct GNUNET_FS_Uri);
-      te->uri->type = GNUNET_FS_URI_CHK;
-      te->uri->data.chk.chk = te->chk_tree[off];
-      te->uri->data.chk.file_length = GNUNET_htonll(te->size);
       te->in_next = GNUNET_NO;
-      te->cont(te->cls);
+      te->cont (te->cls);
       return;
     }
-  if (0 == te->current_depth)
-    {
-      /* read DBLOCK */
-      pt_size = GNUNET_MIN(DBLOCK_SIZE, te->size - te->publish_offset);
-      if (pt_size !=
-          te->reader(te->cls, te->publish_offset, pt_size, iob, &te->emsg))
-        {
-          te->in_next = GNUNET_NO;
-          te->cont(te->cls);
-          return;
-        }
-      pt_block = iob;
-    }
+    pt_block = iob;
+  }
   else
-    {
-      pt_size =
-        GNUNET_FS_tree_compute_iblock_size(te->current_depth,
-                                           te->publish_offset);
-      pt_block = &te->chk_tree[(te->current_depth - 1) * CHK_PER_INODE];
-    }
-  off = compute_chk_offset(te->current_depth, te->publish_offset);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "TE is at offset %llu and depth %u with block size %u and target-CHK-offset %u\n",
-             (unsigned long long)te->publish_offset, te->current_depth,
-             (unsigned int)pt_size, (unsigned int)off);
+  {
+    pt_size =
+      GNUNET_FS_tree_compute_iblock_size (te->current_depth,
+                                          te->publish_offset);
+    pt_block = &te->chk_tree[(te->current_depth - 1) * CHK_PER_INODE];
+  }
+  off = compute_chk_offset (te->current_depth, te->publish_offset);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "TE is at offset %llu and depth %u with block size %u and target-CHK-offset %u\n",
+              (unsigned long long) te->publish_offset, te->current_depth,
+              (unsigned int) pt_size, (unsigned int) off);
   mychk = &te->chk_tree[te->current_depth * CHK_PER_INODE + off];
-  GNUNET_CRYPTO_hash(pt_block, pt_size, &mychk->key);
-  GNUNET_CRYPTO_hash_to_aes_key(&mychk->key, &sk, &iv);
-  GNUNET_CRYPTO_symmetric_encrypt(pt_block, pt_size, &sk, &iv, enc);
-  GNUNET_CRYPTO_hash(enc, pt_size, &mychk->query);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "TE calculates query to be `%s', stored at %u\n",
-             GNUNET_h2s(&mychk->query),
-             te->current_depth * CHK_PER_INODE + off);
+  GNUNET_CRYPTO_hash (pt_block, pt_size, &mychk->key);
+  GNUNET_CRYPTO_hash_to_aes_key (&mychk->key, &sk, &iv);
+  GNUNET_CRYPTO_symmetric_encrypt (pt_block, pt_size, &sk, &iv, enc);
+  GNUNET_CRYPTO_hash (enc, pt_size, &mychk->query);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "TE calculates query to be `%s', stored at %u\n",
+              GNUNET_h2s (&mychk->query),
+              te->current_depth * CHK_PER_INODE + off);
   if (NULL != te->proc)
-    te->proc(te->cls, mychk, te->publish_offset, te->current_depth,
-             (0 ==
-              te->current_depth) ? GNUNET_BLOCK_TYPE_FS_DBLOCK :
-             GNUNET_BLOCK_TYPE_FS_IBLOCK, enc, pt_size);
+    te->proc (te->cls, mychk, te->publish_offset, te->current_depth,
+              (0 ==
+               te->current_depth) ? GNUNET_BLOCK_TYPE_FS_DBLOCK :
+              GNUNET_BLOCK_TYPE_FS_IBLOCK, enc, pt_size);
   if (NULL != te->progress)
-    te->progress(te->cls, te->publish_offset, pt_block, pt_size,
-                 te->current_depth);
+    te->progress (te->cls, te->publish_offset, pt_block, pt_size,
+                  te->current_depth);
   if (0 == te->current_depth)
-    {
-      te->publish_offset += pt_size;
-      if ((te->publish_offset == te->size) ||
-          (0 == te->publish_offset % (CHK_PER_INODE * DBLOCK_SIZE)))
-        te->current_depth++;
-    }
+  {
+    te->publish_offset += pt_size;
+    if ((te->publish_offset == te->size) ||
+        (0 == te->publish_offset % (CHK_PER_INODE * DBLOCK_SIZE)))
+      te->current_depth++;
+  }
   else
-    {
-      if ((off == CHK_PER_INODE) || (te->publish_offset == te->size))
-        te->current_depth++;
-      else
-        te->current_depth = 0;
-    }
+  {
+    if ((off == CHK_PER_INODE) || (te->publish_offset == te->size))
+      te->current_depth++;
+    else
+      te->current_depth = 0;
+  }
   te->in_next = GNUNET_NO;
 }
 
@@ -420,10 +421,10 @@ GNUNET_FS_tree_encoder_next(struct GNUNET_FS_TreeEncoder *te)
  * @return uri set to the resulting URI (if encoding finished), NULL otherwise
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_tree_encoder_get_uri(struct GNUNET_FS_TreeEncoder *te)
+GNUNET_FS_tree_encoder_get_uri (struct GNUNET_FS_TreeEncoder *te)
 {
   if (NULL != te->uri)
-    return GNUNET_FS_uri_dup(te->uri);
+    return GNUNET_FS_uri_dup (te->uri);
   return NULL;
 }
 
@@ -439,23 +440,23 @@ GNUNET_FS_tree_encoder_get_uri(struct GNUNET_FS_TreeEncoder *te)
  *        both "*emsg" will be set to NULL).
  */
 void
-GNUNET_FS_tree_encoder_finish(struct GNUNET_FS_TreeEncoder *te,
-                              char **emsg)
+GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder *te,
+                               char **emsg)
 {
   if (NULL != te->reader)
-    {
-      (void)te->reader(te->cls, UINT64_MAX, 0, 0, NULL);
-      te->reader = NULL;
-    }
-  GNUNET_assert(GNUNET_NO == te->in_next);
+  {
+    (void) te->reader (te->cls, UINT64_MAX, 0, 0, NULL);
+    te->reader = NULL;
+  }
+  GNUNET_assert (GNUNET_NO == te->in_next);
   if (NULL != te->uri)
-    GNUNET_FS_uri_destroy(te->uri);
+    GNUNET_FS_uri_destroy (te->uri);
   if (emsg != NULL)
     *emsg = te->emsg;
   else
-    GNUNET_free_non_null(te->emsg);
-  GNUNET_free(te->chk_tree);
-  GNUNET_free(te);
+    GNUNET_free_non_null (te->emsg);
+  GNUNET_free (te->chk_tree);
+  GNUNET_free (te);
 }
 
 /* end of fs_tree.c */
diff --git a/src/fs/fs_tree.h b/src/fs/fs_tree.h
index 7ce7e461b..12b5b5d07 100644
--- a/src/fs/fs_tree.h
+++ b/src/fs/fs_tree.h
@@ -41,7 +41,7 @@
  * @return depth of the tree, always > 0.  A depth of 1 means only a DBLOCK.
  */
 unsigned int
-GNUNET_FS_compute_depth(uint64_t flen);
+GNUNET_FS_compute_depth (uint64_t flen);
 
 
 /**
@@ -54,7 +54,7 @@ GNUNET_FS_compute_depth(uint64_t flen);
  * @return number of bytes of payload a subtree of this depth may correspond to
  */
 uint64_t
-GNUNET_FS_tree_compute_tree_size(unsigned int depth);
+GNUNET_FS_tree_compute_tree_size (unsigned int depth);
 
 
 /**
@@ -69,8 +69,8 @@ GNUNET_FS_tree_compute_tree_size(unsigned int depth);
  * @return number of bytes stored in this node
  */
 size_t
-GNUNET_FS_tree_calculate_block_size(uint64_t fsize, uint64_t offset,
-                                    unsigned int depth);
+GNUNET_FS_tree_calculate_block_size (uint64_t fsize, uint64_t offset,
+                                     unsigned int depth);
 
 
 /**
@@ -95,7 +95,7 @@ struct GNUNET_FS_TreeEncoder;
  * @param block_size size of block (in bytes)
  */
 typedef void (*GNUNET_FS_TreeBlockProcessor) (void *cls,
-                                              const struct ContentHashKey * chk,
+                                              const struct ContentHashKey *chk,
                                               uint64_t offset,
                                               unsigned int depth,
                                               enum GNUNET_BLOCK_Type type,
@@ -138,11 +138,11 @@ typedef void (*GNUNET_FS_TreeProgressCallback) (void *cls, uint64_t offset,
  * @return tree encoder context
  */
 struct GNUNET_FS_TreeEncoder *
-GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size,
-                              void *cls, GNUNET_FS_DataReader reader,
-                              GNUNET_FS_TreeBlockProcessor proc,
-                              GNUNET_FS_TreeProgressCallback progress,
-                              GNUNET_SCHEDULER_TaskCallback cont);
+GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h, uint64_t size,
+                               void *cls, GNUNET_FS_DataReader reader,
+                               GNUNET_FS_TreeBlockProcessor proc,
+                               GNUNET_FS_TreeProgressCallback progress,
+                               GNUNET_SCHEDULER_TaskCallback cont);
 
 
 /**
@@ -154,7 +154,7 @@ GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size,
  * @param te tree encoder to use
  */
 void
-GNUNET_FS_tree_encoder_next(struct GNUNET_FS_TreeEncoder *te);
+GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te);
 
 
 /**
@@ -164,7 +164,7 @@ GNUNET_FS_tree_encoder_next(struct GNUNET_FS_TreeEncoder *te);
  * @return uri set to the resulting URI (if encoding finished), NULL otherwise
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_tree_encoder_get_uri(struct GNUNET_FS_TreeEncoder *te);
+GNUNET_FS_tree_encoder_get_uri (struct GNUNET_FS_TreeEncoder *te);
 
 
 /**
@@ -178,8 +178,8 @@ GNUNET_FS_tree_encoder_get_uri(struct GNUNET_FS_TreeEncoder *te);
  *        both "*emsg" will be set to NULL).
  */
 void
-GNUNET_FS_tree_encoder_finish(struct GNUNET_FS_TreeEncoder *te,
-                              char **emsg);
+GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder *te,
+                               char **emsg);
 
 
 #if 0
@@ -194,8 +194,8 @@ GNUNET_FS_tree_encoder_finish(struct GNUNET_FS_TreeEncoder *te,
  * @param size set to the size of the resume data
  */
 void
-GNUNET_FS_tree_encoder_resume_get_data(const struct GNUNET_FS_TreeEncoder *te,
-                                       void **data, size_t * size);
+GNUNET_FS_tree_encoder_resume_get_data (const struct GNUNET_FS_TreeEncoder *te,
+                                        void **data, size_t *size);
 
 
 /**
@@ -207,8 +207,8 @@ GNUNET_FS_tree_encoder_resume_get_data(const struct GNUNET_FS_TreeEncoder *te,
  * @param size the size of the resume data
  */
 void
-GNUNET_FS_tree_encoder_resume(struct GNUNET_FS_TreeEncoder *te,
-                              const void *data, size_t size);
+GNUNET_FS_tree_encoder_resume (struct GNUNET_FS_TreeEncoder *te,
+                               const void *data, size_t size);
 
 #endif
 
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index be2dbbddd..c35d49312 100644
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -48,26 +48,26 @@
  * @return number of bytes copied to buf, 0 on error
  */
 static size_t
-unindex_reader(void *cls,
-               uint64_t offset,
-               size_t max,
-               void *buf,
-               char **emsg)
+unindex_reader (void *cls,
+                uint64_t offset,
+                size_t max,
+                void *buf,
+                char **emsg)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   size_t pt_size;
 
-  pt_size = GNUNET_MIN(max, uc->file_size - offset);
-  if (offset != GNUNET_DISK_file_seek(uc->fh, offset, GNUNET_DISK_SEEK_SET))
-    {
-      *emsg = GNUNET_strdup(_("Failed to find given position in file"));
-      return 0;
-    }
-  if (pt_size != GNUNET_DISK_file_read(uc->fh, buf, pt_size))
-    {
-      *emsg = GNUNET_strdup(_("Failed to read file"));
-      return 0;
-    }
+  pt_size = GNUNET_MIN (max, uc->file_size - offset);
+  if (offset != GNUNET_DISK_file_seek (uc->fh, offset, GNUNET_DISK_SEEK_SET))
+  {
+    *emsg = GNUNET_strdup (_ ("Failed to find given position in file"));
+    return 0;
+  }
+  if (pt_size != GNUNET_DISK_file_read (uc->fh, buf, pt_size))
+  {
+    *emsg = GNUNET_strdup (_ ("Failed to read file"));
+    return 0;
+  }
   return pt_size;
 }
 
@@ -81,21 +81,21 @@ unindex_reader(void *cls,
  * @param offset where we are in the file (for progress)
  */
 void
-GNUNET_FS_unindex_make_status_(struct GNUNET_FS_ProgressInfo *pi,
-                               struct GNUNET_FS_UnindexContext *uc,
-                               uint64_t offset)
+GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                struct GNUNET_FS_UnindexContext *uc,
+                                uint64_t offset)
 {
   pi->value.unindex.uc = uc;
   pi->value.unindex.cctx = uc->client_info;
   pi->value.unindex.filename = uc->filename;
   pi->value.unindex.size = uc->file_size;
   pi->value.unindex.eta =
-    GNUNET_TIME_calculate_eta(uc->start_time, offset, uc->file_size);
+    GNUNET_TIME_calculate_eta (uc->start_time, offset, uc->file_size);
   pi->value.unindex.duration =
-    GNUNET_TIME_absolute_get_duration(uc->start_time);
+    GNUNET_TIME_absolute_get_duration (uc->start_time);
   pi->value.unindex.completed = offset;
   pi->fsh = uc->h;
-  uc->client_info = uc->h->upcb(uc->h->upcb_cls, pi);
+  uc->client_info = uc->h->upcb (uc->h->upcb_cls, pi);
 }
 
 
@@ -110,11 +110,11 @@ GNUNET_FS_unindex_make_status_(struct GNUNET_FS_ProgressInfo *pi,
  * @param depth depth of the block in the tree, 0 for DBLOCK
  */
 static void
-unindex_progress(void *cls,
-                 uint64_t offset,
-                 const void *pt_block,
-                 size_t pt_size,
-                 unsigned int depth)
+unindex_progress (void *cls,
+                  uint64_t offset,
+                  const void *pt_block,
+                  size_t pt_size,
+                  unsigned int depth)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   struct GNUNET_FS_ProgressInfo pi;
@@ -124,7 +124,7 @@ unindex_progress(void *cls,
   pi.value.unindex.specifics.progress.offset = offset;
   pi.value.unindex.specifics.progress.data_len = pt_size;
   pi.value.unindex.specifics.progress.depth = depth;
-  GNUNET_FS_unindex_make_status_(&pi, uc, offset);
+  GNUNET_FS_unindex_make_status_ (&pi, uc, offset);
 }
 
 
@@ -135,14 +135,14 @@ unindex_progress(void *cls,
  * @param uc context for the failed unindexing operation
  */
 static void
-signal_unindex_error(struct GNUNET_FS_UnindexContext *uc)
+signal_unindex_error (struct GNUNET_FS_UnindexContext *uc)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
   pi.status = GNUNET_FS_STATUS_UNINDEX_ERROR;
   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
   pi.value.unindex.specifics.error.message = uc->emsg;
-  GNUNET_FS_unindex_make_status_(&pi, uc, 0);
+  GNUNET_FS_unindex_make_status_ (&pi, uc, 0);
 }
 
 
@@ -156,22 +156,22 @@ signal_unindex_error(struct GNUNET_FS_UnindexContext *uc)
  * @param msg NULL on success, otherwise an error message
  */
 static void
-process_cont(void *cls,
-             int success,
-             struct GNUNET_TIME_Absolute min_expiration,
-             const char *msg)
+process_cont (void *cls,
+              int success,
+              struct GNUNET_TIME_Absolute min_expiration,
+              const char *msg)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
 
   if (success == GNUNET_SYSERR)
-    {
-      uc->emsg = GNUNET_strdup(msg);
-      signal_unindex_error(uc);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Datastore REMOVE operation succeeded\n");
-  GNUNET_FS_tree_encoder_next(uc->tc);
+  {
+    uc->emsg = GNUNET_strdup (msg);
+    signal_unindex_error (uc);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Datastore REMOVE operation succeeded\n");
+  GNUNET_FS_tree_encoder_next (uc->tc);
 }
 
 
@@ -190,13 +190,13 @@ process_cont(void *cls,
  * @param block_size size of block (in bytes)
  */
 static void
-unindex_process(void *cls,
-                const struct ContentHashKey *chk,
-                uint64_t offset,
-                unsigned int depth,
-                enum GNUNET_BLOCK_Type type,
-                const void *block,
-                uint16_t block_size)
+unindex_process (void *cls,
+                 const struct ContentHashKey *chk,
+                 uint64_t offset,
+                 unsigned int depth,
+                 enum GNUNET_BLOCK_Type type,
+                 const void *block,
+                 uint16_t block_size)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   uint32_t size;
@@ -204,21 +204,21 @@ unindex_process(void *cls,
   struct OnDemandBlock odb;
 
   if (type != GNUNET_BLOCK_TYPE_FS_DBLOCK)
-    {
-      size = block_size;
-      data = block;
-    }
+  {
+    size = block_size;
+    data = block;
+  }
   else                          /* on-demand encoded DBLOCK */
-    {
-      size = sizeof(struct OnDemandBlock);
-      odb.offset = GNUNET_htonll(offset);
-      odb.file_id = uc->file_id;
-      data = &odb;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending REMOVE request to DATASTORE service\n");
-  GNUNET_DATASTORE_remove(uc->dsh, &chk->query, size, data, -2, 1,
-                          &process_cont, uc);
+  {
+    size = sizeof(struct OnDemandBlock);
+    odb.offset = GNUNET_htonll (offset);
+    odb.file_id = uc->file_id;
+    data = &odb;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending REMOVE request to DATASTORE service\n");
+  GNUNET_DATASTORE_remove (uc->dsh, &chk->query, size, data, -2, 1,
+                           &process_cont, uc);
   uc->chk = *chk;
 }
 
@@ -231,24 +231,24 @@ unindex_process(void *cls,
  * @param msg the response
  */
 static void
-handle_unindex_response(void *cls,
-                        const struct GNUNET_MessageHeader *msg)
+handle_unindex_response (void *cls,
+                         const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
   if (NULL != uc->mq)
-    {
-      GNUNET_MQ_destroy(uc->mq);
-      uc->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (uc->mq);
+    uc->mq = NULL;
+  }
   uc->state = UNINDEX_STATE_COMPLETE;
   pi.status = GNUNET_FS_STATUS_UNINDEX_COMPLETED;
   pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
-  GNUNET_FS_unindex_sync_(uc);
-  GNUNET_FS_unindex_make_status_(&pi,
-                                 uc,
-                                 uc->file_size);
+  GNUNET_FS_unindex_sync_ (uc);
+  GNUNET_FS_unindex_make_status_ (&pi,
+                                  uc,
+                                  uc->file_size);
 }
 
 
@@ -261,20 +261,20 @@ handle_unindex_response(void *cls,
  * @param error error code
  */
 static void
-unindex_mq_error_handler(void *cls,
-                         enum GNUNET_MQ_Error error)
+unindex_mq_error_handler (void *cls,
+                          enum GNUNET_MQ_Error error)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
 
   if (NULL != uc->mq)
-    {
-      GNUNET_MQ_destroy(uc->mq);
-      uc->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (uc->mq);
+    uc->mq = NULL;
+  }
   uc->state = UNINDEX_STATE_ERROR;
-  uc->emsg = GNUNET_strdup(_("Error communicating with `fs' service."));
-  GNUNET_FS_unindex_sync_(uc);
-  signal_unindex_error(uc);
+  uc->emsg = GNUNET_strdup (_ ("Error communicating with `fs' service."));
+  GNUNET_FS_unindex_sync_ (uc);
+  signal_unindex_error (uc);
 }
 
 
@@ -286,56 +286,56 @@ unindex_mq_error_handler(void *cls,
  * @param uc our unindexing context
  */
 static void
-unindex_finish(struct GNUNET_FS_UnindexContext *uc)
+unindex_finish (struct GNUNET_FS_UnindexContext *uc)
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_fixed_size(unindex_response,
-                            GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK,
-                            struct GNUNET_MessageHeader,
-                            uc),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_fixed_size (unindex_response,
+                             GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK,
+                             struct GNUNET_MessageHeader,
+                             uc),
+    GNUNET_MQ_handler_end ()
   };
   char *emsg;
   struct GNUNET_MQ_Envelope *env;
   struct UnindexMessage *req;
 
   /* generate final progress message */
-  unindex_progress(uc,
-                   uc->file_size,
-                   NULL,
-                   0,
-                   0);
-  GNUNET_FS_tree_encoder_finish(uc->tc,
-                                &emsg);
+  unindex_progress (uc,
+                    uc->file_size,
+                    NULL,
+                    0,
+                    0);
+  GNUNET_FS_tree_encoder_finish (uc->tc,
+                                 &emsg);
   uc->tc = NULL;
-  GNUNET_DISK_file_close(uc->fh);
+  GNUNET_DISK_file_close (uc->fh);
   uc->fh = NULL;
-  GNUNET_DATASTORE_disconnect(uc->dsh, GNUNET_NO);
+  GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
   uc->dsh = NULL;
   uc->state = UNINDEX_STATE_FS_NOTIFY;
-  GNUNET_FS_unindex_sync_(uc);
-  uc->mq = GNUNET_CLIENT_connect(uc->h->cfg,
-                                 "fs",
-                                 handlers,
-                                 &unindex_mq_error_handler,
-                                 uc);
+  GNUNET_FS_unindex_sync_ (uc);
+  uc->mq = GNUNET_CLIENT_connect (uc->h->cfg,
+                                  "fs",
+                                  handlers,
+                                  &unindex_mq_error_handler,
+                                  uc);
   if (NULL == uc->mq)
-    {
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg =
-        GNUNET_strdup(_("Failed to connect to FS service for unindexing."));
-      GNUNET_FS_unindex_sync_(uc);
-      signal_unindex_error(uc);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending UNINDEX message to FS service\n");
-  env = GNUNET_MQ_msg(req,
-                      GNUNET_MESSAGE_TYPE_FS_UNINDEX);
+  {
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg =
+      GNUNET_strdup (_ ("Failed to connect to FS service for unindexing."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending UNINDEX message to FS service\n");
+  env = GNUNET_MQ_msg (req,
+                       GNUNET_MESSAGE_TYPE_FS_UNINDEX);
   req->reserved = 0;
   req->file_id = uc->file_id;
-  GNUNET_MQ_send(uc->mq,
-                 env);
+  GNUNET_MQ_send (uc->mq,
+                  env);
 }
 
 
@@ -351,49 +351,49 @@ unindex_finish(struct GNUNET_FS_UnindexContext *uc)
  * @param reason kind of progress we are making
  */
 static void
-unindex_directory_scan_cb(void *cls,
-                          const char *filename,
-                          int is_directory,
-                          enum GNUNET_FS_DirScannerProgressUpdateReason reason)
+unindex_directory_scan_cb (void *cls,
+                           const char *filename,
+                           int is_directory,
+                           enum GNUNET_FS_DirScannerProgressUpdateReason reason)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
-  static struct GNUNET_FS_ShareTreeItem * directory_scan_result;
+  static struct GNUNET_FS_ShareTreeItem *directory_scan_result;
 
   switch (reason)
-    {
-    case GNUNET_FS_DIRSCANNER_FINISHED:
-      directory_scan_result = GNUNET_FS_directory_scan_get_result(uc->dscan);
-      uc->dscan = NULL;
-      if (NULL != directory_scan_result->ksk_uri)
-        {
-          uc->ksk_uri = GNUNET_FS_uri_dup(directory_scan_result->ksk_uri);
-          uc->state = UNINDEX_STATE_DS_REMOVE_KBLOCKS;
-          GNUNET_FS_unindex_sync_(uc);
-          GNUNET_FS_unindex_do_remove_kblocks_(uc);
-        }
-      else
-        {
-          uc->emsg = GNUNET_strdup(_("Failed to get KSKs from directory scan."));
-          GNUNET_FS_unindex_sync_(uc);
-          unindex_finish(uc);
-        }
-      GNUNET_FS_share_tree_free(directory_scan_result);
-      break;
-
-    case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Internal error scanning `%s'.\n"),
-                 uc->filename);
-      GNUNET_FS_directory_scan_abort(uc->dscan);
-      uc->dscan = NULL;
-      uc->emsg = GNUNET_strdup(_("Failed to get KSKs from directory scan."));
-      GNUNET_FS_unindex_sync_(uc);
-      unindex_finish(uc);
-      break;
-
-    default:
-      break;
-    }
+  {
+  case GNUNET_FS_DIRSCANNER_FINISHED:
+    directory_scan_result = GNUNET_FS_directory_scan_get_result (uc->dscan);
+    uc->dscan = NULL;
+    if (NULL != directory_scan_result->ksk_uri)
+    {
+      uc->ksk_uri = GNUNET_FS_uri_dup (directory_scan_result->ksk_uri);
+      uc->state = UNINDEX_STATE_DS_REMOVE_KBLOCKS;
+      GNUNET_FS_unindex_sync_ (uc);
+      GNUNET_FS_unindex_do_remove_kblocks_ (uc);
+    }
+    else
+    {
+      uc->emsg = GNUNET_strdup (_ ("Failed to get KSKs from directory scan."));
+      GNUNET_FS_unindex_sync_ (uc);
+      unindex_finish (uc);
+    }
+    GNUNET_FS_share_tree_free (directory_scan_result);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Internal error scanning `%s'.\n"),
+                uc->filename);
+    GNUNET_FS_directory_scan_abort (uc->dscan);
+    uc->dscan = NULL;
+    uc->emsg = GNUNET_strdup (_ ("Failed to get KSKs from directory scan."));
+    GNUNET_FS_unindex_sync_ (uc);
+    unindex_finish (uc);
+    break;
+
+  default:
+    break;
+  }
 }
 
 
@@ -403,18 +403,19 @@ unindex_directory_scan_cb(void *cls,
  * @param uc context for the unindex operation.
  */
 void
-GNUNET_FS_unindex_do_extract_keywords_(struct GNUNET_FS_UnindexContext *uc)
+GNUNET_FS_unindex_do_extract_keywords_ (struct GNUNET_FS_UnindexContext *uc)
 {
   char *ex;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(uc->h->cfg, "FS", "EXTRACTORS", &ex))
+      GNUNET_CONFIGURATION_get_value_string (uc->h->cfg, "FS", "EXTRACTORS",
+                                             &ex))
     ex = NULL;
-  uc->dscan = GNUNET_FS_directory_scan_start(uc->filename,
-                                             GNUNET_NO, ex,
-                                             &unindex_directory_scan_cb,
-                                             uc);
-  GNUNET_free_non_null(ex);
+  uc->dscan = GNUNET_FS_directory_scan_start (uc->filename,
+                                              GNUNET_NO, ex,
+                                              &unindex_directory_scan_cb,
+                                              uc);
+  GNUNET_free_non_null (ex);
 }
 
 
@@ -432,20 +433,20 @@ GNUNET_FS_unindex_do_extract_keywords_(struct GNUNET_FS_UnindexContext *uc)
  * @param msg NULL on success, otherwise an error message
  */
 static void
-continue_after_remove(void *cls,
-                      int32_t success,
-                      struct GNUNET_TIME_Absolute min_expiration,
-                      const char *msg)
+continue_after_remove (void *cls,
+                       int32_t success,
+                       struct GNUNET_TIME_Absolute min_expiration,
+                       const char *msg)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
 
   uc->dqe = NULL;
   if (success != GNUNET_YES)
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-               _("Failed to remove UBlock: %s\n"),
-               msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to remove UBlock: %s\n"),
+                msg);
   uc->ksk_offset++;
-  GNUNET_FS_unindex_do_remove_kblocks_(uc);
+  GNUNET_FS_unindex_do_remove_kblocks_ (uc);
 }
 
 
@@ -472,16 +473,16 @@ continue_after_remove(void *cls,
  *        maybe 0 if no unique identifier is available
  */
 static void
-process_kblock_for_unindex(void *cls,
-                           const struct GNUNET_HashCode *key,
-                           size_t size,
-                           const void *data,
-                           enum GNUNET_BLOCK_Type type,
-                           uint32_t priority,
-                           uint32_t anonymity,
-                           uint32_t replication,
-                           struct GNUNET_TIME_Absolute expiration,
-                           uint64_t uid)
+process_kblock_for_unindex (void *cls,
+                            const struct GNUNET_HashCode *key,
+                            size_t size,
+                            const void *data,
+                            enum GNUNET_BLOCK_Type type,
+                            uint32_t priority,
+                            uint32_t anonymity,
+                            uint32_t replication,
+                            struct GNUNET_TIME_Absolute expiration,
+                            uint64_t uid)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   const struct UBlock *ub;
@@ -490,82 +491,83 @@ process_kblock_for_unindex(void *cls,
 
   uc->dqe = NULL;
   if (NULL == data)
-    {
-      /* no result */
-      uc->ksk_offset++;
-      GNUNET_FS_unindex_do_remove_kblocks_(uc);
-      return;
-    }
-  GNUNET_assert(GNUNET_BLOCK_TYPE_FS_UBLOCK == type);
+  {
+    /* no result */
+    uc->ksk_offset++;
+    GNUNET_FS_unindex_do_remove_kblocks_ (uc);
+    return;
+  }
+  GNUNET_assert (GNUNET_BLOCK_TYPE_FS_UBLOCK == type);
   if (size < sizeof(struct UBlock))
-    {
-      GNUNET_break(0);
-      goto get_next;
-    }
+  {
+    GNUNET_break (0);
+    goto get_next;
+  }
   ub = data;
-  GNUNET_CRYPTO_hash(&ub->verification_key,
-                     sizeof(ub->verification_key),
-                     &query);
-  if (0 != memcmp(&query,
-                  key,
-                  sizeof(struct GNUNET_HashCode)))
-    {
-      /* result does not match our keyword, skip */
-      goto get_next;
-    }
+  GNUNET_CRYPTO_hash (&ub->verification_key,
+                      sizeof(ub->verification_key),
+                      &query);
+  if (0 != memcmp (&query,
+                   key,
+                   sizeof(struct GNUNET_HashCode)))
+  {
+    /* result does not match our keyword, skip */
+    goto get_next;
+  }
   {
     char pt[size - sizeof(struct UBlock)];
     struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
     const char *keyword;
 
-    GNUNET_CRYPTO_ecdsa_key_get_public(GNUNET_CRYPTO_ecdsa_key_get_anonymous(),
-                                       &anon_pub);
+    GNUNET_CRYPTO_ecdsa_key_get_public (
+      GNUNET_CRYPTO_ecdsa_key_get_anonymous (),
+      &anon_pub);
     keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
-    GNUNET_FS_ublock_decrypt_(&ub[1], size - sizeof(struct UBlock),
-                              &anon_pub,
-                              keyword,
-                              pt);
-    if (NULL == memchr(&pt[1], 0, sizeof(pt) - 1))
-      {
-        GNUNET_break_op(0); /* malformed UBlock */
-        goto get_next;
-      }
-    chk_uri = GNUNET_FS_uri_parse(&pt[1], NULL);
+    GNUNET_FS_ublock_decrypt_ (&ub[1], size - sizeof(struct UBlock),
+                               &anon_pub,
+                               keyword,
+                               pt);
+    if (NULL == memchr (&pt[1], 0, sizeof(pt) - 1))
+    {
+      GNUNET_break_op (0);  /* malformed UBlock */
+      goto get_next;
+    }
+    chk_uri = GNUNET_FS_uri_parse (&pt[1], NULL);
     if (NULL == chk_uri)
-      {
-        GNUNET_break_op(0); /* malformed UBlock */
-        goto get_next;
-      }
-  }
-  if (0 != memcmp(&uc->chk,
-                  &chk_uri->data.chk.chk,
-                  sizeof(struct ContentHashKey)))
     {
-      /* different CHK, ignore */
-      GNUNET_FS_uri_destroy(chk_uri);
+      GNUNET_break_op (0);  /* malformed UBlock */
       goto get_next;
     }
-  GNUNET_FS_uri_destroy(chk_uri);
+  }
+  if (0 != memcmp (&uc->chk,
+                   &chk_uri->data.chk.chk,
+                   sizeof(struct ContentHashKey)))
+  {
+    /* different CHK, ignore */
+    GNUNET_FS_uri_destroy (chk_uri);
+    goto get_next;
+  }
+  GNUNET_FS_uri_destroy (chk_uri);
   /* matches! */
-  uc->dqe = GNUNET_DATASTORE_remove(uc->dsh,
-                                    key,
-                                    size,
-                                    data,
-                                    0 /* priority */,
-                                    1 /* queue size */,
-                                    &continue_after_remove,
-                                    uc);
-  return;
-get_next:
-  uc->dqe = GNUNET_DATASTORE_get_key(uc->dsh,
-                                     uid + 1 /* next_uid */,
-                                     false /* random */,
-                                     &uc->uquery,
-                                     GNUNET_BLOCK_TYPE_FS_UBLOCK,
+  uc->dqe = GNUNET_DATASTORE_remove (uc->dsh,
+                                     key,
+                                     size,
+                                     data,
                                      0 /* priority */,
                                      1 /* queue size */,
-                                     &process_kblock_for_unindex,
+                                     &continue_after_remove,
                                      uc);
+  return;
+get_next:
+  uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
+                                      uid + 1 /* next_uid */,
+                                      false /* random */,
+                                      &uc->uquery,
+                                      GNUNET_BLOCK_TYPE_FS_UBLOCK,
+                                      0 /* priority */,
+                                      1 /* queue size */,
+                                      &process_kblock_for_unindex,
+                                      uc);
 }
 
 
@@ -575,7 +577,7 @@ get_next:
  * @param uc context for the unindex operation.
  */
 void
-GNUNET_FS_unindex_do_remove_kblocks_(struct GNUNET_FS_UnindexContext *uc)
+GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
 {
   const char *keyword;
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
@@ -583,41 +585,41 @@ GNUNET_FS_unindex_do_remove_kblocks_(struct GNUNET_FS_UnindexContext *uc)
   struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
 
   if (NULL == uc->dsh)
-    uc->dsh = GNUNET_DATASTORE_connect(uc->h->cfg);
+    uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
   if (NULL == uc->dsh)
-    {
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg = GNUNET_strdup(_("Failed to connect to `datastore' service."));
-      GNUNET_FS_unindex_sync_(uc);
-      signal_unindex_error(uc);
-      return;
-    }
+  {
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg = GNUNET_strdup (_ ("Failed to connect to `datastore' service."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
   if ((NULL == uc->ksk_uri) ||
       (uc->ksk_offset >= uc->ksk_uri->data.ksk.keywordCount))
-    {
-      unindex_finish(uc);
-      return;
-    }
-  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous();
-  GNUNET_CRYPTO_ecdsa_key_get_public(anon,
-                                     &anon_pub);
+  {
+    unindex_finish (uc);
+    return;
+  }
+  anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
+  GNUNET_CRYPTO_ecdsa_key_get_public (anon,
+                                      &anon_pub);
   keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
-  GNUNET_CRYPTO_ecdsa_public_key_derive(&anon_pub,
-                                        keyword,
-                                        "fs-ublock",
-                                        &dpub);
-  GNUNET_CRYPTO_hash(&dpub,
-                     sizeof(dpub),
-                     &uc->uquery);
-  uc->dqe = GNUNET_DATASTORE_get_key(uc->dsh,
-                                     0 /* next_uid */,
-                                     false /* random */,
-                                     &uc->uquery,
-                                     GNUNET_BLOCK_TYPE_FS_UBLOCK,
-                                     0 /* priority */,
-                                     1 /* queue size */,
-                                     &process_kblock_for_unindex,
-                                     uc);
+  GNUNET_CRYPTO_ecdsa_public_key_derive (&anon_pub,
+                                         keyword,
+                                         "fs-ublock",
+                                         &dpub);
+  GNUNET_CRYPTO_hash (&dpub,
+                      sizeof(dpub),
+                      &uc->uquery);
+  uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
+                                      0 /* next_uid */,
+                                      false /* random */,
+                                      &uc->uquery,
+                                      GNUNET_BLOCK_TYPE_FS_UBLOCK,
+                                      0 /* priority */,
+                                      1 /* queue size */,
+                                      &process_kblock_for_unindex,
+                                      uc);
 }
 
 
@@ -628,13 +630,13 @@ GNUNET_FS_unindex_do_remove_kblocks_(struct GNUNET_FS_UnindexContext *uc)
  * @param cls our unindexing context
  */
 static void
-unindex_extract_keywords(void *cls)
+unindex_extract_keywords (void *cls)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
 
   uc->state = UNINDEX_STATE_EXTRACT_KEYWORDS;
-  GNUNET_FS_unindex_sync_(uc);
-  GNUNET_FS_unindex_do_extract_keywords_(uc);
+  GNUNET_FS_unindex_sync_ (uc);
+  GNUNET_FS_unindex_do_extract_keywords_ (uc);
 }
 
 
@@ -644,40 +646,40 @@ unindex_extract_keywords(void *cls)
  * @param uc context for the unindex operation.
  */
 void
-GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc)
+GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
 {
   if (NULL == uc->dsh)
-    uc->dsh = GNUNET_DATASTORE_connect(uc->h->cfg);
+    uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
   if (NULL == uc->dsh)
-    {
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg = GNUNET_strdup(_("Failed to connect to `datastore' service."));
-      GNUNET_FS_unindex_sync_(uc);
-      signal_unindex_error(uc);
-      return;
-    }
+  {
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg = GNUNET_strdup (_ ("Failed to connect to `datastore' service."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
   uc->fh =
-    GNUNET_DISK_file_open(uc->filename, GNUNET_DISK_OPEN_READ,
-                          GNUNET_DISK_PERM_NONE);
+    GNUNET_DISK_file_open (uc->filename, GNUNET_DISK_OPEN_READ,
+                           GNUNET_DISK_PERM_NONE);
   if (NULL == uc->fh)
-    {
-      GNUNET_DATASTORE_disconnect(uc->dsh, GNUNET_NO);
-      uc->dsh = NULL;
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg = GNUNET_strdup(_("Failed to open file for unindexing."));
-      GNUNET_FS_unindex_sync_(uc);
-      signal_unindex_error(uc);
-      return;
-    }
+  {
+    GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
+    uc->dsh = NULL;
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg = GNUNET_strdup (_ ("Failed to open file for unindexing."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
   uc->tc =
-    GNUNET_FS_tree_encoder_create(uc->h,
-                                  uc->file_size,
-                                  uc,
-                                  &unindex_reader,
-                                  &unindex_process,
-                                  &unindex_progress,
-                                  &unindex_extract_keywords);
-  GNUNET_FS_tree_encoder_next(uc->tc);
+    GNUNET_FS_tree_encoder_create (uc->h,
+                                   uc->file_size,
+                                   uc,
+                                   &unindex_reader,
+                                   &unindex_process,
+                                   &unindex_progress,
+                                   &unindex_extract_keywords);
+  GNUNET_FS_tree_encoder_next (uc->tc);
 }
 
 
@@ -689,29 +691,29 @@ GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc)
  * @param file_id computed hash, NULL on error
  */
 void
-GNUNET_FS_unindex_process_hash_(void *cls,
-                                const struct GNUNET_HashCode *file_id)
+GNUNET_FS_unindex_process_hash_ (void *cls,
+                                 const struct GNUNET_HashCode *file_id)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
 
   uc->fhc = NULL;
   if (uc->state != UNINDEX_STATE_HASHING)
-    {
-      GNUNET_FS_unindex_stop(uc);
-      return;
-    }
+  {
+    GNUNET_FS_unindex_stop (uc);
+    return;
+  }
   if (file_id == NULL)
-    {
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg = GNUNET_strdup(_("Failed to compute hash of file."));
-      GNUNET_FS_unindex_sync_(uc);
-      signal_unindex_error(uc);
-      return;
-    }
+  {
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg = GNUNET_strdup (_ ("Failed to compute hash of file."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
   uc->file_id = *file_id;
   uc->state = UNINDEX_STATE_DS_REMOVE;
-  GNUNET_FS_unindex_sync_(uc);
-  GNUNET_FS_unindex_do_remove_(uc);
+  GNUNET_FS_unindex_sync_ (uc);
+  GNUNET_FS_unindex_do_remove_ (uc);
 }
 
 
@@ -722,62 +724,62 @@ GNUNET_FS_unindex_process_hash_(void *cls,
  * @param cls the `struct GNUNET_FS_UnindexContext` to signal for
  */
 void
-GNUNET_FS_unindex_signal_suspend_(void *cls)
+GNUNET_FS_unindex_signal_suspend_ (void *cls)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
   /* FIXME: lots of duplication with unindex_stop here! */
   if (uc->dscan != NULL)
-    {
-      GNUNET_FS_directory_scan_abort(uc->dscan);
-      uc->dscan = NULL;
-    }
+  {
+    GNUNET_FS_directory_scan_abort (uc->dscan);
+    uc->dscan = NULL;
+  }
   if (NULL != uc->dqe)
-    {
-      GNUNET_DATASTORE_cancel(uc->dqe);
-      uc->dqe = NULL;
-    }
+  {
+    GNUNET_DATASTORE_cancel (uc->dqe);
+    uc->dqe = NULL;
+  }
   if (uc->fhc != NULL)
-    {
-      GNUNET_CRYPTO_hash_file_cancel(uc->fhc);
-      uc->fhc = NULL;
-    }
+  {
+    GNUNET_CRYPTO_hash_file_cancel (uc->fhc);
+    uc->fhc = NULL;
+  }
   if (NULL != uc->ksk_uri)
-    {
-      GNUNET_FS_uri_destroy(uc->ksk_uri);
-      uc->ksk_uri = NULL;
-    }
+  {
+    GNUNET_FS_uri_destroy (uc->ksk_uri);
+    uc->ksk_uri = NULL;
+  }
   if (NULL != uc->mq)
-    {
-      GNUNET_MQ_destroy(uc->mq);
-      uc->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (uc->mq);
+    uc->mq = NULL;
+  }
   if (NULL != uc->dsh)
-    {
-      GNUNET_DATASTORE_disconnect(uc->dsh, GNUNET_NO);
-      uc->dsh = NULL;
-    }
+  {
+    GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
+    uc->dsh = NULL;
+  }
   if (NULL != uc->tc)
-    {
-      GNUNET_FS_tree_encoder_finish(uc->tc, NULL);
-      uc->tc = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (uc->tc, NULL);
+    uc->tc = NULL;
+  }
   if (uc->fh != NULL)
-    {
-      GNUNET_DISK_file_close(uc->fh);
-      uc->fh = NULL;
-    }
-  GNUNET_FS_end_top(uc->h, uc->top);
+  {
+    GNUNET_DISK_file_close (uc->fh);
+    uc->fh = NULL;
+  }
+  GNUNET_FS_end_top (uc->h, uc->top);
   pi.status = GNUNET_FS_STATUS_UNINDEX_SUSPEND;
-  GNUNET_FS_unindex_make_status_(&pi, uc,
-                                 (uc->state ==
-                                  UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
-  GNUNET_break(NULL == uc->client_info);
-  GNUNET_free(uc->filename);
-  GNUNET_free_non_null(uc->serialization);
-  GNUNET_free_non_null(uc->emsg);
-  GNUNET_free(uc);
+  GNUNET_FS_unindex_make_status_ (&pi, uc,
+                                  (uc->state ==
+                                   UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
+  GNUNET_break (NULL == uc->client_info);
+  GNUNET_free (uc->filename);
+  GNUNET_free_non_null (uc->serialization);
+  GNUNET_free_non_null (uc->emsg);
+  GNUNET_free (uc);
 }
 
 
@@ -790,38 +792,38 @@ GNUNET_FS_unindex_signal_suspend_(void *cls)
  * @return NULL on error, otherwise handle
  */
 struct GNUNET_FS_UnindexContext *
-GNUNET_FS_unindex_start(struct GNUNET_FS_Handle *h,
-                        const char *filename,
-                        void *cctx)
+GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h,
+                         const char *filename,
+                         void *cctx)
 {
   struct GNUNET_FS_UnindexContext *uc;
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t size;
 
   if (GNUNET_OK !=
-      GNUNET_DISK_file_size(filename,
-                            &size,
-                            GNUNET_YES,
-                            GNUNET_YES))
+      GNUNET_DISK_file_size (filename,
+                             &size,
+                             GNUNET_YES,
+                             GNUNET_YES))
     return NULL;
-  uc = GNUNET_new(struct GNUNET_FS_UnindexContext);
+  uc = GNUNET_new (struct GNUNET_FS_UnindexContext);
   uc->h = h;
-  uc->filename = GNUNET_strdup(filename);
-  uc->start_time = GNUNET_TIME_absolute_get();
+  uc->filename = GNUNET_strdup (filename);
+  uc->start_time = GNUNET_TIME_absolute_get ();
   uc->file_size = size;
   uc->client_info = cctx;
-  GNUNET_FS_unindex_sync_(uc);
+  GNUNET_FS_unindex_sync_ (uc);
   pi.status = GNUNET_FS_STATUS_UNINDEX_START;
   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
-  GNUNET_FS_unindex_make_status_(&pi, uc, 0);
+  GNUNET_FS_unindex_make_status_ (&pi, uc, 0);
   uc->fhc =
-    GNUNET_CRYPTO_hash_file(GNUNET_SCHEDULER_PRIORITY_IDLE,
-                            filename,
-                            HASHING_BLOCKSIZE,
-                            &GNUNET_FS_unindex_process_hash_, uc);
-  uc->top = GNUNET_FS_make_top(h,
-                               &GNUNET_FS_unindex_signal_suspend_,
-                               uc);
+    GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                             filename,
+                             HASHING_BLOCKSIZE,
+                             &GNUNET_FS_unindex_process_hash_, uc);
+  uc->top = GNUNET_FS_make_top (h,
+                                &GNUNET_FS_unindex_signal_suspend_,
+                                uc);
   return uc;
 }
 
@@ -832,67 +834,67 @@ GNUNET_FS_unindex_start(struct GNUNET_FS_Handle *h,
  * @param uc handle
  */
 void
-GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
+GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc)
 {
   struct GNUNET_FS_ProgressInfo pi;
 
   if (NULL != uc->dscan)
-    {
-      GNUNET_FS_directory_scan_abort(uc->dscan);
-      uc->dscan = NULL;
-    }
+  {
+    GNUNET_FS_directory_scan_abort (uc->dscan);
+    uc->dscan = NULL;
+  }
   if (NULL != uc->dqe)
-    {
-      GNUNET_DATASTORE_cancel(uc->dqe);
-      uc->dqe = NULL;
-    }
+  {
+    GNUNET_DATASTORE_cancel (uc->dqe);
+    uc->dqe = NULL;
+  }
   if (NULL != uc->fhc)
-    {
-      GNUNET_CRYPTO_hash_file_cancel(uc->fhc);
-      uc->fhc = NULL;
-    }
+  {
+    GNUNET_CRYPTO_hash_file_cancel (uc->fhc);
+    uc->fhc = NULL;
+  }
   if (NULL != uc->mq)
-    {
-      GNUNET_MQ_destroy(uc->mq);
-      uc->mq = NULL;
-    }
+  {
+    GNUNET_MQ_destroy (uc->mq);
+    uc->mq = NULL;
+  }
   if (NULL != uc->dsh)
-    {
-      GNUNET_DATASTORE_disconnect(uc->dsh, GNUNET_NO);
-      uc->dsh = NULL;
-    }
+  {
+    GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
+    uc->dsh = NULL;
+  }
   if (NULL != uc->ksk_uri)
-    {
-      GNUNET_FS_uri_destroy(uc->ksk_uri);
-      uc->ksk_uri = NULL;
-    }
+  {
+    GNUNET_FS_uri_destroy (uc->ksk_uri);
+    uc->ksk_uri = NULL;
+  }
   if (NULL != uc->tc)
-    {
-      GNUNET_FS_tree_encoder_finish(uc->tc, NULL);
-      uc->tc = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (uc->tc, NULL);
+    uc->tc = NULL;
+  }
   if (uc->fh != NULL)
-    {
-      GNUNET_DISK_file_close(uc->fh);
-      uc->fh = NULL;
-    }
-  GNUNET_FS_end_top(uc->h, uc->top);
+  {
+    GNUNET_DISK_file_close (uc->fh);
+    uc->fh = NULL;
+  }
+  GNUNET_FS_end_top (uc->h, uc->top);
   if (uc->serialization != NULL)
-    {
-      GNUNET_FS_remove_sync_file_(uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
-                                  uc->serialization);
-      GNUNET_free(uc->serialization);
-      uc->serialization = NULL;
-    }
+  {
+    GNUNET_FS_remove_sync_file_ (uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
+                                 uc->serialization);
+    GNUNET_free (uc->serialization);
+    uc->serialization = NULL;
+  }
   pi.status = GNUNET_FS_STATUS_UNINDEX_STOPPED;
   pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
-  GNUNET_FS_unindex_make_status_(&pi, uc,
-                                 (uc->state ==
-                                  UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
-  GNUNET_break(NULL == uc->client_info);
-  GNUNET_free_non_null(uc->emsg);
-  GNUNET_free(uc->filename);
-  GNUNET_free(uc);
+  GNUNET_FS_unindex_make_status_ (&pi, uc,
+                                  (uc->state ==
+                                   UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
+  GNUNET_break (NULL == uc->client_info);
+  GNUNET_free_non_null (uc->emsg);
+  GNUNET_free (uc->filename);
+  GNUNET_free (uc);
 }
 
 /* end of fs_unindex.c */
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index c9ce19114..7eb9f86b0 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -100,47 +100,47 @@
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_FS_uri_to_key(const struct GNUNET_FS_Uri *uri,
-                     struct GNUNET_HashCode *key)
+GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri,
+                      struct GNUNET_HashCode *key)
 {
   switch (uri->type)
+  {
+  case GNUNET_FS_URI_CHK:
+    *key = uri->data.chk.chk.query;
+    return GNUNET_OK;
+
+  case GNUNET_FS_URI_SKS:
+    GNUNET_CRYPTO_hash (uri->data.sks.identifier,
+                        strlen (uri->data.sks.identifier),
+                        key);
+    return GNUNET_OK;
+
+  case GNUNET_FS_URI_KSK:
+    if (uri->data.ksk.keywordCount > 0)
     {
-    case GNUNET_FS_URI_CHK:
-      *key = uri->data.chk.chk.query;
+      GNUNET_CRYPTO_hash (uri->data.ksk.keywords[0],
+                          strlen (uri->data.ksk.keywords[0]),
+                          key);
       return GNUNET_OK;
-
-    case GNUNET_FS_URI_SKS:
-      GNUNET_CRYPTO_hash(uri->data.sks.identifier,
-                         strlen(uri->data.sks.identifier),
-                         key);
-      return GNUNET_OK;
-
-    case GNUNET_FS_URI_KSK:
-      if (uri->data.ksk.keywordCount > 0)
-        {
-          GNUNET_CRYPTO_hash(uri->data.ksk.keywords[0],
-                             strlen(uri->data.ksk.keywords[0]),
-                             key);
-          return GNUNET_OK;
-        }
-      else
-        {
-          memset(key, 0, sizeof(struct GNUNET_HashCode));
-          return GNUNET_SYSERR;
-        }
-      break;
-
-    case GNUNET_FS_URI_LOC:
-      GNUNET_CRYPTO_hash(&uri->data.loc.fi,
-                         sizeof(struct FileIdentifier) +
-                         sizeof(struct GNUNET_PeerIdentity),
-                         key);
-      return GNUNET_OK;
-
-    default:
-      memset(key, 0, sizeof(struct GNUNET_HashCode));
+    }
+    else
+    {
+      memset (key, 0, sizeof(struct GNUNET_HashCode));
       return GNUNET_SYSERR;
     }
+    break;
+
+  case GNUNET_FS_URI_LOC:
+    GNUNET_CRYPTO_hash (&uri->data.loc.fi,
+                        sizeof(struct FileIdentifier)
+                        + sizeof(struct GNUNET_PeerIdentity),
+                        key);
+    return GNUNET_OK;
+
+  default:
+    memset (key, 0, sizeof(struct GNUNET_HashCode));
+    return GNUNET_SYSERR;
+  }
 }
 
 
@@ -152,7 +152,7 @@ GNUNET_FS_uri_to_key(const struct GNUNET_FS_Uri *uri,
  * @return string with the keywords
  */
 char *
-GNUNET_FS_uri_ksk_to_string_fancy(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_ksk_to_string_fancy (const struct GNUNET_FS_Uri *uri)
 {
   size_t n;
   char *ret;
@@ -162,45 +162,45 @@ GNUNET_FS_uri_ksk_to_string_fancy(const struct GNUNET_FS_Uri *uri)
   unsigned int keywordCount;
 
   if ((NULL == uri) || (GNUNET_FS_URI_KSK != uri->type))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   keywords = uri->data.ksk.keywords;
   keywordCount = uri->data.ksk.keywordCount;
   n = keywordCount + 1;
   for (i = 0; i < keywordCount; i++)
+  {
+    keyword = keywords[i];
+    n += strlen (keyword) - 1;
+    if (NULL != strstr (&keyword[1], " "))
+      n += 2;
+    if (keyword[0] == '+')
+      n++;
+  }
+  ret = GNUNET_malloc (n);
+  strcpy (ret, "");
+  for (i = 0; i < keywordCount; i++)
+  {
+    keyword = keywords[i];
+    if (NULL != strstr (&keyword[1], " "))
     {
-      keyword = keywords[i];
-      n += strlen(keyword) - 1;
-      if (NULL != strstr(&keyword[1], " "))
-        n += 2;
+      strcat (ret, "\"");
       if (keyword[0] == '+')
-        n++;
+        strcat (ret, keyword);
+      else
+        strcat (ret, &keyword[1]);
+      strcat (ret, "\"");
     }
-  ret = GNUNET_malloc(n);
-  strcpy(ret, "");
-  for (i = 0; i < keywordCount; i++)
+    else
     {
-      keyword = keywords[i];
-      if (NULL != strstr(&keyword[1], " "))
-        {
-          strcat(ret, "\"");
-          if (keyword[0] == '+')
-            strcat(ret, keyword);
-          else
-            strcat(ret, &keyword[1]);
-          strcat(ret, "\"");
-        }
+      if (keyword[0] == '+')
+        strcat (ret, keyword);
       else
-        {
-          if (keyword[0] == '+')
-            strcat(ret, keyword);
-          else
-            strcat(ret, &keyword[1]);
-        }
-      strcat(ret, " ");
+        strcat (ret, &keyword[1]);
     }
+    strcat (ret, " ");
+  }
   return ret;
 }
 
@@ -216,7 +216,7 @@ GNUNET_FS_uri_ksk_to_string_fancy(const struct GNUNET_FS_Uri *uri)
  * @return decodded string with leading space (or preserved plus)
  */
 static char *
-percent_decode_keyword(const char *in, char **emsg)
+percent_decode_keyword (const char *in, char **emsg)
 {
   char *out;
   char *ret;
@@ -224,44 +224,44 @@ percent_decode_keyword(const char *in, char **emsg)
   unsigned int wpos;
   unsigned int hx;
 
-  out = GNUNET_strdup(in);
+  out = GNUNET_strdup (in);
   rpos = 0;
   wpos = 0;
   while (out[rpos] != '\0')
+  {
+    if (out[rpos] == '%')
     {
-      if (out[rpos] == '%')
-        {
-          if (1 != sscanf(&out[rpos + 1], "%2X", &hx))
-            {
-              GNUNET_free(out);
-              *emsg = GNUNET_strdup(
-                _(/* xgettext:no-c-format */
-                  "Malformed KSK URI (`%' must be followed by HEX number)"));
-              return NULL;
-            }
-          rpos += 3;
-          if (hx == '"')
-            continue; /* skip double quote */
-          out[wpos++] = (char)hx;
-        }
-      else
-        {
-          out[wpos++] = out[rpos++];
-        }
+      if (1 != sscanf (&out[rpos + 1], "%2X", &hx))
+      {
+        GNUNET_free (out);
+        *emsg = GNUNET_strdup (
+          _ (     /* xgettext:no-c-format */
+            "Malformed KSK URI (`%' must be followed by HEX number)"));
+        return NULL;
+      }
+      rpos += 3;
+      if (hx == '"')
+        continue;     /* skip double quote */
+      out[wpos++] = (char) hx;
     }
-  out[wpos] = '\0';
-  if (out[0] == '+')
+    else
     {
-      ret = GNUNET_strdup(out);
+      out[wpos++] = out[rpos++];
     }
+  }
+  out[wpos] = '\0';
+  if (out[0] == '+')
+  {
+    ret = GNUNET_strdup (out);
+  }
   else
-    {
-      /* need to prefix with space */
-      ret = GNUNET_malloc(strlen(out) + 2);
-      strcpy(ret, " ");
-      strcat(ret, out);
-    }
-  GNUNET_free(out);
+  {
+    /* need to prefix with space */
+    ret = GNUNET_malloc (strlen (out) + 2);
+    strcpy (ret, " ");
+    strcat (ret, out);
+  }
+  GNUNET_free (out);
   return ret;
 }
 
@@ -275,7 +275,7 @@ percent_decode_keyword(const char *in, char **emsg)
  * @return NULL on error, otherwise the KSK URI
  */
 static struct GNUNET_FS_Uri *
-uri_ksk_parse(const char *s, char **emsg)
+uri_ksk_parse (const char *s, char **emsg)
 {
   struct GNUNET_FS_Uri *ret;
   char **keywords;
@@ -287,74 +287,74 @@ uri_ksk_parse(const char *s, char **emsg)
   char *dup;
   int saw_quote;
 
-  slen = strlen(s);
-  pos = strlen(GNUNET_FS_URI_KSK_PREFIX);
-  if ((slen <= pos) || (0 != strncmp(s, GNUNET_FS_URI_KSK_PREFIX, pos)))
+  slen = strlen (s);
+  pos = strlen (GNUNET_FS_URI_KSK_PREFIX);
+  if ((slen <= pos) || (0 != strncmp (s, GNUNET_FS_URI_KSK_PREFIX, pos)))
     return NULL; /* not KSK URI */
   if ((s[slen - 1] == '+') || (s[pos] == '+'))
-    {
-      *emsg =
-        GNUNET_strdup(_("Malformed KSK URI (must not begin or end with `+')"));
-      return NULL;
-    }
+  {
+    *emsg =
+      GNUNET_strdup (_ ("Malformed KSK URI (must not begin or end with `+')"));
+    return NULL;
+  }
   max = 1;
   saw_quote = 0;
   for (i = pos; i < slen; i++)
+  {
+    if ((s[i] == '%') && (&s[i] == strstr (&s[i], "%22")))
     {
-      if ((s[i] == '%') && (&s[i] == strstr(&s[i], "%22")))
-        {
-          saw_quote = (saw_quote + 1) % 2;
-          i += 3;
-          continue;
-        }
-      if ((s[i] == '+') && (saw_quote == 0))
-        {
-          max++;
-          if (s[i - 1] == '+')
-            {
-              *emsg = GNUNET_strdup(_("Malformed KSK URI (`++' not allowed)"));
-              return NULL;
-            }
-        }
+      saw_quote = (saw_quote + 1) % 2;
+      i += 3;
+      continue;
     }
-  if (saw_quote == 1)
+    if ((s[i] == '+') && (saw_quote == 0))
     {
-      *emsg = GNUNET_strdup(_("Malformed KSK URI (quotes not balanced)"));
-      return NULL;
+      max++;
+      if (s[i - 1] == '+')
+      {
+        *emsg = GNUNET_strdup (_ ("Malformed KSK URI (`++' not allowed)"));
+        return NULL;
+      }
     }
+  }
+  if (saw_quote == 1)
+  {
+    *emsg = GNUNET_strdup (_ ("Malformed KSK URI (quotes not balanced)"));
+    return NULL;
+  }
   iret = max;
-  dup = GNUNET_strdup(s);
-  keywords = GNUNET_new_array(max, char *);
-  for (i = slen - 1; i >= (int)pos; i--)
+  dup = GNUNET_strdup (s);
+  keywords = GNUNET_new_array (max, char *);
+  for (i = slen - 1; i >= (int) pos; i--)
+  {
+    if ((s[i] == '%') && (&s[i] == strstr (&s[i], "%22")))
     {
-      if ((s[i] == '%') && (&s[i] == strstr(&s[i], "%22")))
-        {
-          saw_quote = (saw_quote + 1) % 2;
-          continue;
-        }
-      if ((dup[i] == '+') && (saw_quote == 0))
-        {
-          keywords[--max] = percent_decode_keyword(&dup[i + 1], emsg);
-          if (NULL == keywords[max])
-            goto CLEANUP;
-          dup[i] = '\0';
-        }
+      saw_quote = (saw_quote + 1) % 2;
+      continue;
     }
-  keywords[--max] = percent_decode_keyword(&dup[pos], emsg);
+    if ((dup[i] == '+') && (saw_quote == 0))
+    {
+      keywords[--max] = percent_decode_keyword (&dup[i + 1], emsg);
+      if (NULL == keywords[max])
+        goto CLEANUP;
+      dup[i] = '\0';
+    }
+  }
+  keywords[--max] = percent_decode_keyword (&dup[pos], emsg);
   if (NULL == keywords[max])
     goto CLEANUP;
-  GNUNET_assert(0 == max);
-  GNUNET_free(dup);
-  ret = GNUNET_new(struct GNUNET_FS_Uri);
+  GNUNET_assert (0 == max);
+  GNUNET_free (dup);
+  ret = GNUNET_new (struct GNUNET_FS_Uri);
   ret->type = GNUNET_FS_URI_KSK;
   ret->data.ksk.keywordCount = iret;
   ret->data.ksk.keywords = keywords;
   return ret;
 CLEANUP:
   for (i = 0; i < max; i++)
-    GNUNET_free_non_null(keywords[i]);
-  GNUNET_free(keywords);
-  GNUNET_free(dup);
+    GNUNET_free_non_null (keywords[i]);
+  GNUNET_free (keywords);
+  GNUNET_free (dup);
   return NULL;
 }
 
@@ -369,31 +369,31 @@ CLEANUP:
  * @return NULL on error, SKS URI otherwise
  */
 static struct GNUNET_FS_Uri *
-uri_sks_parse(const char *s, char **emsg)
+uri_sks_parse (const char *s, char **emsg)
 {
   struct GNUNET_FS_Uri *ret;
   struct GNUNET_CRYPTO_EcdsaPublicKey ns;
   size_t pos;
   char *end;
 
-  pos = strlen(GNUNET_FS_URI_SKS_PREFIX);
-  if ((strlen(s) <= pos) || (0 != strncmp(s, GNUNET_FS_URI_SKS_PREFIX, pos)))
+  pos = strlen (GNUNET_FS_URI_SKS_PREFIX);
+  if ((strlen (s) <= pos) || (0 != strncmp (s, GNUNET_FS_URI_SKS_PREFIX, pos)))
     return NULL; /* not an SKS URI */
-  end = strchr(&s[pos], '/');
+  end = strchr (&s[pos], '/');
   if ((NULL == end) ||
-      (GNUNET_OK != GNUNET_STRINGS_string_to_data(&s[pos],
-                                                  end - &s[pos],
-                                                  &ns,
-                                                  sizeof(ns))))
-    {
-      *emsg = GNUNET_strdup(_("Malformed SKS URI (wrong syntax)"));
-      return NULL; /* malformed */
-    }
+      (GNUNET_OK != GNUNET_STRINGS_string_to_data (&s[pos],
+                                                   end - &s[pos],
+                                                   &ns,
+                                                   sizeof(ns))))
+  {
+    *emsg = GNUNET_strdup (_ ("Malformed SKS URI (wrong syntax)"));
+    return NULL;   /* malformed */
+  }
   end++; /* skip over '/' */
-  ret = GNUNET_new(struct GNUNET_FS_Uri);
+  ret = GNUNET_new (struct GNUNET_FS_Uri);
   ret->type = GNUNET_FS_URI_SKS;
   ret->data.sks.ns = ns;
-  ret->data.sks.identifier = GNUNET_strdup(end);
+  ret->data.sks.identifier = GNUNET_strdup (end);
   return ret;
 }
 
@@ -408,7 +408,7 @@ uri_sks_parse(const char *s, char **emsg)
  * @return NULL on error, CHK URI otherwise
  */
 static struct GNUNET_FS_Uri *
-uri_chk_parse(const char *s, char **emsg)
+uri_chk_parse (const char *s, char **emsg)
 {
   struct GNUNET_FS_Uri *ret;
   struct FileIdentifier fi;
@@ -418,36 +418,36 @@ uri_chk_parse(const char *s, char **emsg)
   char h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
   char h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
 
-  slen = strlen(s);
-  pos = strlen(GNUNET_FS_URI_CHK_PREFIX);
+  slen = strlen (s);
+  pos = strlen (GNUNET_FS_URI_CHK_PREFIX);
   if ((slen < pos + 2 * sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) + 1) ||
-      (0 != strncmp(s, GNUNET_FS_URI_CHK_PREFIX, pos)))
+      (0 != strncmp (s, GNUNET_FS_URI_CHK_PREFIX, pos)))
     return NULL; /* not a CHK URI */
   if ((s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '.') ||
       (s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2 - 1] != '.'))
-    {
-      *emsg = GNUNET_strdup(_("Malformed CHK URI (wrong syntax)"));
-      return NULL;
-    }
-  GNUNET_memcpy(h1, &s[pos], sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
+  {
+    *emsg = GNUNET_strdup (_ ("Malformed CHK URI (wrong syntax)"));
+    return NULL;
+  }
+  GNUNET_memcpy (h1, &s[pos], sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
   h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
-  GNUNET_memcpy(h2,
-                &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
-                sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
+  GNUNET_memcpy (h2,
+                 &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
+                 sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
   h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
 
-  if ((GNUNET_OK != GNUNET_CRYPTO_hash_from_string(h1, &fi.chk.key)) ||
-      (GNUNET_OK != GNUNET_CRYPTO_hash_from_string(h2, &fi.chk.query)) ||
+  if ((GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h1, &fi.chk.key)) ||
+      (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h2, &fi.chk.query)) ||
       (1 !=
-       sscanf(&s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
-              "%llu",
-              &flen)))
-    {
-      *emsg = GNUNET_strdup(_("Malformed CHK URI (failed to decode CHK)"));
-      return NULL;
-    }
-  fi.file_length = GNUNET_htonll(flen);
-  ret = GNUNET_new(struct GNUNET_FS_Uri);
+       sscanf (&s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
+               "%llu",
+               &flen)))
+  {
+    *emsg = GNUNET_strdup (_ ("Malformed CHK URI (failed to decode CHK)"));
+    return NULL;
+  }
+  fi.file_length = GNUNET_htonll (flen);
+  ret = GNUNET_new (struct GNUNET_FS_Uri);
   ret->type = GNUNET_FS_URI_CHK;
   ret->data.chk = fi;
   return ret;
@@ -460,7 +460,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
  * assembled in memory to create or verify the signature of a location
  * URI.
  */
-struct LocUriAssembly {
+struct LocUriAssembly
+{
   /**
    * What is being signed (rest of this struct).
    */
@@ -497,7 +498,7 @@ GNUNET_NETWORK_STRUCT_END
  * @return NULL on error, valid LOC URI otherwise
  */
 static struct GNUNET_FS_Uri *
-uri_loc_parse(const char *s, char **emsg)
+uri_loc_parse (const char *s, char **emsg)
 {
   struct GNUNET_FS_Uri *uri;
   char h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
@@ -511,113 +512,113 @@ uri_loc_parse(const char *s, char **emsg)
   struct LocUriAssembly ass;
   size_t slen;
 
-  slen = strlen(s);
-  pos = strlen(GNUNET_FS_URI_LOC_PREFIX);
+  slen = strlen (s);
+  pos = strlen (GNUNET_FS_URI_LOC_PREFIX);
   if ((slen < pos + 2 * sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) + 1) ||
-      (0 != strncmp(s, GNUNET_FS_URI_LOC_PREFIX, pos)))
+      (0 != strncmp (s, GNUNET_FS_URI_LOC_PREFIX, pos)))
     return NULL; /* not a LOC URI */
   if ((s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '.') ||
       (s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2 - 1] != '.'))
-    {
-      *emsg = GNUNET_strdup(_("LOC URI malformed (wrong syntax)"));
-      return NULL;
-    }
-  GNUNET_memcpy(h1, &s[pos], sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
+  {
+    *emsg = GNUNET_strdup (_ ("LOC URI malformed (wrong syntax)"));
+    return NULL;
+  }
+  GNUNET_memcpy (h1, &s[pos], sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
   h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
-  GNUNET_memcpy(h2,
-                &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
-                sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
+  GNUNET_memcpy (h2,
+                 &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
+                 sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
   h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
 
-  if ((GNUNET_OK != GNUNET_CRYPTO_hash_from_string(h1, &ass.fi.chk.key)) ||
-      (GNUNET_OK != GNUNET_CRYPTO_hash_from_string(h2, &ass.fi.chk.query)) ||
+  if ((GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h1, &ass.fi.chk.key)) ||
+      (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (h2, &ass.fi.chk.query)) ||
       (1 !=
-       sscanf(&s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
-              "%llu",
-              &flen)))
-    {
-      *emsg = GNUNET_strdup(_("LOC URI malformed (no CHK)"));
-      return NULL;
-    }
-  ass.fi.file_length = GNUNET_htonll(flen);
+       sscanf (&s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
+               "%llu",
+               &flen)))
+  {
+    *emsg = GNUNET_strdup (_ ("LOC URI malformed (no CHK)"));
+    return NULL;
+  }
+  ass.fi.file_length = GNUNET_htonll (flen);
 
   npos = pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded) * 2;
   while ((s[npos] != '\0') && (s[npos] != '.'))
     npos++;
   if (s[npos] == '\0')
-    {
-      *emsg = GNUNET_strdup(_("LOC URI malformed (missing LOC)"));
-      goto ERR;
-    }
+  {
+    *emsg = GNUNET_strdup (_ ("LOC URI malformed (missing LOC)"));
+    goto ERR;
+  }
   npos++;
-  if ((strlen(&s[npos]) <= GNUNET_CRYPTO_PKEY_ASCII_LENGTH + 1) ||
+  if ((strlen (&s[npos]) <= GNUNET_CRYPTO_PKEY_ASCII_LENGTH + 1) ||
       ('.' != s[npos + GNUNET_CRYPTO_PKEY_ASCII_LENGTH]))
-    {
-      *emsg =
-        GNUNET_strdup(_("LOC URI malformed (wrong syntax for public key)"));
-    }
+  {
+    *emsg =
+      GNUNET_strdup (_ ("LOC URI malformed (wrong syntax for public key)"));
+  }
   if (
     GNUNET_OK !=
-    GNUNET_CRYPTO_eddsa_public_key_from_string(&s[npos],
-                                               GNUNET_CRYPTO_PKEY_ASCII_LENGTH,
-                                               &ass.peer.public_key))
-    {
-      *emsg =
-        GNUNET_strdup(_("LOC URI malformed (could not decode public key)"));
-      goto ERR;
-    }
+    GNUNET_CRYPTO_eddsa_public_key_from_string (&s[npos],
+                                                GNUNET_CRYPTO_PKEY_ASCII_LENGTH,
+                                                &ass.peer.public_key))
+  {
+    *emsg =
+      GNUNET_strdup (_ ("LOC URI malformed (could not decode public key)"));
+    goto ERR;
+  }
   npos += GNUNET_CRYPTO_PKEY_ASCII_LENGTH;
   if (s[npos++] != '.')
-    {
-      *emsg = GNUNET_strdup(_("LOC URI malformed (could not find signature)"));
-      goto ERR;
-    }
-  if ((strlen(&s[npos]) <= SIGNATURE_ASCII_LENGTH + 1) ||
+  {
+    *emsg = GNUNET_strdup (_ ("LOC URI malformed (could not find signature)"));
+    goto ERR;
+  }
+  if ((strlen (&s[npos]) <= SIGNATURE_ASCII_LENGTH + 1) ||
       ('.' != s[npos + SIGNATURE_ASCII_LENGTH]))
-    {
-      *emsg =
-        GNUNET_strdup(_("LOC URI malformed (wrong syntax for signature)"));
-      goto ERR;
-    }
+  {
+    *emsg =
+      GNUNET_strdup (_ ("LOC URI malformed (wrong syntax for signature)"));
+    goto ERR;
+  }
   if (GNUNET_OK !=
-      GNUNET_STRINGS_string_to_data(&s[npos],
-                                    SIGNATURE_ASCII_LENGTH,
-                                    &sig,
-                                    sizeof(
-                                      struct GNUNET_CRYPTO_EddsaSignature)))
-    {
-      *emsg =
-        GNUNET_strdup(_("LOC URI malformed (could not decode signature)"));
-      goto ERR;
-    }
+      GNUNET_STRINGS_string_to_data (&s[npos],
+                                     SIGNATURE_ASCII_LENGTH,
+                                     &sig,
+                                     sizeof(
+                                       struct GNUNET_CRYPTO_EddsaSignature)))
+  {
+    *emsg =
+      GNUNET_strdup (_ ("LOC URI malformed (could not decode signature)"));
+    goto ERR;
+  }
   npos += SIGNATURE_ASCII_LENGTH;
   if (s[npos++] != '.')
-    {
-      *emsg = GNUNET_strdup(
-        _("LOC URI malformed (wrong syntax for expiration time)"));
-      goto ERR;
-    }
-  if (1 != sscanf(&s[npos], "%llu", &exptime))
-    {
-      *emsg =
-        GNUNET_strdup(_("LOC URI malformed (could not parse expiration time)"));
-      goto ERR;
-    }
-  ass.purpose.size = htonl(sizeof(struct LocUriAssembly));
-  ass.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
+  {
+    *emsg = GNUNET_strdup (
+      _ ("LOC URI malformed (wrong syntax for expiration time)"));
+    goto ERR;
+  }
+  if (1 != sscanf (&s[npos], "%llu", &exptime))
+  {
+    *emsg =
+      GNUNET_strdup (_ ("LOC URI malformed (could not parse expiration time)"));
+    goto ERR;
+  }
+  ass.purpose.size = htonl (sizeof(struct LocUriAssembly));
+  ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
   et.abs_value_us = exptime * 1000LL * 1000LL;
-  ass.exptime = GNUNET_TIME_absolute_hton(et);
+  ass.exptime = GNUNET_TIME_absolute_hton (et);
   if (GNUNET_OK !=
-      GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT,
-                                 &ass.purpose,
-                                 &sig,
-                                 &ass.peer.public_key))
-    {
-      *emsg =
-        GNUNET_strdup(_("LOC URI malformed (signature failed validation)"));
-      goto ERR;
-    }
-  uri = GNUNET_new(struct GNUNET_FS_Uri);
+      GNUNET_CRYPTO_eddsa_verify (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT,
+                                  &ass.purpose,
+                                  &sig,
+                                  &ass.peer.public_key))
+  {
+    *emsg =
+      GNUNET_strdup (_ ("LOC URI malformed (signature failed validation)"));
+    goto ERR;
+  }
+  uri = GNUNET_new (struct GNUNET_FS_Uri);
   uri->type = GNUNET_FS_URI_LOC;
   uri->data.loc.fi = ass.fi;
   uri->data.loc.peer = ass.peer;
@@ -638,30 +639,30 @@ ERR:
  * @return NULL on error
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_parse(const char *uri, char **emsg)
+GNUNET_FS_uri_parse (const char *uri, char **emsg)
 {
   struct GNUNET_FS_Uri *ret;
   char *msg;
 
   if (NULL == uri)
-    {
-      GNUNET_break(0);
-      if (NULL != emsg)
-        *emsg = GNUNET_strdup(_("invalid argument"));
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    if (NULL != emsg)
+      *emsg = GNUNET_strdup (_ ("invalid argument"));
+    return NULL;
+  }
   if (NULL == emsg)
     emsg = &msg;
   *emsg = NULL;
-  if ((NULL != (ret = uri_chk_parse(uri, emsg))) ||
-      (NULL != (ret = uri_ksk_parse(uri, emsg))) ||
-      (NULL != (ret = uri_sks_parse(uri, emsg))) ||
-      (NULL != (ret = uri_loc_parse(uri, emsg))))
+  if ((NULL != (ret = uri_chk_parse (uri, emsg))) ||
+      (NULL != (ret = uri_ksk_parse (uri, emsg))) ||
+      (NULL != (ret = uri_sks_parse (uri, emsg))) ||
+      (NULL != (ret = uri_loc_parse (uri, emsg))))
     return ret;
   if (NULL == *emsg)
-    *emsg = GNUNET_strdup(_("Unrecognized URI type"));
+    *emsg = GNUNET_strdup (_ ("Unrecognized URI type"));
   if (emsg == &msg)
-    GNUNET_free(msg);
+    GNUNET_free (msg);
   return NULL;
 }
 
@@ -672,30 +673,30 @@ GNUNET_FS_uri_parse(const char *uri, char **emsg)
  * @param uri uri to free
  */
 void
-GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_destroy (struct GNUNET_FS_Uri *uri)
 {
   unsigned int i;
 
   switch (uri->type)
-    {
-    case GNUNET_FS_URI_KSK:
-      for (i = 0; i < uri->data.ksk.keywordCount; i++)
-        GNUNET_free(uri->data.ksk.keywords[i]);
-      GNUNET_array_grow(uri->data.ksk.keywords, uri->data.ksk.keywordCount, 0);
-      break;
-
-    case GNUNET_FS_URI_SKS:
-      GNUNET_free(uri->data.sks.identifier);
-      break;
-
-    case GNUNET_FS_URI_LOC:
-      break;
-
-    default:
-      /* do nothing */
-      break;
-    }
-  GNUNET_free(uri);
+  {
+  case GNUNET_FS_URI_KSK:
+    for (i = 0; i < uri->data.ksk.keywordCount; i++)
+      GNUNET_free (uri->data.ksk.keywords[i]);
+    GNUNET_array_grow (uri->data.ksk.keywords, uri->data.ksk.keywordCount, 0);
+    break;
+
+  case GNUNET_FS_URI_SKS:
+    GNUNET_free (uri->data.sks.identifier);
+    break;
+
+  case GNUNET_FS_URI_LOC:
+    break;
+
+  default:
+    /* do nothing */
+    break;
+  }
+  GNUNET_free (uri);
 }
 
 
@@ -706,7 +707,7 @@ GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
  * @return 0 if this is not a keyword URI
  */
 unsigned int
-GNUNET_FS_uri_ksk_get_keyword_count(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_ksk_get_keyword_count (const struct GNUNET_FS_Uri *uri)
 {
   if (uri->type != GNUNET_FS_URI_KSK)
     return 0;
@@ -724,9 +725,9 @@ GNUNET_FS_uri_ksk_get_keyword_count(const struct GNUNET_FS_Uri *uri)
  *   keywords iterated over until iterator aborted
  */
 int
-GNUNET_FS_uri_ksk_get_keywords(const struct GNUNET_FS_Uri *uri,
-                               GNUNET_FS_KeywordIterator iterator,
-                               void *iterator_cls)
+GNUNET_FS_uri_ksk_get_keywords (const struct GNUNET_FS_Uri *uri,
+                                GNUNET_FS_KeywordIterator iterator,
+                                void *iterator_cls)
 {
   unsigned int i;
   char *keyword;
@@ -736,13 +737,13 @@ GNUNET_FS_uri_ksk_get_keywords(const struct GNUNET_FS_Uri *uri,
   if (NULL == iterator)
     return uri->data.ksk.keywordCount;
   for (i = 0; i < uri->data.ksk.keywordCount; i++)
-    {
-      keyword = uri->data.ksk.keywords[i];
-      /* first character of keyword indicates
-       * if it is mandatory or not */
-      if (GNUNET_OK != iterator(iterator_cls, &keyword[1], keyword[0] == '+'))
-        return i;
-    }
+  {
+    keyword = uri->data.ksk.keywords[i];
+    /* first character of keyword indicates
+     * if it is mandatory or not */
+    if (GNUNET_OK != iterator (iterator_cls, &keyword[1],(keyword[0] == '+') ))
+      return i;
+  }
   return i;
 }
 
@@ -756,23 +757,23 @@ GNUNET_FS_uri_ksk_get_keywords(const struct GNUNET_FS_Uri *uri,
  * @param is_mandatory is this keyword mandatory?
  */
 void
-GNUNET_FS_uri_ksk_add_keyword(struct GNUNET_FS_Uri *uri,
-                              const char *keyword,
-                              int is_mandatory)
+GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri,
+                               const char *keyword,
+                               int is_mandatory)
 {
   unsigned int i;
   const char *old;
   char *n;
 
-  GNUNET_assert(uri->type == GNUNET_FS_URI_KSK);
+  GNUNET_assert (uri->type == GNUNET_FS_URI_KSK);
   for (i = 0; i < uri->data.ksk.keywordCount; i++)
-    {
-      old = uri->data.ksk.keywords[i];
-      if (0 == strcmp(&old[1], keyword))
-        return;
-    }
-  GNUNET_asprintf(&n, is_mandatory ? "+%s" : " %s", keyword);
-  GNUNET_array_append(uri->data.ksk.keywords, uri->data.ksk.keywordCount, n);
+  {
+    old = uri->data.ksk.keywords[i];
+    if (0 == strcmp (&old[1], keyword))
+      return;
+  }
+  GNUNET_asprintf (&n, is_mandatory ? "+%s" : " %s", keyword);
+  GNUNET_array_append (uri->data.ksk.keywords, uri->data.ksk.keywordCount, n);
 }
 
 
@@ -784,27 +785,27 @@ GNUNET_FS_uri_ksk_add_keyword(struct GNUNET_FS_Uri *uri,
  * @param keyword keyword to add
  */
 void
-GNUNET_FS_uri_ksk_remove_keyword(struct GNUNET_FS_Uri *uri,
-                                 const char *keyword)
+GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri *uri,
+                                  const char *keyword)
 {
   unsigned int i;
   char *old;
 
-  GNUNET_assert(uri->type == GNUNET_FS_URI_KSK);
+  GNUNET_assert (uri->type == GNUNET_FS_URI_KSK);
   for (i = 0; i < uri->data.ksk.keywordCount; i++)
+  {
+    old = uri->data.ksk.keywords[i];
+    if (0 == strcmp (&old[1], keyword))
     {
-      old = uri->data.ksk.keywords[i];
-      if (0 == strcmp(&old[1], keyword))
-        {
-          uri->data.ksk.keywords[i] =
-            uri->data.ksk.keywords[uri->data.ksk.keywordCount - 1];
-          GNUNET_array_grow(uri->data.ksk.keywords,
-                            uri->data.ksk.keywordCount,
-                            uri->data.ksk.keywordCount - 1);
-          GNUNET_free(old);
-          return;
-        }
+      uri->data.ksk.keywords[i] =
+        uri->data.ksk.keywords[uri->data.ksk.keywordCount - 1];
+      GNUNET_array_grow (uri->data.ksk.keywords,
+                         uri->data.ksk.keywordCount,
+                         uri->data.ksk.keywordCount - 1);
+      GNUNET_free (old);
+      return;
     }
+  }
 }
 
 
@@ -816,8 +817,8 @@ GNUNET_FS_uri_ksk_remove_keyword(struct GNUNET_FS_Uri *uri,
  * @return #GNUNET_SYSERR if this is not a location URI, otherwise #GNUNET_OK
  */
 int
-GNUNET_FS_uri_loc_get_peer_identity(const struct GNUNET_FS_Uri *uri,
-                                    struct GNUNET_PeerIdentity *peer)
+GNUNET_FS_uri_loc_get_peer_identity (const struct GNUNET_FS_Uri *uri,
+                                     struct GNUNET_PeerIdentity *peer)
 {
   if (uri->type != GNUNET_FS_URI_LOC)
     return GNUNET_SYSERR;
@@ -833,9 +834,9 @@ GNUNET_FS_uri_loc_get_peer_identity(const struct GNUNET_FS_Uri *uri,
  * @return expiration time of the URI
  */
 struct GNUNET_TIME_Absolute
-GNUNET_FS_uri_loc_get_expiration(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_loc_get_expiration (const struct GNUNET_FS_Uri *uri)
 {
-  GNUNET_assert(uri->type == GNUNET_FS_URI_LOC);
+  GNUNET_assert (uri->type == GNUNET_FS_URI_LOC);
   return uri->data.loc.expirationTime;
 }
 
@@ -847,13 +848,13 @@ GNUNET_FS_uri_loc_get_expiration(const struct GNUNET_FS_Uri *uri)
  * @return NULL if argument is not a location URI
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_loc_get_uri(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_loc_get_uri (const struct GNUNET_FS_Uri *uri)
 {
   struct GNUNET_FS_Uri *ret;
 
   if (uri->type != GNUNET_FS_URI_LOC)
     return NULL;
-  ret = GNUNET_new(struct GNUNET_FS_Uri);
+  ret = GNUNET_new (struct GNUNET_FS_Uri);
   ret->type = GNUNET_FS_URI_CHK;
   ret->data.chk = uri->data.loc.fi;
   return ret;
@@ -873,9 +874,9 @@ GNUNET_FS_uri_loc_get_uri(const struct GNUNET_FS_Uri *uri)
  * @return the location URI, NULL on error
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_loc_create(const struct GNUNET_FS_Uri *base_uri,
-                         const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key,
-                         struct GNUNET_TIME_Absolute expiration_time)
+GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *base_uri,
+                          const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key,
+                          struct GNUNET_TIME_Absolute expiration_time)
 {
   struct GNUNET_FS_Uri *uri;
   struct GNUNET_CRYPTO_EddsaPublicKey my_public_key;
@@ -886,21 +887,21 @@ GNUNET_FS_uri_loc_create(const struct GNUNET_FS_Uri *base_uri,
     return NULL;
   /* we round expiration time to full seconds for SKS URIs */
   et.abs_value_us = (expiration_time.abs_value_us / 1000000LL) * 1000000LL;
-  GNUNET_CRYPTO_eddsa_key_get_public(sign_key, &my_public_key);
-  ass.purpose.size = htonl(sizeof(struct LocUriAssembly));
-  ass.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
-  ass.exptime = GNUNET_TIME_absolute_hton(et);
+  GNUNET_CRYPTO_eddsa_key_get_public (sign_key, &my_public_key);
+  ass.purpose.size = htonl (sizeof(struct LocUriAssembly));
+  ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
+  ass.exptime = GNUNET_TIME_absolute_hton (et);
   ass.fi = base_uri->data.chk;
   ass.peer.public_key = my_public_key;
-  uri = GNUNET_new(struct GNUNET_FS_Uri);
+  uri = GNUNET_new (struct GNUNET_FS_Uri);
   uri->type = GNUNET_FS_URI_LOC;
   uri->data.loc.fi = base_uri->data.chk;
   uri->data.loc.expirationTime = et;
   uri->data.loc.peer.public_key = my_public_key;
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CRYPTO_eddsa_sign(sign_key,
-                                         &ass.purpose,
-                                         &uri->data.loc.contentSignature));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_eddsa_sign (sign_key,
+                                           &ass.purpose,
+                                           &uri->data.loc.contentSignature));
   return uri;
 }
 
@@ -913,15 +914,15 @@ GNUNET_FS_uri_loc_create(const struct GNUNET_FS_Uri *base_uri,
  * @return an FS URI for the given namespace and identifier
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_sks_create(const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
-                         const char *id)
+GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
+                          const char *id)
 {
   struct GNUNET_FS_Uri *ns_uri;
 
-  ns_uri = GNUNET_new(struct GNUNET_FS_Uri);
+  ns_uri = GNUNET_new (struct GNUNET_FS_Uri);
   ns_uri->type = GNUNET_FS_URI_SKS;
   ns_uri->data.sks.ns = *ns;
-  ns_uri->data.sks.identifier = GNUNET_strdup(id);
+  ns_uri->data.sks.identifier = GNUNET_strdup (id);
   return ns_uri;
 }
 
@@ -936,8 +937,8 @@ GNUNET_FS_uri_sks_create(const struct GNUNET_CRYPTO_EcdsaPublicKey *ns,
  * @return merged URI, NULL on error
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_merge(const struct GNUNET_FS_Uri *u1,
-                        const struct GNUNET_FS_Uri *u2)
+GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri *u1,
+                         const struct GNUNET_FS_Uri *u2)
 {
   struct GNUNET_FS_Uri *ret;
   unsigned int kc;
@@ -950,34 +951,34 @@ GNUNET_FS_uri_ksk_merge(const struct GNUNET_FS_Uri *u1,
   if ((u1 == NULL) && (u2 == NULL))
     return NULL;
   if (u1 == NULL)
-    return GNUNET_FS_uri_dup(u2);
+    return GNUNET_FS_uri_dup (u2);
   if (u2 == NULL)
-    return GNUNET_FS_uri_dup(u1);
+    return GNUNET_FS_uri_dup (u1);
   if ((u1->type != GNUNET_FS_URI_KSK) || (u2->type != GNUNET_FS_URI_KSK))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   kc = u1->data.ksk.keywordCount;
-  kl = GNUNET_new_array(kc + u2->data.ksk.keywordCount, char *);
+  kl = GNUNET_new_array (kc + u2->data.ksk.keywordCount, char *);
   for (i = 0; i < u1->data.ksk.keywordCount; i++)
-    kl[i] = GNUNET_strdup(u1->data.ksk.keywords[i]);
+    kl[i] = GNUNET_strdup (u1->data.ksk.keywords[i]);
   for (i = 0; i < u2->data.ksk.keywordCount; i++)
-    {
-      kp = u2->data.ksk.keywords[i];
-      found = 0;
-      for (j = 0; j < u1->data.ksk.keywordCount; j++)
-        if (0 == strcmp(kp + 1, kl[j] + 1))
-          {
-            found = 1;
-            if (kp[0] == '+')
-              kl[j][0] = '+';
-            break;
-          }
-      if (0 == found)
-        kl[kc++] = GNUNET_strdup(kp);
-    }
-  ret = GNUNET_new(struct GNUNET_FS_Uri);
+  {
+    kp = u2->data.ksk.keywords[i];
+    found = 0;
+    for (j = 0; j < u1->data.ksk.keywordCount; j++)
+      if (0 == strcmp (kp + 1, kl[j] + 1))
+      {
+        found = 1;
+        if (kp[0] == '+')
+          kl[j][0] = '+';
+        break;
+      }
+    if (0 == found)
+      kl[kc++] = GNUNET_strdup (kp);
+  }
+  ret = GNUNET_new (struct GNUNET_FS_Uri);
   ret->type = GNUNET_FS_URI_KSK;
   ret->data.ksk.keywordCount = kc;
   ret->data.ksk.keywords = kl;
@@ -992,46 +993,46 @@ GNUNET_FS_uri_ksk_merge(const struct GNUNET_FS_Uri *u1,
  * @return copy of the URI
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri)
 {
   struct GNUNET_FS_Uri *ret;
   unsigned int i;
 
   if (uri == NULL)
     return NULL;
-  ret = GNUNET_new(struct GNUNET_FS_Uri);
-  GNUNET_memcpy(ret, uri, sizeof(struct GNUNET_FS_Uri));
+  ret = GNUNET_new (struct GNUNET_FS_Uri);
+  GNUNET_memcpy (ret, uri, sizeof(struct GNUNET_FS_Uri));
   switch (ret->type)
+  {
+  case GNUNET_FS_URI_KSK:
+    if (ret->data.ksk.keywordCount >=
+        GNUNET_MAX_MALLOC_CHECKED / sizeof(char *))
     {
-    case GNUNET_FS_URI_KSK:
-      if (ret->data.ksk.keywordCount >=
-          GNUNET_MAX_MALLOC_CHECKED / sizeof(char *))
-        {
-          GNUNET_break(0);
-          GNUNET_free(ret);
-          return NULL;
-        }
-      if (ret->data.ksk.keywordCount > 0)
-        {
-          ret->data.ksk.keywords =
-            GNUNET_new_array(ret->data.ksk.keywordCount, char *);
-          for (i = 0; i < ret->data.ksk.keywordCount; i++)
-            ret->data.ksk.keywords[i] = GNUNET_strdup(uri->data.ksk.keywords[i]);
-        }
-      else
-        ret->data.ksk.keywords = NULL; /* just to be sure */
-      break;
+      GNUNET_break (0);
+      GNUNET_free (ret);
+      return NULL;
+    }
+    if (ret->data.ksk.keywordCount > 0)
+    {
+      ret->data.ksk.keywords =
+        GNUNET_new_array (ret->data.ksk.keywordCount, char *);
+      for (i = 0; i < ret->data.ksk.keywordCount; i++)
+        ret->data.ksk.keywords[i] = GNUNET_strdup (uri->data.ksk.keywords[i]);
+    }
+    else
+      ret->data.ksk.keywords = NULL;   /* just to be sure */
+    break;
 
-    case GNUNET_FS_URI_SKS:
-      ret->data.sks.identifier = GNUNET_strdup(uri->data.sks.identifier);
-      break;
+  case GNUNET_FS_URI_SKS:
+    ret->data.sks.identifier = GNUNET_strdup (uri->data.sks.identifier);
+    break;
 
-    case GNUNET_FS_URI_LOC:
-      break;
+  case GNUNET_FS_URI_LOC:
+    break;
 
-    default:
-      break;
-    }
+  default:
+    break;
+  }
   return ret;
 }
 
@@ -1054,7 +1055,7 @@ GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
  *  if keywords is not legal (i.e. empty).
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create(const char *keywords, char **emsg)
+GNUNET_FS_uri_ksk_create (const char *keywords, char **emsg)
 {
   char **keywordarr;
   unsigned int num_Words;
@@ -1065,68 +1066,68 @@ GNUNET_FS_uri_ksk_create(const char *keywords, char **emsg)
   int saw_quote;
 
   if (keywords == NULL)
-    {
-      *emsg = GNUNET_strdup(_("No keywords specified!\n"));
-      GNUNET_break(0);
-      return NULL;
-    }
-  searchString = GNUNET_strdup(keywords);
+  {
+    *emsg = GNUNET_strdup (_ ("No keywords specified!\n"));
+    GNUNET_break (0);
+    return NULL;
+  }
+  searchString = GNUNET_strdup (keywords);
   num_Words = 0;
   inWord = 0;
   saw_quote = 0;
   pos = searchString;
   while ('\0' != *pos)
+  {
+    if ((saw_quote == 0) && (isspace ((unsigned char) *pos)))
     {
-      if ((saw_quote == 0) && (isspace((unsigned char)*pos)))
-        {
-          inWord = 0;
-        }
-      else if (0 == inWord)
-        {
-          inWord = 1;
-          ++num_Words;
-        }
-      if ('"' == *pos)
-        saw_quote = (saw_quote + 1) % 2;
-      pos++;
+      inWord = 0;
     }
-  if (num_Words == 0)
+    else if (0 == inWord)
     {
-      GNUNET_free(searchString);
-      *emsg = GNUNET_strdup(_("No keywords specified!\n"));
-      return NULL;
+      inWord = 1;
+      ++num_Words;
     }
+    if ('"' == *pos)
+      saw_quote = (saw_quote + 1) % 2;
+    pos++;
+  }
+  if (num_Words == 0)
+  {
+    GNUNET_free (searchString);
+    *emsg = GNUNET_strdup (_ ("No keywords specified!\n"));
+    return NULL;
+  }
   if (saw_quote != 0)
-    {
-      GNUNET_free(searchString);
-      *emsg = GNUNET_strdup(_("Number of double-quotes not balanced!\n"));
-      return NULL;
-    }
-  keywordarr = GNUNET_new_array(num_Words, char *);
+  {
+    GNUNET_free (searchString);
+    *emsg = GNUNET_strdup (_ ("Number of double-quotes not balanced!\n"));
+    return NULL;
+  }
+  keywordarr = GNUNET_new_array (num_Words, char *);
   num_Words = 0;
   inWord = 0;
   pos = searchString;
   while ('\0' != *pos)
+  {
+    if ((saw_quote == 0) && (isspace ((unsigned char) *pos)))
     {
-      if ((saw_quote == 0) && (isspace((unsigned char)*pos)))
-        {
-          inWord = 0;
-          *pos = '\0';
-        }
-      else if (0 == inWord)
-        {
-          keywordarr[num_Words] = pos;
-          inWord = 1;
-          ++num_Words;
-        }
-      if ('"' == *pos)
-        saw_quote = (saw_quote + 1) % 2;
-      pos++;
+      inWord = 0;
+      *pos = '\0';
     }
+    else if (0 == inWord)
+    {
+      keywordarr[num_Words] = pos;
+      inWord = 1;
+      ++num_Words;
+    }
+    if ('"' == *pos)
+      saw_quote = (saw_quote + 1) % 2;
+    pos++;
+  }
   uri =
-    GNUNET_FS_uri_ksk_create_from_args(num_Words, (const char **)keywordarr);
-  GNUNET_free(keywordarr);
-  GNUNET_free(searchString);
+    GNUNET_FS_uri_ksk_create_from_args (num_Words, (const char **) keywordarr);
+  GNUNET_free (keywordarr);
+  GNUNET_free (searchString);
   return uri;
 }
 
@@ -1149,7 +1150,7 @@ GNUNET_FS_uri_ksk_create(const char *keywords, char **emsg)
  *  if keywords is not legal (i.e. empty).
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create_from_args(unsigned int argc, const char **argv)
+GNUNET_FS_uri_ksk_create_from_args (unsigned int argc, const char **argv)
 {
   unsigned int i;
   struct GNUNET_FS_Uri *uri;
@@ -1164,36 +1165,36 @@ GNUNET_FS_uri_ksk_create_from_args(unsigned int argc, const char **argv)
   /* allow URI to be given as one and only keyword and
    * handle accordingly */
   emsg = NULL;
-  if ((argc == 1) && (strlen(argv[0]) > strlen(GNUNET_FS_URI_PREFIX)) &&
-      (0 == strncmp(argv[0],
-                    GNUNET_FS_URI_PREFIX,
-                    strlen(GNUNET_FS_URI_PREFIX))) &&
-      (NULL != (uri = GNUNET_FS_uri_parse(argv[0], &emsg))))
+  if ((argc == 1) && (strlen (argv[0]) > strlen (GNUNET_FS_URI_PREFIX)) &&
+      (0 == strncmp (argv[0],
+                     GNUNET_FS_URI_PREFIX,
+                     strlen (GNUNET_FS_URI_PREFIX))) &&
+      (NULL != (uri = GNUNET_FS_uri_parse (argv[0], &emsg))))
     return uri;
-  GNUNET_free_non_null(emsg);
-  uri = GNUNET_new(struct GNUNET_FS_Uri);
+  GNUNET_free_non_null (emsg);
+  uri = GNUNET_new (struct GNUNET_FS_Uri);
   uri->type = GNUNET_FS_URI_KSK;
   uri->data.ksk.keywordCount = argc;
-  uri->data.ksk.keywords = GNUNET_new_array(argc, char *);
+  uri->data.ksk.keywords = GNUNET_new_array (argc, char *);
   for (i = 0; i < argc; i++)
+  {
+    keyword = argv[i];
+    if (keyword[0] == '+')
+      val = GNUNET_strdup (keyword);
+    else
+      GNUNET_asprintf (&val, " %s", keyword);
+    r = val;
+    w = val;
+    while ('\0' != *r)
     {
-      keyword = argv[i];
-      if (keyword[0] == '+')
-        val = GNUNET_strdup(keyword);
+      if ('"' == *r)
+        r++;
       else
-        GNUNET_asprintf(&val, " %s", keyword);
-      r = val;
-      w = val;
-      while ('\0' != *r)
-        {
-          if ('"' == *r)
-            r++;
-          else
-            *(w++) = *(r++);
-        }
-      *w = '\0';
-      uri->data.ksk.keywords[i] = val;
+        *(w++) = *(r++);
     }
+    *w = '\0';
+    uri->data.ksk.keywords[i] = val;
+  }
   return uri;
 }
 
@@ -1206,66 +1207,66 @@ GNUNET_FS_uri_ksk_create_from_args(unsigned int argc, const char **argv)
  * @return #GNUNET_YES if the URIs are equal
  */
 int
-GNUNET_FS_uri_test_equal(const struct GNUNET_FS_Uri *u1,
-                         const struct GNUNET_FS_Uri *u2)
+GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
+                          const struct GNUNET_FS_Uri *u2)
 {
   int ret;
   unsigned int i;
   unsigned int j;
 
-  GNUNET_assert(u1 != NULL);
-  GNUNET_assert(u2 != NULL);
+  GNUNET_assert (u1 != NULL);
+  GNUNET_assert (u2 != NULL);
   if (u1->type != u2->type)
     return GNUNET_NO;
   switch (u1->type)
-    {
-    case GNUNET_FS_URI_CHK:
-      if (0 ==
-          memcmp(&u1->data.chk, &u2->data.chk, sizeof(struct FileIdentifier)))
-        return GNUNET_YES;
-      return GNUNET_NO;
+  {
+  case GNUNET_FS_URI_CHK:
+    if (0 ==
+        memcmp (&u1->data.chk, &u2->data.chk, sizeof(struct FileIdentifier)))
+      return GNUNET_YES;
+    return GNUNET_NO;
 
-    case GNUNET_FS_URI_SKS:
-      if ((0 == memcmp(&u1->data.sks.ns,
-                       &u2->data.sks.ns,
-                       sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))) &&
-          (0 == strcmp(u1->data.sks.identifier, u2->data.sks.identifier)))
+  case GNUNET_FS_URI_SKS:
+    if ((0 == memcmp (&u1->data.sks.ns,
+                      &u2->data.sks.ns,
+                      sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))) &&
+        (0 == strcmp (u1->data.sks.identifier, u2->data.sks.identifier)))
 
-        return GNUNET_YES;
-      return GNUNET_NO;
+      return GNUNET_YES;
+    return GNUNET_NO;
 
-    case GNUNET_FS_URI_KSK:
-      if (u1->data.ksk.keywordCount != u2->data.ksk.keywordCount)
-        return GNUNET_NO;
-      for (i = 0; i < u1->data.ksk.keywordCount; i++)
+  case GNUNET_FS_URI_KSK:
+    if (u1->data.ksk.keywordCount != u2->data.ksk.keywordCount)
+      return GNUNET_NO;
+    for (i = 0; i < u1->data.ksk.keywordCount; i++)
+    {
+      ret = GNUNET_NO;
+      for (j = 0; j < u2->data.ksk.keywordCount; j++)
+      {
+        if (0 == strcmp (u1->data.ksk.keywords[i], u2->data.ksk.keywords[j]))
         {
-          ret = GNUNET_NO;
-          for (j = 0; j < u2->data.ksk.keywordCount; j++)
-            {
-              if (0 == strcmp(u1->data.ksk.keywords[i], u2->data.ksk.keywords[j]))
-                {
-                  ret = GNUNET_YES;
-                  break;
-                }
-            }
-          if (ret == GNUNET_NO)
-            return GNUNET_NO;
+          ret = GNUNET_YES;
+          break;
         }
-      return GNUNET_YES;
-
-    case GNUNET_FS_URI_LOC:
-      if (memcmp(&u1->data.loc,
-                 &u2->data.loc,
-                 sizeof(struct FileIdentifier) +
-                 sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey) +
-                 sizeof(struct GNUNET_TIME_Absolute) +
-                 sizeof(unsigned short) + sizeof(unsigned short)) != 0)
+      }
+      if (ret == GNUNET_NO)
         return GNUNET_NO;
-      return GNUNET_YES;
-
-    default:
-      return GNUNET_NO;
     }
+    return GNUNET_YES;
+
+  case GNUNET_FS_URI_LOC:
+    if (memcmp (&u1->data.loc,
+                &u2->data.loc,
+                sizeof(struct FileIdentifier)
+                + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)
+                + sizeof(struct GNUNET_TIME_Absolute)
+                + sizeof(unsigned short) + sizeof(unsigned short)) != 0)
+      return GNUNET_NO;
+    return GNUNET_YES;
+
+  default:
+    return GNUNET_NO;
+  }
 }
 
 
@@ -1276,7 +1277,7 @@ GNUNET_FS_uri_test_equal(const struct GNUNET_FS_Uri *u1,
  * @return #GNUNET_YES if this is an SKS uri
  */
 int
-GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri)
 {
   return uri->type == GNUNET_FS_URI_SKS;
 }
@@ -1291,14 +1292,14 @@ GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_FS_uri_sks_get_namespace(const struct GNUNET_FS_Uri *uri,
-                                struct GNUNET_CRYPTO_EcdsaPublicKey *pseudonym)
+GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri,
+                                 struct GNUNET_CRYPTO_EcdsaPublicKey *pseudonym)
 {
-  if (!GNUNET_FS_uri_test_sks(uri))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  if (! GNUNET_FS_uri_test_sks (uri))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   *pseudonym = uri->data.sks.ns;
   return GNUNET_OK;
 }
@@ -1311,14 +1312,14 @@ GNUNET_FS_uri_sks_get_namespace(const struct GNUNET_FS_Uri *uri,
  * @return NULL on error (not a valid SKS URI)
  */
 char *
-GNUNET_FS_uri_sks_get_content_id(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_sks_get_content_id (const struct GNUNET_FS_Uri *uri)
 {
-  if (!GNUNET_FS_uri_test_sks(uri))
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
-  return GNUNET_strdup(uri->data.sks.identifier);
+  if (! GNUNET_FS_uri_test_sks (uri))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
+  return GNUNET_strdup (uri->data.sks.identifier);
 }
 
 
@@ -1329,16 +1330,16 @@ GNUNET_FS_uri_sks_get_content_id(const struct GNUNET_FS_Uri *uri)
  * @return #GNUNET_YES if this is a KSK uri
  */
 int
-GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri)
 {
 #if EXTRA_CHECKS
   unsigned int i;
 
   if (uri->type == GNUNET_FS_URI_KSK)
-    {
-      for (i = 0; i < uri->data.ksk.keywordCount; i++)
-        GNUNET_assert(uri->data.ksk.keywords[i] != NULL);
-    }
+  {
+    for (i = 0; i < uri->data.ksk.keywordCount; i++)
+      GNUNET_assert (uri->data.ksk.keywords[i] != NULL);
+  }
 #endif
   return uri->type == GNUNET_FS_URI_KSK;
 }
@@ -1351,7 +1352,7 @@ GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
  * @return #GNUNET_YES if this is a CHK uri
  */
 int
-GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri)
 {
   return uri->type == GNUNET_FS_URI_CHK;
 }
@@ -1365,19 +1366,19 @@ GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
  * @return size of the file as specified in the CHK URI
  */
 uint64_t
-GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_chk_get_file_size (const struct GNUNET_FS_Uri *uri)
 {
   switch (uri->type)
-    {
-    case GNUNET_FS_URI_CHK:
-      return GNUNET_ntohll(uri->data.chk.file_length);
+  {
+  case GNUNET_FS_URI_CHK:
+    return GNUNET_ntohll (uri->data.chk.file_length);
 
-    case GNUNET_FS_URI_LOC:
-      return GNUNET_ntohll(uri->data.loc.fi.file_length);
+  case GNUNET_FS_URI_LOC:
+    return GNUNET_ntohll (uri->data.loc.fi.file_length);
 
-    default:
-      GNUNET_assert(0);
-    }
+  default:
+    GNUNET_assert (0);
+  }
   return 0; /* unreachable */
 }
 
@@ -1389,7 +1390,7 @@ GNUNET_FS_uri_chk_get_file_size(const struct GNUNET_FS_Uri *uri)
  * @return #GNUNET_YES if this is a LOC uri
  */
 int
-GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
 {
   return uri->type == GNUNET_FS_URI_LOC;
 }
@@ -1405,13 +1406,13 @@ GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
  * @param index offset where to add the keyword
  */
 static void
-insert_non_mandatory_keyword(const char *s, char **array, int index)
+insert_non_mandatory_keyword (const char *s, char **array, int index)
 {
   char *nkword;
 
-  GNUNET_asprintf(&nkword,
-                  " %s",  /* space to mark as 'non mandatory' */
-                  s);
+  GNUNET_asprintf (&nkword,
+                   " %s", /* space to mark as 'non mandatory' */
+                   s);
   array[index] = nkword;
 }
 
@@ -1426,12 +1427,12 @@ insert_non_mandatory_keyword(const char *s, char **array, int index)
  * @return #GNUNET_YES if the keyword exists, #GNUNET_NO if not
  */
 static int
-find_duplicate(const char *s, const char **array, int array_length)
+find_duplicate (const char *s, const char **array, int array_length)
 {
   int j;
 
   for (j = array_length - 1; j >= 0; j--)
-    if (0 == strcmp(&array[j][1], s))
+    if (0 == strcmp (&array[j][1], s))
       return GNUNET_YES;
   return GNUNET_NO;
 }
@@ -1441,12 +1442,12 @@ find_duplicate(const char *s, const char **array, int array_length)
  * FIXME: comment
  */
 static char *
-normalize_metadata(enum EXTRACTOR_MetaFormat format,
-                   const char *data,
-                   size_t data_len)
+normalize_metadata (enum EXTRACTOR_MetaFormat format,
+                    const char *data,
+                    size_t data_len)
 {
   uint8_t *free_str = NULL;
-  uint8_t *str_to_normalize = (uint8_t *)data;
+  uint8_t *str_to_normalize = (uint8_t *) data;
   uint8_t *normalized;
   size_t r_len;
 
@@ -1454,41 +1455,41 @@ normalize_metadata(enum EXTRACTOR_MetaFormat format,
     return NULL;
   /* Don't trust libextractor */
   if (format == EXTRACTOR_METAFORMAT_UTF8)
-    {
-      free_str = (uint8_t *)u8_check((const uint8_t *)data, data_len);
-      if (free_str == NULL)
-        free_str = NULL;
-      else
-        format = EXTRACTOR_METAFORMAT_C_STRING;
-    }
+  {
+    free_str = (uint8_t *) u8_check ((const uint8_t *) data, data_len);
+    if (free_str == NULL)
+      free_str = NULL;
+    else
+      format = EXTRACTOR_METAFORMAT_C_STRING;
+  }
   if (format == EXTRACTOR_METAFORMAT_C_STRING)
-    {
-      free_str = u8_strconv_from_encoding(data,
-                                          locale_charset(),
-                                          iconveh_escape_sequence);
-      if (free_str == NULL)
-        return NULL;
-    }
-
-  normalized = u8_tolower(str_to_normalize,
-                          strlen((char *)str_to_normalize),
-                          NULL,
-                          UNINORM_NFD,
-                          NULL,
-                          &r_len);
+  {
+    free_str = u8_strconv_from_encoding (data,
+                                         locale_charset (),
+                                         iconveh_escape_sequence);
+    if (free_str == NULL)
+      return NULL;
+  }
+
+  normalized = u8_tolower (str_to_normalize,
+                           strlen ((char *) str_to_normalize),
+                           NULL,
+                           UNINORM_NFD,
+                           NULL,
+                           &r_len);
   /* free_str is allocated by libunistring internally, use free() */
   if (free_str != NULL)
-    free(free_str);
+    free (free_str);
   if (normalized != NULL)
-    {
-      /* u8_tolower allocates a non-NULL-terminated string! */
-      free_str = GNUNET_malloc(r_len + 1);
-      GNUNET_memcpy(free_str, normalized, r_len);
-      free_str[r_len] = '\0';
-      free(normalized);
-      normalized = free_str;
-    }
-  return (char *)normalized;
+  {
+    /* u8_tolower allocates a non-NULL-terminated string! */
+    free_str = GNUNET_malloc (r_len + 1);
+    GNUNET_memcpy (free_str, normalized, r_len);
+    free_str[r_len] = '\0';
+    free (normalized);
+    normalized = free_str;
+  }
+  return (char *) normalized;
 }
 
 
@@ -1497,16 +1498,16 @@ normalize_metadata(enum EXTRACTOR_MetaFormat format,
  * returns that count.
  */
 static size_t
-u8_strcount(const uint8_t *s)
+u8_strcount (const uint8_t *s)
 {
   size_t count;
   ucs4_t c;
 
-  GNUNET_assert(s != NULL);
+  GNUNET_assert (s != NULL);
   if (s[0] == 0)
     return 0;
   for (count = 0; s != NULL; count++)
-    s = u8_next(&c, s);
+    s = u8_next (&c, s);
   return count - 1;
 }
 
@@ -1528,7 +1529,7 @@ u8_strcount(const uint8_t *s)
  *         were duplicates (when extracting).
  */
 static int
-get_keywords_from_parens(const char *s, char **array, int index)
+get_keywords_from_parens (const char *s, char **array, int index)
 {
   int count = 0;
   char *open_paren;
@@ -1538,80 +1539,80 @@ get_keywords_from_parens(const char *s, char **array, int index)
 
   if (NULL == s)
     return 0;
-  ss = GNUNET_strdup(s);
+  ss = GNUNET_strdup (s);
   open_paren = ss - 1;
-  while (NULL != (open_paren = strpbrk(open_paren + 1, "[{(")))
+  while (NULL != (open_paren = strpbrk (open_paren + 1, "[{(")))
+  {
+    int match = 0;
+
+    close_paren = strpbrk (open_paren + 1, "]})");
+    if (NULL == close_paren)
+      continue;
+    switch (open_paren[0])
     {
-      int match = 0;
-
-      close_paren = strpbrk(open_paren + 1, "]})");
-      if (NULL == close_paren)
-        continue;
-      switch (open_paren[0])
-        {
-        case '[':
-          if (']' == close_paren[0])
-            match = 1;
-          break;
+    case '[':
+      if (']' == close_paren[0])
+        match = 1;
+      break;
 
-        case '{':
-          if ('}' == close_paren[0])
-            match = 1;
-          break;
+    case '{':
+      if ('}' == close_paren[0])
+        match = 1;
+      break;
 
-        case '(':
-          if (')' == close_paren[0])
-            match = 1;
-          break;
+    case '(':
+      if (')' == close_paren[0])
+        match = 1;
+      break;
 
-        default:
-          break;
+    default:
+      break;
+    }
+    if (match && (close_paren - open_paren > 1))
+    {
+      tmp = close_paren[0];
+      close_paren[0] = '\0';
+      /* Keywords must be at least 3 characters long */
+      if (u8_strcount ((const uint8_t *) &open_paren[1]) <= 2)
+      {
+        close_paren[0] = tmp;
+        continue;
+      }
+      if (NULL != array)
+      {
+        char *normalized;
+        if (GNUNET_NO == find_duplicate ((const char *) &open_paren[1],
+                                         (const char **) array,
+                                         index + count))
+        {
+          insert_non_mandatory_keyword ((const char *) &open_paren[1],
+                                        array,
+                                        index + count);
+          count++;
         }
-      if (match && (close_paren - open_paren > 1))
+        normalized = normalize_metadata (EXTRACTOR_METAFORMAT_UTF8,
+                                         &open_paren[1],
+                                         close_paren - &open_paren[1]);
+        if (normalized != NULL)
         {
-          tmp = close_paren[0];
-          close_paren[0] = '\0';
-          /* Keywords must be at least 3 characters long */
-          if (u8_strcount((const uint8_t *)&open_paren[1]) <= 2)
-            {
-              close_paren[0] = tmp;
-              continue;
-            }
-          if (NULL != array)
-            {
-              char *normalized;
-              if (GNUNET_NO == find_duplicate((const char *)&open_paren[1],
-                                              (const char **)array,
-                                              index + count))
-                {
-                  insert_non_mandatory_keyword((const char *)&open_paren[1],
-                                               array,
-                                               index + count);
-                  count++;
-                }
-              normalized = normalize_metadata(EXTRACTOR_METAFORMAT_UTF8,
-                                              &open_paren[1],
-                                              close_paren - &open_paren[1]);
-              if (normalized != NULL)
-                {
-                  if (GNUNET_NO == find_duplicate((const char *)normalized,
-                                                  (const char **)array,
-                                                  index + count))
-                    {
-                      insert_non_mandatory_keyword((const char *)normalized,
-                                                   array,
-                                                   index + count);
-                      count++;
-                    }
-                  GNUNET_free(normalized);
-                }
-            }
-          else
+          if (GNUNET_NO == find_duplicate ((const char *) normalized,
+                                           (const char **) array,
+                                           index + count))
+          {
+            insert_non_mandatory_keyword ((const char *) normalized,
+                                          array,
+                                          index + count);
             count++;
-          close_paren[0] = tmp;
+          }
+          GNUNET_free (normalized);
         }
+      }
+      else
+        count++;
+      close_paren[0] = tmp;
     }
-  GNUNET_free(ss);
+  }
+  GNUNET_free (ss);
   return count;
 }
 
@@ -1636,46 +1637,46 @@ get_keywords_from_parens(const char *s, char **array, int index)
  *         duplicates (when extracting).
  */
 static int
-get_keywords_from_tokens(const char *s, char **array, int index)
+get_keywords_from_tokens (const char *s, char **array, int index)
 {
   char *p;
   char *ss;
   int seps = 0;
 
-  ss = GNUNET_strdup(s);
-  for (p = strtok(ss, TOKENS); p != NULL; p = strtok(NULL, TOKENS))
+  ss = GNUNET_strdup (s);
+  for (p = strtok (ss, TOKENS); p != NULL; p = strtok (NULL, TOKENS))
+  {
+    /* Keywords must be at least 3 characters long */
+    if (u8_strcount ((const uint8_t *) p) <= 2)
+      continue;
+    if (NULL != array)
     {
-      /* Keywords must be at least 3 characters long */
-      if (u8_strcount((const uint8_t *)p) <= 2)
-        continue;
-      if (NULL != array)
+      char *normalized;
+      if (GNUNET_NO == find_duplicate (p, (const char **) array, index + seps))
+      {
+        insert_non_mandatory_keyword (p, array, index + seps);
+        seps++;
+      }
+      normalized =
+        normalize_metadata (EXTRACTOR_METAFORMAT_UTF8, p, strlen (p));
+      if (normalized != NULL)
+      {
+        if (GNUNET_NO == find_duplicate ((const char *) normalized,
+                                         (const char **) array,
+                                         index + seps))
         {
-          char *normalized;
-          if (GNUNET_NO == find_duplicate(p, (const char **)array, index + seps))
-            {
-              insert_non_mandatory_keyword(p, array, index + seps);
-              seps++;
-            }
-          normalized =
-            normalize_metadata(EXTRACTOR_METAFORMAT_UTF8, p, strlen(p));
-          if (normalized != NULL)
-            {
-              if (GNUNET_NO == find_duplicate((const char *)normalized,
-                                              (const char **)array,
-                                              index + seps))
-                {
-                  insert_non_mandatory_keyword((const char *)normalized,
-                                               array,
-                                               index + seps);
-                  seps++;
-                }
-              GNUNET_free(normalized);
-            }
+          insert_non_mandatory_keyword ((const char *) normalized,
+                                        array,
+                                        index + seps);
+          seps++;
         }
-      else
-        seps++;
+        GNUNET_free (normalized);
+      }
     }
-  GNUNET_free(ss);
+    else
+      seps++;
+  }
+  GNUNET_free (ss);
   return seps;
 }
 #undef TOKENS
@@ -1699,13 +1700,13 @@ get_keywords_from_tokens(const char *s, char **array, int index)
  * @return 0 (always)
  */
 static int
-gather_uri_data(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)
+gather_uri_data (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_FS_Uri *uri = cls;
   char *normalized_data;
@@ -1719,49 +1720,49 @@ gather_uri_data(void *cls,
    * and will return the length of its valid part, skipping the keyword.
    * If it does - fix the extractor, not this check!
    */
-  if (u8_strcount((const uint8_t *)data) <= 2)
+  if (u8_strcount ((const uint8_t *) data) <= 2)
     return 0;
   if ((EXTRACTOR_METATYPE_MIMETYPE == type) &&
-      (NULL != (sep = memchr(data, '/', data_len))) && (sep != data))
-    {
-      char *xtra;
+      (NULL != (sep = memchr (data, '/', data_len))) && (sep != data))
+  {
+    char *xtra;
 
-      GNUNET_asprintf(&xtra, "mimetype:%.*s", (int)(sep - data), data);
-      if (!find_duplicate(xtra,
-                          (const char **)uri->data.ksk.keywords,
+    GNUNET_asprintf (&xtra, "mimetype:%.*s", (int) (sep - data), data);
+    if (! find_duplicate (xtra,
+                          (const char **) uri->data.ksk.keywords,
                           uri->data.ksk.keywordCount))
-        {
-          insert_non_mandatory_keyword(xtra,
-                                       uri->data.ksk.keywords,
-                                       uri->data.ksk.keywordCount);
-          uri->data.ksk.keywordCount++;
-        }
-      GNUNET_free(xtra);
-    }
-
-  normalized_data = normalize_metadata(format, data, data_len);
-  if (!find_duplicate(data,
-                      (const char **)uri->data.ksk.keywords,
-                      uri->data.ksk.keywordCount))
     {
-      insert_non_mandatory_keyword(data,
-                                   uri->data.ksk.keywords,
-                                   uri->data.ksk.keywordCount);
+      insert_non_mandatory_keyword (xtra,
+                                    uri->data.ksk.keywords,
+                                    uri->data.ksk.keywordCount);
       uri->data.ksk.keywordCount++;
     }
+    GNUNET_free (xtra);
+  }
+
+  normalized_data = normalize_metadata (format, data, data_len);
+  if (! find_duplicate (data,
+                        (const char **) uri->data.ksk.keywords,
+                        uri->data.ksk.keywordCount))
+  {
+    insert_non_mandatory_keyword (data,
+                                  uri->data.ksk.keywords,
+                                  uri->data.ksk.keywordCount);
+    uri->data.ksk.keywordCount++;
+  }
   if (NULL != normalized_data)
-    {
-      if (!find_duplicate(normalized_data,
-                          (const char **)uri->data.ksk.keywords,
+  {
+    if (! find_duplicate (normalized_data,
+                          (const char **) uri->data.ksk.keywords,
                           uri->data.ksk.keywordCount))
-        {
-          insert_non_mandatory_keyword(normalized_data,
-                                       uri->data.ksk.keywords,
-                                       uri->data.ksk.keywordCount);
-          uri->data.ksk.keywordCount++;
-        }
-      GNUNET_free(normalized_data);
+    {
+      insert_non_mandatory_keyword (normalized_data,
+                                    uri->data.ksk.keywords,
+                                    uri->data.ksk.keywordCount);
+      uri->data.ksk.keywordCount++;
     }
+    GNUNET_free (normalized_data);
+  }
   return 0;
 }
 
@@ -1775,7 +1776,7 @@ gather_uri_data(void *cls,
  * @return NULL on error, otherwise a KSK URI
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create_from_meta_data(
+GNUNET_FS_uri_ksk_create_from_meta_data (
   const struct GNUNET_CONTAINER_MetaData *md)
 {
   struct GNUNET_FS_Uri *ret;
@@ -1788,41 +1789,41 @@ GNUNET_FS_uri_ksk_create_from_meta_data(
 
   if (NULL == md)
     return NULL;
-  ret = GNUNET_new(struct GNUNET_FS_Uri);
+  ret = GNUNET_new (struct GNUNET_FS_Uri);
   ret->type = GNUNET_FS_URI_KSK;
-  ent = GNUNET_CONTAINER_meta_data_iterate(md, NULL, NULL);
+  ent = GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL);
   if (ent > 0)
+  {
+    full_name = GNUNET_CONTAINER_meta_data_get_first_by_types (
+      md,
+      EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+      -1);
+    if (NULL != full_name)
     {
-      full_name = GNUNET_CONTAINER_meta_data_get_first_by_types(
-        md,
-        EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-        -1);
-      if (NULL != full_name)
-        {
-          filename = full_name;
-          while (NULL != (ss = strstr(filename, DIR_SEPARATOR_STR)))
-            filename = ss + 1;
-          tok_keywords = get_keywords_from_tokens(filename, NULL, 0);
-          paren_keywords = get_keywords_from_parens(filename, NULL, 0);
-        }
-      /* x3 because there might be a normalized variant of every keyword,
-         plus theoretically one more for mime... */
-      ret->data.ksk.keywords =
-        GNUNET_new_array((ent + tok_keywords + paren_keywords) * 3, char *);
-      GNUNET_CONTAINER_meta_data_iterate(md, &gather_uri_data, ret);
+      filename = full_name;
+      while (NULL != (ss = strstr (filename, DIR_SEPARATOR_STR)))
+        filename = ss + 1;
+      tok_keywords = get_keywords_from_tokens (filename, NULL, 0);
+      paren_keywords = get_keywords_from_parens (filename, NULL, 0);
     }
+    /* x3 because there might be a normalized variant of every keyword,
+       plus theoretically one more for mime... */
+    ret->data.ksk.keywords =
+      GNUNET_new_array ((ent + tok_keywords + paren_keywords) * 3, char *);
+    GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
+  }
   if (tok_keywords > 0)
     ret->data.ksk.keywordCount +=
-      get_keywords_from_tokens(filename,
-                               ret->data.ksk.keywords,
-                               ret->data.ksk.keywordCount);
+      get_keywords_from_tokens (filename,
+                                ret->data.ksk.keywords,
+                                ret->data.ksk.keywordCount);
   if (paren_keywords > 0)
     ret->data.ksk.keywordCount +=
-      get_keywords_from_parens(filename,
-                               ret->data.ksk.keywords,
-                               ret->data.ksk.keywordCount);
+      get_keywords_from_parens (filename,
+                                ret->data.ksk.keywords,
+                                ret->data.ksk.keywordCount);
   if (ent > 0)
-    GNUNET_free_non_null(full_name);
+    GNUNET_free_non_null (full_name);
   return ret;
 }
 
@@ -1832,10 +1833,10 @@ GNUNET_FS_uri_ksk_create_from_meta_data(
  * need to be encoded using %-encoding?
  */
 static int
-needs_percent(char c)
+needs_percent (char c)
 {
-  return(!((isalnum((unsigned char)c)) || (c == '-') || (c == '_') ||
-           (c == '.') || (c == '~')));
+  return(! ((isalnum ((unsigned char) c)) || (c == '-') || (c == '_') ||
+            (c == '.') || (c == '~')));
 }
 
 
@@ -1846,7 +1847,7 @@ needs_percent(char c)
  * @return NULL on error (i.e. keywordCount == 0)
  */
 static char *
-uri_ksk_to_string(const struct GNUNET_FS_Uri *uri)
+uri_ksk_to_string (const struct GNUNET_FS_Uri *uri)
 {
   char **keywords;
   unsigned int keywordCount;
@@ -1862,49 +1863,49 @@ uri_ksk_to_string(const struct GNUNET_FS_Uri *uri)
     return NULL;
   keywords = uri->data.ksk.keywords;
   keywordCount = uri->data.ksk.keywordCount;
-  n = keywordCount + strlen(GNUNET_FS_URI_PREFIX) +
-      strlen(GNUNET_FS_URI_KSK_INFIX) + 1;
+  n = keywordCount + strlen (GNUNET_FS_URI_PREFIX)
+      + strlen (GNUNET_FS_URI_KSK_INFIX) + 1;
   for (i = 0; i < keywordCount; i++)
+  {
+    keyword = keywords[i];
+    slen = strlen (keyword);
+    n += slen;
+    for (j = 0; j < slen; j++)
     {
-      keyword = keywords[i];
-      slen = strlen(keyword);
-      n += slen;
-      for (j = 0; j < slen; j++)
-        {
-          if ((j == 0) && (keyword[j] == ' '))
-            {
-              n--;
-              continue; /* skip leading space */
-            }
-          if (needs_percent(keyword[j]))
-            n += 2; /* will use %-encoding */
-        }
+      if ((j == 0) && (keyword[j] == ' '))
+      {
+        n--;
+        continue;       /* skip leading space */
+      }
+      if (needs_percent (keyword[j]))
+        n += 2;     /* will use %-encoding */
     }
-  ret = GNUNET_malloc(n);
-  strcpy(ret, GNUNET_FS_URI_PREFIX);
-  strcat(ret, GNUNET_FS_URI_KSK_INFIX);
-  wpos = strlen(ret);
+  }
+  ret = GNUNET_malloc (n);
+  strcpy (ret, GNUNET_FS_URI_PREFIX);
+  strcat (ret, GNUNET_FS_URI_KSK_INFIX);
+  wpos = strlen (ret);
   for (i = 0; i < keywordCount; i++)
+  {
+    keyword = keywords[i];
+    slen = strlen (keyword);
+    for (j = 0; j < slen; j++)
     {
-      keyword = keywords[i];
-      slen = strlen(keyword);
-      for (j = 0; j < slen; j++)
-        {
-          if ((j == 0) && (keyword[j] == ' '))
-            continue; /* skip leading space */
-          if (needs_percent(keyword[j]))
-            {
-              sprintf(&ret[wpos], "%%%02X", (unsigned char)keyword[j]);
-              wpos += 3;
-            }
-          else
-            {
-              ret[wpos++] = keyword[j];
-            }
-        }
-      if (i != keywordCount - 1)
-        ret[wpos++] = '+';
+      if ((j == 0) && (keyword[j] == ' '))
+        continue;     /* skip leading space */
+      if (needs_percent (keyword[j]))
+      {
+        sprintf (&ret[wpos], "%%%02X", (unsigned char) keyword[j]);
+        wpos += 3;
+      }
+      else
+      {
+        ret[wpos++] = keyword[j];
+      }
     }
+    if (i != keywordCount - 1)
+      ret[wpos++] = '+';
+  }
   return ret;
 }
 
@@ -1916,7 +1917,7 @@ uri_ksk_to_string(const struct GNUNET_FS_Uri *uri)
  * @return NULL on error
  */
 static char *
-uri_sks_to_string(const struct GNUNET_FS_Uri *uri)
+uri_sks_to_string (const struct GNUNET_FS_Uri *uri)
 {
   char *ret;
   char buf[1024];
@@ -1924,18 +1925,18 @@ uri_sks_to_string(const struct GNUNET_FS_Uri *uri)
   if (GNUNET_FS_URI_SKS != uri->type)
     return NULL;
   ret =
-    GNUNET_STRINGS_data_to_string(&uri->data.sks.ns,
-                                  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
-                                  buf,
-                                  sizeof(buf));
-  GNUNET_assert(NULL != ret);
+    GNUNET_STRINGS_data_to_string (&uri->data.sks.ns,
+                                   sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey),
+                                   buf,
+                                   sizeof(buf));
+  GNUNET_assert (NULL != ret);
   ret[0] = '\0';
-  GNUNET_asprintf(&ret,
-                  "%s%s%s/%s",
-                  GNUNET_FS_URI_PREFIX,
-                  GNUNET_FS_URI_SKS_INFIX,
-                  buf,
-                  uri->data.sks.identifier);
+  GNUNET_asprintf (&ret,
+                   "%s%s%s/%s",
+                   GNUNET_FS_URI_PREFIX,
+                   GNUNET_FS_URI_SKS_INFIX,
+                   buf,
+                   uri->data.sks.identifier);
   return ret;
 }
 
@@ -1947,7 +1948,7 @@ uri_sks_to_string(const struct GNUNET_FS_Uri *uri)
  * @return NULL on error
  */
 static char *
-uri_chk_to_string(const struct GNUNET_FS_Uri *uri)
+uri_chk_to_string (const struct GNUNET_FS_Uri *uri)
 {
   const struct FileIdentifier *fi;
   char *ret;
@@ -1957,16 +1958,16 @@ uri_chk_to_string(const struct GNUNET_FS_Uri *uri)
   if (uri->type != GNUNET_FS_URI_CHK)
     return NULL;
   fi = &uri->data.chk;
-  GNUNET_CRYPTO_hash_to_enc(&fi->chk.key, &keyhash);
-  GNUNET_CRYPTO_hash_to_enc(&fi->chk.query, &queryhash);
-
-  GNUNET_asprintf(&ret,
-                  "%s%s%s.%s.%llu",
-                  GNUNET_FS_URI_PREFIX,
-                  GNUNET_FS_URI_CHK_INFIX,
-                  (const char *)&keyhash,
-                  (const char *)&queryhash,
-                  GNUNET_ntohll(fi->file_length));
+  GNUNET_CRYPTO_hash_to_enc (&fi->chk.key, &keyhash);
+  GNUNET_CRYPTO_hash_to_enc (&fi->chk.query, &queryhash);
+
+  GNUNET_asprintf (&ret,
+                   "%s%s%s.%s.%llu",
+                   GNUNET_FS_URI_PREFIX,
+                   GNUNET_FS_URI_CHK_INFIX,
+                   (const char *) &keyhash,
+                   (const char *) &queryhash,
+                   GNUNET_ntohll (fi->file_length));
   return ret;
 }
 
@@ -1978,7 +1979,7 @@ uri_chk_to_string(const struct GNUNET_FS_Uri *uri)
  * @return NULL on error
  */
 static char *
-uri_loc_to_string(const struct GNUNET_FS_Uri *uri)
+uri_loc_to_string (const struct GNUNET_FS_Uri *uri)
 {
   char *ret;
   struct GNUNET_CRYPTO_HashAsciiEncoded keyhash;
@@ -1986,30 +1987,30 @@ uri_loc_to_string(const struct GNUNET_FS_Uri *uri)
   char *peer_id;
   char peer_sig[SIGNATURE_ASCII_LENGTH + 1];
 
-  GNUNET_CRYPTO_hash_to_enc(&uri->data.loc.fi.chk.key, &keyhash);
-  GNUNET_CRYPTO_hash_to_enc(&uri->data.loc.fi.chk.query, &queryhash);
+  GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.key, &keyhash);
+  GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.query, &queryhash);
   peer_id =
-    GNUNET_CRYPTO_eddsa_public_key_to_string(&uri->data.loc.peer.public_key);
-  GNUNET_assert(
+    GNUNET_CRYPTO_eddsa_public_key_to_string (&uri->data.loc.peer.public_key);
+  GNUNET_assert (
     NULL !=
-    GNUNET_STRINGS_data_to_string(&uri->data.loc.contentSignature,
-                                  sizeof(struct GNUNET_CRYPTO_EddsaSignature),
-                                  peer_sig,
-                                  sizeof(peer_sig)));
-  GNUNET_asprintf(&ret,
-                  "%s%s%s.%s.%llu.%s.%s.%llu",
-                  GNUNET_FS_URI_PREFIX,
-                  GNUNET_FS_URI_LOC_INFIX,
-                  (const char *)&keyhash,
-                  (const char *)&queryhash,
-                  (unsigned long long)GNUNET_ntohll(
-                    uri->data.loc.fi.file_length),
-                  peer_id,
-                  peer_sig,
-                  (unsigned long long)
-                  uri->data.loc.expirationTime.abs_value_us /
-                  1000000LL);
-  GNUNET_free(peer_id);
+    GNUNET_STRINGS_data_to_string (&uri->data.loc.contentSignature,
+                                   sizeof(struct GNUNET_CRYPTO_EddsaSignature),
+                                   peer_sig,
+                                   sizeof(peer_sig)));
+  GNUNET_asprintf (&ret,
+                   "%s%s%s.%s.%llu.%s.%s.%llu",
+                   GNUNET_FS_URI_PREFIX,
+                   GNUNET_FS_URI_LOC_INFIX,
+                   (const char *) &keyhash,
+                   (const char *) &queryhash,
+                   (unsigned long long) GNUNET_ntohll (
+                     uri->data.loc.fi.file_length),
+                   peer_id,
+                   peer_sig,
+                   (unsigned long long)
+                   uri->data.loc.expirationTime.abs_value_us
+                   / 1000000LL);
+  GNUNET_free (peer_id);
   return ret;
 }
 
@@ -2021,31 +2022,31 @@ uri_loc_to_string(const struct GNUNET_FS_Uri *uri)
  * @return the UTF-8 string
  */
 char *
-GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
+GNUNET_FS_uri_to_string (const struct GNUNET_FS_Uri *uri)
 {
   if (uri == NULL)
-    {
-      GNUNET_break(0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   switch (uri->type)
-    {
-    case GNUNET_FS_URI_KSK:
-      return uri_ksk_to_string(uri);
+  {
+  case GNUNET_FS_URI_KSK:
+    return uri_ksk_to_string (uri);
 
-    case GNUNET_FS_URI_SKS:
-      return uri_sks_to_string(uri);
+  case GNUNET_FS_URI_SKS:
+    return uri_sks_to_string (uri);
 
-    case GNUNET_FS_URI_CHK:
-      return uri_chk_to_string(uri);
+  case GNUNET_FS_URI_CHK:
+    return uri_chk_to_string (uri);
 
-    case GNUNET_FS_URI_LOC:
-      return uri_loc_to_string(uri);
+  case GNUNET_FS_URI_LOC:
+    return uri_loc_to_string (uri);
 
-    default:
-      GNUNET_break(0);
-      return NULL;
-    }
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
 }
 
 /* end of fs_uri.c */
diff --git a/src/fs/gnunet-auto-share.c b/src/fs/gnunet-auto-share.c
index 6fc71ebe5..dc1912f09 100644
--- a/src/fs/gnunet-auto-share.c
+++ b/src/fs/gnunet-auto-share.c
@@ -29,7 +29,7 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 
-#define MAX_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4)
+#define MAX_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_HOURS, 4)
 
 #define MIN_DELAY GNUNET_TIME_UNIT_MINUTES
 
@@ -38,7 +38,8 @@
  * Item in our work queue (or in the set of files/directories
  * we have successfully published).
  */
-struct WorkItem {
+struct WorkItem
+{
   /**
    * PENDING Work is kept in a linked list.
    */
@@ -160,16 +161,16 @@ static struct GNUNET_OS_Process *publish_proc;
  * Compute the name of the state database file we will use.
  */
 static char *
-get_state_file()
+get_state_file ()
 {
   char *ret;
 
-  GNUNET_asprintf(&ret,
-                  "%s%s.auto-share",
-                  dir_name,
-                  (DIR_SEPARATOR == dir_name[strlen(dir_name) - 1])
-                  ? ""
-                  : DIR_SEPARATOR_STR);
+  GNUNET_asprintf (&ret,
+                   "%s%s.auto-share",
+                   dir_name,
+                   (DIR_SEPARATOR == dir_name[strlen (dir_name) - 1])
+                   ? ""
+                   : DIR_SEPARATOR_STR);
   return ret;
 }
 
@@ -178,7 +179,7 @@ get_state_file()
  * Load the set of #work_finished items from disk.
  */
 static void
-load_state()
+load_state ()
 {
   char *fn;
   struct GNUNET_BIO_ReadHandle *rh;
@@ -188,47 +189,47 @@ load_state()
   char *emsg;
 
   emsg = NULL;
-  fn = get_state_file();
-  rh = GNUNET_BIO_read_open(fn);
-  GNUNET_free(fn);
+  fn = get_state_file ();
+  rh = GNUNET_BIO_read_open (fn);
+  GNUNET_free (fn);
   if (NULL == rh)
     return;
   fn = NULL;
-  if (GNUNET_OK != GNUNET_BIO_read_int32(rh, &n))
+  if (GNUNET_OK != GNUNET_BIO_read_int32 (rh, &n))
     goto error;
   while (n-- > 0)
-    {
-      if ((GNUNET_OK != GNUNET_BIO_read_string(rh, "filename", &fn, 1024)) ||
-          (GNUNET_OK !=
-           GNUNET_BIO_read(rh, "id", &id, sizeof(struct GNUNET_HashCode))))
-        goto error;
-      wi = GNUNET_new(struct WorkItem);
-      wi->id = id;
-      wi->filename = fn;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Loaded serialization ID for `%s' is `%s'\n",
-                 wi->filename,
-                 GNUNET_h2s(&id));
-      fn = NULL;
-      GNUNET_CRYPTO_hash(wi->filename, strlen(wi->filename), &id);
-      GNUNET_break(GNUNET_OK ==
-                   GNUNET_CONTAINER_multihashmap_put(
-                     work_finished,
-                     &id,
-                     wi,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
-  if (GNUNET_OK == GNUNET_BIO_read_close(rh, &emsg))
+  {
+    if ((GNUNET_OK != GNUNET_BIO_read_string (rh, "filename", &fn, 1024)) ||
+        (GNUNET_OK !=
+         GNUNET_BIO_read (rh, "id", &id, sizeof(struct GNUNET_HashCode))))
+      goto error;
+    wi = GNUNET_new (struct WorkItem);
+    wi->id = id;
+    wi->filename = fn;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Loaded serialization ID for `%s' is `%s'\n",
+                wi->filename,
+                GNUNET_h2s (&id));
+    fn = NULL;
+    GNUNET_CRYPTO_hash (wi->filename, strlen (wi->filename), &id);
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_put (
+                    work_finished,
+                    &id,
+                    wi,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
+  if (GNUNET_OK == GNUNET_BIO_read_close (rh, &emsg))
     return;
   rh = NULL;
 error:
-  GNUNET_free_non_null(fn);
+  GNUNET_free_non_null (fn);
   if (NULL != rh)
-    (void)GNUNET_BIO_read_close(rh, &emsg);
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             _("Failed to load state: %s\n"),
-             emsg);
-  GNUNET_free_non_null(emsg);
+    (void) GNUNET_BIO_read_close (rh, &emsg);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ ("Failed to load state: %s\n"),
+              emsg);
+  GNUNET_free_non_null (emsg);
 }
 
 
@@ -241,18 +242,18 @@ error:
  * @return #GNUNET_OK to continue to iterate (if write worked)
  */
 static int
-write_item(void *cls, const struct GNUNET_HashCode *key, void *value)
+write_item (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GNUNET_BIO_WriteHandle *wh = cls;
   struct WorkItem *wi = value;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Saving serialization ID of file `%s' with value `%s'\n",
-             wi->filename,
-             GNUNET_h2s(&wi->id));
-  if ((GNUNET_OK != GNUNET_BIO_write_string(wh, wi->filename)) ||
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Saving serialization ID of file `%s' with value `%s'\n",
+              wi->filename,
+              GNUNET_h2s (&wi->id));
+  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, wi->filename)) ||
       (GNUNET_OK !=
-       GNUNET_BIO_write(wh, &wi->id, sizeof(struct GNUNET_HashCode))))
+       GNUNET_BIO_write (wh, &wi->id, sizeof(struct GNUNET_HashCode))))
     return GNUNET_SYSERR; /* write error, abort iteration */
   return GNUNET_OK;
 }
@@ -262,38 +263,38 @@ write_item(void *cls, const struct GNUNET_HashCode *key, void *value)
  * Save the set of #work_finished items on disk.
  */
 static void
-save_state()
+save_state ()
 {
   uint32_t n;
   struct GNUNET_BIO_WriteHandle *wh;
   char *fn;
 
-  n = GNUNET_CONTAINER_multihashmap_size(work_finished);
-  fn = get_state_file();
-  wh = GNUNET_BIO_write_open(fn);
+  n = GNUNET_CONTAINER_multihashmap_size (work_finished);
+  fn = get_state_file ();
+  wh = GNUNET_BIO_write_open (fn);
   if (NULL == wh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failed to save state to file %s\n"),
-                 fn);
-      GNUNET_free(fn);
-      return;
-    }
-  if (GNUNET_OK != GNUNET_BIO_write_int32(wh, n))
-    {
-      (void)GNUNET_BIO_write_close(wh);
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Failed to save state to file %s\n"),
-                 fn);
-      GNUNET_free(fn);
-      return;
-    }
-  (void)GNUNET_CONTAINER_multihashmap_iterate(work_finished, &write_item, wh);
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-               _("Failed to save state to file %s\n"),
-               fn);
-  GNUNET_free(fn);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to save state to file %s\n"),
+                fn);
+    GNUNET_free (fn);
+    return;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_int32 (wh, n))
+  {
+    (void) GNUNET_BIO_write_close (wh);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to save state to file %s\n"),
+                fn);
+    GNUNET_free (fn);
+    return;
+  }
+  (void) GNUNET_CONTAINER_multihashmap_iterate (work_finished, &write_item, wh);
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to save state to file %s\n"),
+                fn);
+  GNUNET_free (fn);
 }
 
 
@@ -303,19 +304,19 @@ save_state()
  * @param cls closure, unused
  */
 static void
-do_stop_task(void *cls)
+do_stop_task (void *cls)
 {
   do_shutdown = GNUNET_YES;
   if (NULL != publish_proc)
-    {
-      GNUNET_OS_process_kill(publish_proc, SIGKILL);
-      return;
-    }
+  {
+    GNUNET_OS_process_kill (publish_proc, SIGKILL);
+    return;
+  }
   if (NULL != run_task)
-    {
-      GNUNET_SCHEDULER_cancel(run_task);
-      run_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (run_task);
+    run_task = NULL;
+  }
 }
 
 
@@ -323,7 +324,7 @@ do_stop_task(void *cls)
  * Decide what the next task is (working or scanning) and schedule it.
  */
 static void
-schedule_next_task(void);
+schedule_next_task (void);
 
 
 /**
@@ -333,7 +334,7 @@ schedule_next_task(void);
  * @param cls the `struct WorkItem` we were working on
  */
 static void
-maint_child_death(void *cls)
+maint_child_death (void *cls)
 {
   struct WorkItem *wi = cls;
   struct GNUNET_HashCode key;
@@ -345,65 +346,65 @@ maint_child_death(void *cls)
   const struct GNUNET_SCHEDULER_TaskContext *tc;
 
   run_task = NULL;
-  pr = GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ);
-  tc = GNUNET_SCHEDULER_get_task_context();
+  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
+  tc = GNUNET_SCHEDULER_get_task_context ();
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
-    {
-      /* shutdown scheduled us, someone else will kill child,
-         we should just try again */
-      run_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
-                                                pr,
-                                                &maint_child_death,
-                                                wi);
-      return;
-    }
+  {
+    /* shutdown scheduled us, someone else will kill child,
+       we should just try again */
+    run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                               pr,
+                                               &maint_child_death,
+                                               wi);
+    return;
+  }
   /* consume the signal */
-  GNUNET_break(0 < GNUNET_DISK_file_read(pr, &c, sizeof(c)));
+  GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof(c)));
 
-  ret = GNUNET_OS_process_status(publish_proc, &type, &code);
-  GNUNET_assert(GNUNET_SYSERR != ret);
+  ret = GNUNET_OS_process_status (publish_proc, &type, &code);
+  GNUNET_assert (GNUNET_SYSERR != ret);
   if (GNUNET_NO == ret)
-    {
-      /* process still running? Then where did the SIGCHLD come from?
-         Well, let's declare it spurious (kernel bug?) and keep rolling.
-       */
-      GNUNET_break(0);
-      run_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
-                                                pr,
-                                                &maint_child_death,
-                                                wi);
-      return;
-    }
-  GNUNET_assert(GNUNET_OK == ret);
-
-  GNUNET_OS_process_destroy(publish_proc);
+  {
+    /* process still running? Then where did the SIGCHLD come from?
+       Well, let's declare it spurious (kernel bug?) and keep rolling.
+     */
+    GNUNET_break (0);
+    run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                               pr,
+                                               &maint_child_death,
+                                               wi);
+    return;
+  }
+  GNUNET_assert (GNUNET_OK == ret);
+
+  GNUNET_OS_process_destroy (publish_proc);
   publish_proc = NULL;
 
   if (GNUNET_YES == do_shutdown)
-    {
-      GNUNET_free(wi->filename);
-      GNUNET_free(wi);
-      return;
-    }
+  {
+    GNUNET_free (wi->filename);
+    GNUNET_free (wi);
+    return;
+  }
   if ((GNUNET_OS_PROCESS_EXITED == type) && (0 == code))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                 _("Publication of `%s' done\n"),
-                 wi->filename);
-      GNUNET_CRYPTO_hash(wi->filename, strlen(wi->filename), &key);
-      GNUNET_break(GNUNET_OK ==
-                   GNUNET_CONTAINER_multihashmap_put(
-                     work_finished,
-                     &key,
-                     wi,
-                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _ ("Publication of `%s' done\n"),
+                wi->filename);
+    GNUNET_CRYPTO_hash (wi->filename, strlen (wi->filename), &key);
+    GNUNET_break (GNUNET_OK ==
+                  GNUNET_CONTAINER_multihashmap_put (
+                    work_finished,
+                    &key,
+                    wi,
+                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  }
   else
-    {
-      GNUNET_CONTAINER_DLL_insert_tail(work_head, work_tail, wi);
-    }
-  save_state();
-  schedule_next_task();
+  {
+    GNUNET_CONTAINER_DLL_insert_tail (work_head, work_tail, wi);
+  }
+  save_state ();
+  schedule_next_task ();
 }
 
 
@@ -412,17 +413,17 @@ maint_child_death(void *cls)
  * respective handler by writing to the trigger pipe.
  */
 static void
-sighandler_child_death()
+sighandler_child_death ()
 {
   static char c;
   int old_errno = errno; /* back-up errno */
 
-  GNUNET_break(
+  GNUNET_break (
     1 ==
-    GNUNET_DISK_file_write(GNUNET_DISK_pipe_handle(sigpipe,
-                                                   GNUNET_DISK_PIPE_END_WRITE),
-                           &c,
-                           sizeof(c)));
+    GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle (sigpipe,
+                                                     GNUNET_DISK_PIPE_END_WRITE),
+                            &c,
+                            sizeof(c)));
   errno = old_errno; /* restore errno */
 }
 
@@ -433,7 +434,7 @@ sighandler_child_death()
  * @param cls closure, NULL
  */
 static void
-work(void *cls)
+work (void *cls)
 {
   static char *argv[14];
   static char anon_level[20];
@@ -445,7 +446,7 @@ work(void *cls)
 
   run_task = NULL;
   wi = work_head;
-  GNUNET_CONTAINER_DLL_remove(work_head, work_tail, wi);
+  GNUNET_CONTAINER_DLL_remove (work_head, work_tail, wi);
   argc = 0;
   argv[argc++] = "gnunet-publish";
   if (verbose)
@@ -456,41 +457,41 @@ work(void *cls)
     argv[argc++] = "-d";
   argv[argc++] = "-c";
   argv[argc++] = cfg_filename;
-  GNUNET_snprintf(anon_level, sizeof(anon_level), "%u", anonymity_level);
+  GNUNET_snprintf (anon_level, sizeof(anon_level), "%u", anonymity_level);
   argv[argc++] = "-a";
   argv[argc++] = anon_level;
-  GNUNET_snprintf(content_prio, sizeof(content_prio), "%u", content_priority);
+  GNUNET_snprintf (content_prio, sizeof(content_prio), "%u", content_priority);
   argv[argc++] = "-p";
   argv[argc++] = content_prio;
-  GNUNET_snprintf(repl_level, sizeof(repl_level), "%u", replication_level);
+  GNUNET_snprintf (repl_level, sizeof(repl_level), "%u", replication_level);
   argv[argc++] = "-r";
   argv[argc++] = repl_level;
   argv[argc++] = wi->filename;
   argv[argc] = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO, _("Publishing `%s'\n"), wi->filename);
-  GNUNET_assert(NULL == publish_proc);
-  publish_proc = GNUNET_OS_start_process_vap(GNUNET_YES,
-                                             0,
-                                             NULL,
-                                             NULL,
-                                             NULL,
-                                             "gnunet-publish",
-                                             argv);
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO, _ ("Publishing `%s'\n"), wi->filename);
+  GNUNET_assert (NULL == publish_proc);
+  publish_proc = GNUNET_OS_start_process_vap (GNUNET_YES,
+                                              0,
+                                              NULL,
+                                              NULL,
+                                              NULL,
+                                              "gnunet-publish",
+                                              argv);
   if (NULL == publish_proc)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to run `%s'\n"),
-                 "gnunet-publish");
-      GNUNET_CONTAINER_DLL_insert(work_head, work_tail, wi);
-      run_task =
-        GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, &work, NULL);
-      return;
-    }
-  pr = GNUNET_DISK_pipe_handle(sigpipe, GNUNET_DISK_PIPE_END_READ);
-  run_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL,
-                                            pr,
-                                            &maint_child_death,
-                                            wi);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to run `%s'\n"),
+                "gnunet-publish");
+    GNUNET_CONTAINER_DLL_insert (work_head, work_tail, wi);
+    run_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &work, NULL);
+    return;
+  }
+  pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
+  run_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
+                                             pr,
+                                             &maint_child_death,
+                                             wi);
 }
 
 
@@ -503,39 +504,39 @@ work(void *cls)
  * @return #GNUNET_OK (always)
  */
 static int
-determine_id(void *cls, const char *filename)
+determine_id (void *cls, const char *filename)
 {
   struct GNUNET_HashCode *id = cls;
   struct stat sbuf;
   struct GNUNET_HashCode fx[2];
   struct GNUNET_HashCode ft;
 
-  if (0 != stat(filename, &sbuf))
-    {
-      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_WARNING, "stat", filename);
-      return GNUNET_OK;
-    }
-  GNUNET_CRYPTO_hash(filename, strlen(filename), &fx[0]);
-  if (!S_ISDIR(sbuf.st_mode))
-    {
-      uint64_t fattr[2];
-
-      fattr[0] = GNUNET_htonll(sbuf.st_size);
-      fattr[0] = GNUNET_htonll(sbuf.st_mtime);
-
-      GNUNET_CRYPTO_hash(fattr, sizeof(fattr), &fx[1]);
-    }
+  if (0 != stat (filename, &sbuf))
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+    return GNUNET_OK;
+  }
+  GNUNET_CRYPTO_hash (filename, strlen (filename), &fx[0]);
+  if (! S_ISDIR (sbuf.st_mode))
+  {
+    uint64_t fattr[2];
+
+    fattr[0] = GNUNET_htonll (sbuf.st_size);
+    fattr[0] = GNUNET_htonll (sbuf.st_mtime);
+
+    GNUNET_CRYPTO_hash (fattr, sizeof(fattr), &fx[1]);
+  }
   else
-    {
-      memset(&fx[1], 1, sizeof(struct GNUNET_HashCode));
-      GNUNET_DISK_directory_scan(filename, &determine_id, &fx[1]);
-    }
+  {
+    memset (&fx[1], 1, sizeof(struct GNUNET_HashCode));
+    GNUNET_DISK_directory_scan (filename, &determine_id, &fx[1]);
+  }
   /* use hash here to make hierarchical structure distinct from
      all files on the same level */
-  GNUNET_CRYPTO_hash(fx, sizeof(fx), &ft);
+  GNUNET_CRYPTO_hash (fx, sizeof(fx), &ft);
   /* use XOR here so that order of the files in the directory
      does not matter! */
-  GNUNET_CRYPTO_hash_xor(&ft, id, id);
+  GNUNET_CRYPTO_hash_xor (&ft, id, id);
   return GNUNET_OK;
 }
 
@@ -550,7 +551,7 @@ determine_id(void *cls, const char *filename)
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR during shutdown
  */
 static int
-add_file(void *cls, const char *filename)
+add_file (void *cls, const char *filename)
 {
   struct WorkItem *wi;
   struct GNUNET_HashCode key;
@@ -558,29 +559,29 @@ add_file(void *cls, const char *filename)
 
   if (GNUNET_YES == do_shutdown)
     return GNUNET_SYSERR;
-  if ((NULL != strstr(filename, "/.auto-share")) ||
-      (NULL != strstr(filename, "\\.auto-share")))
+  if ((NULL != strstr (filename, "/.auto-share")) ||
+      (NULL != strstr (filename, "\\.auto-share")))
     return GNUNET_OK; /* skip internal file */
-  GNUNET_CRYPTO_hash(filename, strlen(filename), &key);
-  wi = GNUNET_CONTAINER_multihashmap_get(work_finished, &key);
-  memset(&id, 0, sizeof(struct GNUNET_HashCode));
-  determine_id(&id, filename);
+  GNUNET_CRYPTO_hash (filename, strlen (filename), &key);
+  wi = GNUNET_CONTAINER_multihashmap_get (work_finished, &key);
+  memset (&id, 0, sizeof(struct GNUNET_HashCode));
+  determine_id (&id, filename);
   if (NULL != wi)
-    {
-      if (0 == memcmp(&id, &wi->id, sizeof(struct GNUNET_HashCode)))
-        return GNUNET_OK; /* skip: we did this one already */
-      /* contents changed, need to re-do the directory... */
-      GNUNET_assert(
-        GNUNET_YES ==
-        GNUNET_CONTAINER_multihashmap_remove(work_finished, &key, wi));
-    }
+  {
+    if (0 == memcmp (&id, &wi->id, sizeof(struct GNUNET_HashCode)))
+      return GNUNET_OK;   /* skip: we did this one already */
+    /* contents changed, need to re-do the directory... */
+    GNUNET_assert (
+      GNUNET_YES ==
+      GNUNET_CONTAINER_multihashmap_remove (work_finished, &key, wi));
+  }
   else
-    {
-      wi = GNUNET_new(struct WorkItem);
-      wi->filename = GNUNET_strdup(filename);
-    }
+  {
+    wi = GNUNET_new (struct WorkItem);
+    wi->filename = GNUNET_strdup (filename);
+  }
   wi->id = id;
-  GNUNET_CONTAINER_DLL_insert(work_head, work_tail, wi);
+  GNUNET_CONTAINER_DLL_insert (work_head, work_tail, wi);
   if (GNUNET_YES == do_shutdown)
     return GNUNET_SYSERR;
   return GNUNET_OK;
@@ -593,12 +594,12 @@ add_file(void *cls, const char *filename)
  * @param cls NULL
  */
 static void
-scan(void *cls)
+scan (void *cls)
 {
   run_task = NULL;
-  start_time = GNUNET_TIME_absolute_get();
-  (void)GNUNET_DISK_directory_scan(dir_name, &add_file, NULL);
-  schedule_next_task();
+  start_time = GNUNET_TIME_absolute_get ();
+  (void) GNUNET_DISK_directory_scan (dir_name, &add_file, NULL);
+  schedule_next_task ();
 }
 
 
@@ -606,27 +607,27 @@ scan(void *cls)
  * Decide what the next task is (working or scanning) and schedule it.
  */
 static void
-schedule_next_task()
+schedule_next_task ()
 {
   struct GNUNET_TIME_Relative delay;
 
   if (GNUNET_YES == do_shutdown)
     return;
-  GNUNET_assert(NULL == run_task);
+  GNUNET_assert (NULL == run_task);
   if (NULL == work_head)
-    {
-      /* delay by at most 4h, at least 1s, and otherwise in between depending
-         on how long it took to scan */
-      delay = GNUNET_TIME_absolute_get_duration(start_time);
-      delay = GNUNET_TIME_relative_saturating_multiply(delay, 100);
-      delay = GNUNET_TIME_relative_min(delay, MAX_DELAY);
-      delay = GNUNET_TIME_relative_max(delay, MIN_DELAY);
-      run_task = GNUNET_SCHEDULER_add_delayed(delay, &scan, NULL);
-    }
+  {
+    /* delay by at most 4h, at least 1s, and otherwise in between depending
+       on how long it took to scan */
+    delay = GNUNET_TIME_absolute_get_duration (start_time);
+    delay = GNUNET_TIME_relative_saturating_multiply (delay, 100);
+    delay = GNUNET_TIME_relative_min (delay, MAX_DELAY);
+    delay = GNUNET_TIME_relative_max (delay, MIN_DELAY);
+    run_task = GNUNET_SCHEDULER_add_delayed (delay, &scan, NULL);
+  }
   else
-    {
-      run_task = GNUNET_SCHEDULER_add_now(&work, NULL);
-    }
+  {
+    run_task = GNUNET_SCHEDULER_add_now (&work, NULL);
+  }
 }
 
 
@@ -639,29 +640,29 @@ schedule_next_task()
  * @param c configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
   /* check arguments */
   if ((NULL == args[0]) || (NULL != args[1]) ||
-      (GNUNET_YES != GNUNET_DISK_directory_test(args[0], GNUNET_YES)))
-    {
-      printf(_(
-               "You must specify one and only one directory name for automatic publication.\n"));
-      ret = -1;
-      return;
-    }
-  cfg_filename = GNUNET_strdup(cfgfile);
+      (GNUNET_YES != GNUNET_DISK_directory_test (args[0], GNUNET_YES)))
+  {
+    printf (_ (
+              "You must specify one and only one directory name for automatic publication.\n"));
+    ret = -1;
+    return;
+  }
+  cfg_filename = GNUNET_strdup (cfgfile);
   cfg = c;
   dir_name = args[0];
-  work_finished = GNUNET_CONTAINER_multihashmap_create(1024, GNUNET_NO);
-  load_state();
-  run_task = GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                                &scan,
-                                                NULL);
-  GNUNET_SCHEDULER_add_shutdown(&do_stop_task, NULL);
+  work_finished = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
+  load_state ();
+  run_task = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                                 &scan,
+                                                 NULL);
+  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
 }
 
 
@@ -674,12 +675,12 @@ run(void *cls,
  * @return #GNUNET_OK to continue to iterate
  */
 static int
-free_item(void *cls, const struct GNUNET_HashCode *key, void *value)
+free_item (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct WorkItem *wi = value;
 
-  GNUNET_free(wi->filename);
-  GNUNET_free(wi);
+  GNUNET_free (wi->filename);
+  GNUNET_free (wi);
   return GNUNET_OK;
 }
 
@@ -692,44 +693,44 @@ free_item(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_uint('a',
-                              "anonymity",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired LEVEL of sender-anonymity"),
-                              &anonymity_level),
-
-    GNUNET_GETOPT_option_flag(
+    GNUNET_GETOPT_option_uint ('a',
+                               "anonymity",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired LEVEL of sender-anonymity"),
+                               &anonymity_level),
+
+    GNUNET_GETOPT_option_flag (
       'd',
       "disable-creation-time",
-      gettext_noop(
+      gettext_noop (
         "disable adding the creation time to the metadata of the uploaded file"),
       &do_disable_creation_time),
 
-    GNUNET_GETOPT_option_flag(
+    GNUNET_GETOPT_option_flag (
       'D',
       "disable-extractor",
-      gettext_noop("do not use libextractor to add keywords or metadata"),
+      gettext_noop ("do not use libextractor to add keywords or metadata"),
       &disable_extractor),
 
-    GNUNET_GETOPT_option_uint('p',
-                              "priority",
-                              "PRIORITY",
-                              gettext_noop(
-                                "specify the priority of the content"),
-                              &content_priority),
+    GNUNET_GETOPT_option_uint ('p',
+                               "priority",
+                               "PRIORITY",
+                               gettext_noop (
+                                 "specify the priority of the content"),
+                               &content_priority),
 
-    GNUNET_GETOPT_option_uint('r',
-                              "replication",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired replication LEVEL"),
-                              &replication_level),
+    GNUNET_GETOPT_option_uint ('r',
+                               "replication",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired replication LEVEL"),
+                               &replication_level),
 
-    GNUNET_GETOPT_option_verbose(&verbose),
+    GNUNET_GETOPT_option_verbose (&verbose),
 
     GNUNET_GETOPT_OPTION_END
   };
@@ -737,44 +738,44 @@ main(int argc, char *const *argv)
   int ok;
   struct GNUNET_SIGNAL_Context *shc_chld;
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
-  sigpipe = GNUNET_DISK_pipe(GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
-  GNUNET_assert(NULL != sigpipe);
+  sigpipe = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
+  GNUNET_assert (NULL != sigpipe);
   shc_chld =
-    GNUNET_SIGNAL_handler_install(GNUNET_SIGCHLD, &sighandler_child_death);
+    GNUNET_SIGNAL_handler_install (GNUNET_SIGCHLD, &sighandler_child_death);
   ok =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run(
+     GNUNET_PROGRAM_run (
        argc,
        argv,
        "gnunet-auto-share [OPTIONS] FILENAME",
-       gettext_noop("Automatically publish files from a directory on GNUnet"),
+       gettext_noop ("Automatically publish files from a directory on GNUnet"),
        options,
        &run,
        NULL))
     ? ret
     : 1;
   if (NULL != work_finished)
-    {
-      (void)GNUNET_CONTAINER_multihashmap_iterate(work_finished,
+  {
+    (void) GNUNET_CONTAINER_multihashmap_iterate (work_finished,
                                                   &free_item,
                                                   NULL);
-      GNUNET_CONTAINER_multihashmap_destroy(work_finished);
-    }
+    GNUNET_CONTAINER_multihashmap_destroy (work_finished);
+  }
   while (NULL != (wi = work_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(work_head, work_tail, wi);
-      GNUNET_free(wi->filename);
-      GNUNET_free(wi);
-    }
-  GNUNET_SIGNAL_handler_uninstall(shc_chld);
+  {
+    GNUNET_CONTAINER_DLL_remove (work_head, work_tail, wi);
+    GNUNET_free (wi->filename);
+    GNUNET_free (wi);
+  }
+  GNUNET_SIGNAL_handler_uninstall (shc_chld);
   shc_chld = NULL;
-  GNUNET_DISK_pipe_close(sigpipe);
+  GNUNET_DISK_pipe_close (sigpipe);
   sigpipe = NULL;
-  GNUNET_free_non_null(cfg_filename);
+  GNUNET_free_non_null (cfg_filename);
   cfg_filename = NULL;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ok;
 }
 
diff --git a/src/fs/gnunet-daemon-fsprofiler.c b/src/fs/gnunet-daemon-fsprofiler.c
index 524475c40..0fe26fe8b 100644
--- a/src/fs/gnunet-daemon-fsprofiler.c
+++ b/src/fs/gnunet-daemon-fsprofiler.c
@@ -34,7 +34,8 @@
  * We use 'patterns' of the form (x,y,t) to specify desired download/publish
  * activities of a peer.  They are stored in a DLL.
  */
-struct Pattern {
+struct Pattern
+{
   /**
    * Kept in a DLL.
    */
@@ -68,12 +69,12 @@ struct Pattern {
   /**
    * Task to run the operation.
    */
-  struct GNUNET_SCHEDULER_Task * task;
+  struct GNUNET_SCHEDULER_Task *task;
 
   /**
    * Secondary task to run the operation.
    */
-  struct GNUNET_SCHEDULER_Task * stask;
+  struct GNUNET_SCHEDULER_Task *stask;
 
   /**
    * X-value.
@@ -172,29 +173,29 @@ static struct Pattern *download_tail;
  * @return GNUNET_OK on success
  */
 static int
-parse_pattern(struct Pattern **head,
-              struct Pattern **tail,
-              const char *pattern)
+parse_pattern (struct Pattern **head,
+               struct Pattern **tail,
+               const char *pattern)
 {
   struct Pattern *p;
   unsigned long long x;
   unsigned long long y;
   unsigned long long t;
 
-  while (3 == sscanf(pattern,
-                     "(%llu,%llu,%llu)",
-                     &x, &y, &t))
-    {
-      p = GNUNET_new(struct Pattern);
-      p->x = x;
-      p->y = y;
-      p->delay.rel_value_us = (uint64_t)t;
-      GNUNET_CONTAINER_DLL_insert(*head, *tail, p);
-      pattern = strstr(pattern, ")");
-      GNUNET_assert(NULL != pattern);
-      pattern++;
-    }
-  return (0 == strlen(pattern)) ? GNUNET_OK : GNUNET_SYSERR;
+  while (3 == sscanf (pattern,
+                      "(%llu,%llu,%llu)",
+                      &x, &y, &t))
+  {
+    p = GNUNET_new (struct Pattern);
+    p->x = x;
+    p->y = y;
+    p->delay.rel_value_us = (uint64_t) t;
+    GNUNET_CONTAINER_DLL_insert (*head, *tail, p);
+    pattern = strstr (pattern, ")");
+    GNUNET_assert (NULL != pattern);
+    pattern++;
+  }
+  return (0 == strlen (pattern)) ? GNUNET_OK : GNUNET_SYSERR;
 }
 
 
@@ -205,13 +206,13 @@ parse_pattern(struct Pattern **head,
  * @return corresponding KSK URI
  */
 static struct GNUNET_FS_Uri *
-make_keywords(uint64_t kval)
+make_keywords (uint64_t kval)
 {
   char kw[128];
 
-  GNUNET_snprintf(kw, sizeof(kw),
-                  "%llu", (unsigned long long)kval);
-  return GNUNET_FS_uri_ksk_create(kw, NULL);
+  GNUNET_snprintf (kw, sizeof(kw),
+                   "%llu", (unsigned long long) kval);
+  return GNUNET_FS_uri_ksk_create (kw, NULL);
 }
 
 
@@ -225,9 +226,9 @@ make_keywords(uint64_t kval)
  * @return file information handle for the file
  */
 static struct GNUNET_FS_FileInformation *
-make_file(uint64_t length,
-          uint64_t kval,
-          void *ctx)
+make_file (uint64_t length,
+           uint64_t kval,
+           void *ctx)
 {
   struct GNUNET_FS_FileInformation *fi;
   struct GNUNET_FS_BlockOptions bo;
@@ -238,26 +239,26 @@ make_file(uint64_t length,
 
   data = NULL; /* to make compilers happy */
   if ((0 != length) &&
-      (NULL == (data = GNUNET_malloc_large((size_t)length))))
+      (NULL == (data = GNUNET_malloc_large ((size_t) length))))
     return NULL;
   /* initialize data with 'unique' data only depending on 'kval' and 'size',
      making sure that blocks do not repeat */
   for (i = 0; i < length; i += 8)
-    {
-      xor = length ^ kval ^ (uint64_t)(i / 32 / 1024);
-      GNUNET_memcpy(&data[i], &xor, GNUNET_MIN(length - i, sizeof(uint64_t)));
-    }
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_DAYS);
-  bo.anonymity_level = (uint32_t)anonymity_level;
+  {
+    xor = length ^ kval ^ (uint64_t) (i / 32 / 1024);
+    GNUNET_memcpy (&data[i], &xor, GNUNET_MIN (length - i, sizeof(uint64_t)));
+  }
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_DAYS);
+  bo.anonymity_level = (uint32_t) anonymity_level;
   bo.content_priority = 128;
-  bo.replication_level = (uint32_t)replication_level;
-  keywords = make_keywords(kval);
-  fi = GNUNET_FS_file_information_create_from_data(fs_handle,
-                                                   ctx,
-                                                   length,
-                                                   data, keywords,
-                                                   NULL, GNUNET_NO, &bo);
-  GNUNET_FS_uri_destroy(keywords);
+  bo.replication_level = (uint32_t) replication_level;
+  keywords = make_keywords (kval);
+  fi = GNUNET_FS_file_information_create_from_data (fs_handle,
+                                                    ctx,
+                                                    length,
+                                                    data, keywords,
+                                                    NULL, GNUNET_NO, &bo);
+  GNUNET_FS_uri_destroy (keywords);
   return fi;
 }
 
@@ -268,42 +269,42 @@ make_file(uint64_t length,
  * @param cls unused
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   struct Pattern *p;
 
   while (NULL != (p = publish_head))
-    {
-      if (NULL != p->task)
-        GNUNET_SCHEDULER_cancel(p->task);
-      if (NULL != p->ctx)
-        GNUNET_FS_publish_stop(p->ctx);
-      GNUNET_CONTAINER_DLL_remove(publish_head, publish_tail, p);
-      GNUNET_free(p);
-    }
+  {
+    if (NULL != p->task)
+      GNUNET_SCHEDULER_cancel (p->task);
+    if (NULL != p->ctx)
+      GNUNET_FS_publish_stop (p->ctx);
+    GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
+    GNUNET_free (p);
+  }
   while (NULL != (p = download_head))
-    {
-      if (NULL != p->task)
-        GNUNET_SCHEDULER_cancel(p->task);
-      if (NULL != p->stask)
-        GNUNET_SCHEDULER_cancel(p->stask);
-      if (NULL != p->ctx)
-        GNUNET_FS_download_stop(p->ctx, GNUNET_YES);
-      if (NULL != p->sctx)
-        GNUNET_FS_search_stop(p->sctx);
-      GNUNET_CONTAINER_DLL_remove(download_head, download_tail, p);
-      GNUNET_free(p);
-    }
+  {
+    if (NULL != p->task)
+      GNUNET_SCHEDULER_cancel (p->task);
+    if (NULL != p->stask)
+      GNUNET_SCHEDULER_cancel (p->stask);
+    if (NULL != p->ctx)
+      GNUNET_FS_download_stop (p->ctx, GNUNET_YES);
+    if (NULL != p->sctx)
+      GNUNET_FS_search_stop (p->sctx);
+    GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
+    GNUNET_free (p);
+  }
   if (NULL != fs_handle)
-    {
-      GNUNET_FS_stop(fs_handle);
-      fs_handle = NULL;
-    }
+  {
+    GNUNET_FS_stop (fs_handle);
+    fs_handle = NULL;
+  }
   if (NULL != stats_handle)
-    {
-      GNUNET_STATISTICS_destroy(stats_handle, GNUNET_YES);
-      stats_handle = NULL;
-    }
+  {
+    GNUNET_STATISTICS_destroy (stats_handle, GNUNET_YES);
+    stats_handle = NULL;
+  }
 }
 
 
@@ -313,12 +314,12 @@ shutdown_task(void *cls)
  * @param cls the 'struct Pattern' of the publish operation to stop
  */
 static void
-publish_stop_task(void *cls)
+publish_stop_task (void *cls)
 {
   struct Pattern *p = cls;
 
   p->task = NULL;
-  GNUNET_FS_publish_stop(p->ctx);
+  GNUNET_FS_publish_stop (p->ctx);
 }
 
 
@@ -328,12 +329,12 @@ publish_stop_task(void *cls)
  * @param cls the 'struct Pattern' of the download operation to stop
  */
 static void
-download_stop_task(void *cls)
+download_stop_task (void *cls)
 {
   struct Pattern *p = cls;
 
   p->task = NULL;
-  GNUNET_FS_download_stop(p->ctx, GNUNET_YES);
+  GNUNET_FS_download_stop (p->ctx, GNUNET_YES);
 }
 
 
@@ -343,12 +344,12 @@ download_stop_task(void *cls)
  * @param cls the 'struct Pattern' of the download operation to stop
  */
 static void
-search_stop_task(void *cls)
+search_stop_task (void *cls)
 {
   struct Pattern *p = cls;
 
   p->stask = NULL;
-  GNUNET_FS_search_stop(p->sctx);
+  GNUNET_FS_search_stop (p->sctx);
 }
 
 
@@ -368,138 +369,141 @@ search_stop_task(void *cls)
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
 static void *
-progress_cb(void *cls,
-            const struct GNUNET_FS_ProgressInfo *info)
+progress_cb (void *cls,
+             const struct GNUNET_FS_ProgressInfo *info)
 {
   struct Pattern *p;
   const struct GNUNET_FS_Uri *uri;
 
   switch (info->status)
+  {
+  case GNUNET_FS_STATUS_PUBLISH_START:
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    p = info->value.publish.cctx;
+    return p;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    p = info->value.publish.cctx;
+    return p;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Publishing failed\n");
+    GNUNET_STATISTICS_update (stats_handle,
+                              "# failed publish operations", 1, GNUNET_NO);
+    p = info->value.publish.cctx;
+    p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
+    return p;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    p = info->value.publish.cctx;
+    GNUNET_STATISTICS_update (stats_handle,
+                              "# publishing time (ms)",
+                              (long long) GNUNET_TIME_absolute_get_duration (
+                                p->start_time).rel_value_us / 1000LL,
+                              GNUNET_NO);
+    p->task = GNUNET_SCHEDULER_add_now (&publish_stop_task, p);
+    return p;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    p = info->value.publish.cctx;
+    p->ctx = NULL;
+    GNUNET_CONTAINER_DLL_remove (publish_head, publish_tail, p);
+    GNUNET_free (p);
+    return NULL;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_START:
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+    p = info->value.download.cctx;
+    return p;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Download failed\n");
+    GNUNET_STATISTICS_update (stats_handle,
+                              "# failed downloads", 1, GNUNET_NO);
+    p = info->value.download.cctx;
+    p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
+    return p;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    p = info->value.download.cctx;
+    GNUNET_STATISTICS_update (stats_handle,
+                              "# download time (ms)",
+                              (long long) GNUNET_TIME_absolute_get_duration (
+                                p->start_time).rel_value_us / 1000LL,
+                              GNUNET_NO);
+    p->task = GNUNET_SCHEDULER_add_now (&download_stop_task, p);
+    return p;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+    p = info->value.download.cctx;
+    p->ctx = NULL;
+    if (NULL == p->sctx)
     {
-    case GNUNET_FS_STATUS_PUBLISH_START:
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      p = info->value.publish.cctx;
-      return p;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      p = info->value.publish.cctx;
-      return p;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Publishing failed\n");
-      GNUNET_STATISTICS_update(stats_handle,
-                               "# failed publish operations", 1, GNUNET_NO);
-      p = info->value.publish.cctx;
-      p->task = GNUNET_SCHEDULER_add_now(&publish_stop_task, p);
-      return p;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      p = info->value.publish.cctx;
-      GNUNET_STATISTICS_update(stats_handle,
-                               "# publishing time (ms)",
-                               (long long)GNUNET_TIME_absolute_get_duration(p->start_time).rel_value_us / 1000LL,
-                               GNUNET_NO);
-      p->task = GNUNET_SCHEDULER_add_now(&publish_stop_task, p);
-      return p;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      p = info->value.publish.cctx;
-      p->ctx = NULL;
-      GNUNET_CONTAINER_DLL_remove(publish_head, publish_tail, p);
-      GNUNET_free(p);
-      return NULL;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_START:
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-    case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
-      p = info->value.download.cctx;
-      return p;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Download failed\n");
-      GNUNET_STATISTICS_update(stats_handle,
-                               "# failed downloads", 1, GNUNET_NO);
-      p = info->value.download.cctx;
-      p->task = GNUNET_SCHEDULER_add_now(&download_stop_task, p);
-      return p;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      p = info->value.download.cctx;
-      GNUNET_STATISTICS_update(stats_handle,
-                               "# download time (ms)",
-                               (long long)GNUNET_TIME_absolute_get_duration(p->start_time).rel_value_us / 1000LL,
-                               GNUNET_NO);
-      p->task = GNUNET_SCHEDULER_add_now(&download_stop_task, p);
-      return p;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
-      p = info->value.download.cctx;
-      p->ctx = NULL;
-      if (NULL == p->sctx)
-        {
-          GNUNET_CONTAINER_DLL_remove(download_head, download_tail, p);
-          GNUNET_free(p);
-        }
-      return NULL;
-
-    case GNUNET_FS_STATUS_SEARCH_START:
-    case GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE:
-      p = info->value.search.cctx;
-      return p;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT:
-      p = info->value.search.cctx;
-      uri = info->value.search.specifics.result.uri;
-      if (GNUNET_YES != GNUNET_FS_uri_test_chk(uri))
-        return NULL; /* not what we want */
-      if (p->y != GNUNET_FS_uri_chk_get_file_size(uri))
-        return NULL; /* not what we want */
-      GNUNET_STATISTICS_update(stats_handle,
-                               "# search time (ms)",
-                               (long long)GNUNET_TIME_absolute_get_duration(p->start_time).rel_value_us / 1000LL,
-                               GNUNET_NO);
-      p->start_time = GNUNET_TIME_absolute_get();
-      p->ctx = GNUNET_FS_download_start(fs_handle, uri,
-                                        NULL, NULL, NULL,
-                                        0, GNUNET_FS_uri_chk_get_file_size(uri),
-                                        anonymity_level,
-                                        GNUNET_FS_DOWNLOAD_NO_TEMPORARIES,
-                                        p,
-                                        NULL);
-      p->stask = GNUNET_SCHEDULER_add_now(&search_stop_task, p);
-      return NULL;
-
-    case GNUNET_FS_STATUS_SEARCH_UPDATE:
-    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
-      return NULL; /* don't care */
-
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Search failed\n");
-      GNUNET_STATISTICS_update(stats_handle,
-                               "# failed searches", 1, GNUNET_NO);
-      p = info->value.search.cctx;
-      p->stask = GNUNET_SCHEDULER_add_now(&search_stop_task, p);
-      return p;
-
-    case GNUNET_FS_STATUS_SEARCH_STOPPED:
-      p = info->value.search.cctx;
-      p->sctx = NULL;
-      if (NULL == p->ctx)
-        {
-          GNUNET_CONTAINER_DLL_remove(download_head, download_tail, p);
-          GNUNET_free(p);
-        }
-      return NULL;
-
-    default:
-      /* unexpected event during profiling */
-      GNUNET_break(0);
-      return NULL;
+      GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
+      GNUNET_free (p);
     }
+    return NULL;
+
+  case GNUNET_FS_STATUS_SEARCH_START:
+  case GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE:
+    p = info->value.search.cctx;
+    return p;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    p = info->value.search.cctx;
+    uri = info->value.search.specifics.result.uri;
+    if (GNUNET_YES != GNUNET_FS_uri_test_chk (uri))
+      return NULL;   /* not what we want */
+    if (p->y != GNUNET_FS_uri_chk_get_file_size (uri))
+      return NULL;   /* not what we want */
+    GNUNET_STATISTICS_update (stats_handle,
+                              "# search time (ms)",
+                              (long long) GNUNET_TIME_absolute_get_duration (
+                                p->start_time).rel_value_us / 1000LL,
+                              GNUNET_NO);
+    p->start_time = GNUNET_TIME_absolute_get ();
+    p->ctx = GNUNET_FS_download_start (fs_handle, uri,
+                                       NULL, NULL, NULL,
+                                       0, GNUNET_FS_uri_chk_get_file_size (uri),
+                                       anonymity_level,
+                                       GNUNET_FS_DOWNLOAD_NO_TEMPORARIES,
+                                       p,
+                                       NULL);
+    p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
+    return NULL;
+
+  case GNUNET_FS_STATUS_SEARCH_UPDATE:
+  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+    return NULL;   /* don't care */
+
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Search failed\n");
+    GNUNET_STATISTICS_update (stats_handle,
+                              "# failed searches", 1, GNUNET_NO);
+    p = info->value.search.cctx;
+    p->stask = GNUNET_SCHEDULER_add_now (&search_stop_task, p);
+    return p;
+
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    p = info->value.search.cctx;
+    p->sctx = NULL;
+    if (NULL == p->ctx)
+    {
+      GNUNET_CONTAINER_DLL_remove (download_head, download_tail, p);
+      GNUNET_free (p);
+    }
+    return NULL;
+
+  default:
+    /* unexpected event during profiling */
+    GNUNET_break (0);
+    return NULL;
+  }
 }
 
 
@@ -509,18 +513,18 @@ progress_cb(void *cls,
  * @param cls the 'struct Pattern' specifying the operation to perform
  */
 static void
-start_publish(void *cls)
+start_publish (void *cls)
 {
   struct Pattern *p = cls;
   struct GNUNET_FS_FileInformation *fi;
 
   p->task = NULL;
-  fi = make_file(p->x, p->y, p);
-  p->start_time = GNUNET_TIME_absolute_get();
-  p->ctx = GNUNET_FS_publish_start(fs_handle,
-                                   fi,
-                                   NULL, NULL, NULL,
-                                   GNUNET_FS_PUBLISH_OPTION_NONE);
+  fi = make_file (p->x, p->y, p);
+  p->start_time = GNUNET_TIME_absolute_get ();
+  p->ctx = GNUNET_FS_publish_start (fs_handle,
+                                    fi,
+                                    NULL, NULL, NULL,
+                                    GNUNET_FS_PUBLISH_OPTION_NONE);
 }
 
 
@@ -530,18 +534,18 @@ start_publish(void *cls)
  * @param cls the 'struct Pattern' specifying the operation to perform
  */
 static void
-start_download(void *cls)
+start_download (void *cls)
 {
   struct Pattern *p = cls;
   struct GNUNET_FS_Uri *keywords;
 
   p->task = NULL;
-  keywords = make_keywords(p->x);
-  p->start_time = GNUNET_TIME_absolute_get();
-  p->sctx = GNUNET_FS_search_start(fs_handle, keywords,
-                                   anonymity_level,
-                                   GNUNET_FS_SEARCH_OPTION_NONE,
-                                   p);
+  keywords = make_keywords (p->x);
+  p->start_time = GNUNET_TIME_absolute_get ();
+  p->sctx = GNUNET_FS_search_start (fs_handle, keywords,
+                                    anonymity_level,
+                                    GNUNET_FS_SEARCH_OPTION_NONE,
+                                    p);
 }
 
 
@@ -554,88 +558,89 @@ start_download(void *cls)
  * @param cfg_ configuration
  */
 static void
-run(void *cls, char *const *args GNUNET_UNUSED,
-    const char *cfgfile GNUNET_UNUSED,
-    const struct GNUNET_CONFIGURATION_Handle *cfg_)
+run (void *cls, char *const *args GNUNET_UNUSED,
+     const char *cfgfile GNUNET_UNUSED,
+     const struct GNUNET_CONFIGURATION_Handle *cfg_)
 {
   char myoptname[128];
   struct Pattern *p;
 
   cfg = cfg_;
   /* Scheduled the task to clean up when shutdown is called */
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
-                                NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 NULL);
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number(cfg,
-                                            "TESTBED", "PEERID",
-                                            &my_peerid))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
-                                "TESTBED", "PEERID");
-      global_ret = GNUNET_SYSERR;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             "TESTBED", "PEERID",
+                                             &my_peerid))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
+                               "TESTBED", "PEERID");
+    global_ret = GNUNET_SYSERR;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number(cfg,
-                                            "FSPROFILER", "ANONYMITY_LEVEL",
-                                            &anonymity_level))
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             "FSPROFILER", "ANONYMITY_LEVEL",
+                                             &anonymity_level))
     anonymity_level = 1;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number(cfg,
-                                            "FSPROFILER", "REPLICATION_LEVEL",
-                                            &replication_level))
+      GNUNET_CONFIGURATION_get_value_number (cfg,
+                                             "FSPROFILER", "REPLICATION_LEVEL",
+                                             &replication_level))
     replication_level = 1;
-  GNUNET_snprintf(myoptname, sizeof(myoptname),
-                  "DOWNLOAD-PATTERN-%u", my_peerid);
+  GNUNET_snprintf (myoptname, sizeof(myoptname),
+                   "DOWNLOAD-PATTERN-%u", my_peerid);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(cfg,
-                                            "FSPROFILER", myoptname,
-                                            &download_pattern))
-    download_pattern = GNUNET_strdup("");
-  GNUNET_snprintf(myoptname, sizeof(myoptname),
-                  "PUBLISH-PATTERN-%u", my_peerid);
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "FSPROFILER", myoptname,
+                                             &download_pattern))
+    download_pattern = GNUNET_strdup ("");
+  GNUNET_snprintf (myoptname, sizeof(myoptname),
+                   "PUBLISH-PATTERN-%u", my_peerid);
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(cfg,
-                                            "FSPROFILER", myoptname,
-                                            &publish_pattern))
-    publish_pattern = GNUNET_strdup("");
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "FSPROFILER", myoptname,
+                                             &publish_pattern))
+    publish_pattern = GNUNET_strdup ("");
   if ((GNUNET_OK !=
-       parse_pattern(&download_head,
-                     &download_tail,
-                     download_pattern)) ||
+       parse_pattern (&download_head,
+                      &download_tail,
+                      download_pattern)) ||
       (GNUNET_OK !=
-       parse_pattern(&publish_head,
-                     &publish_tail,
-                     publish_pattern)))
-    {
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-
-  stats_handle = GNUNET_STATISTICS_create("fsprofiler", cfg);
+       parse_pattern (&publish_head,
+                      &publish_tail,
+                      publish_pattern)))
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  stats_handle = GNUNET_STATISTICS_create ("fsprofiler", cfg);
   fs_handle =
-    GNUNET_FS_start(cfg,
-                    "fsprofiler",
-                    &progress_cb, NULL,
-                    GNUNET_FS_FLAGS_NONE,
-                    GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, 1,
-                    GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, 1,
-                    GNUNET_FS_OPTIONS_END);
+    GNUNET_FS_start (cfg,
+                     "fsprofiler",
+                     &progress_cb, NULL,
+                     GNUNET_FS_FLAGS_NONE,
+                     GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, 1,
+                     GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, 1,
+                     GNUNET_FS_OPTIONS_END);
   if (NULL == fs_handle)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Could not acquire FS handle. Exiting.\n");
-      global_ret = GNUNET_SYSERR;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Could not acquire FS handle. Exiting.\n");
+    global_ret = GNUNET_SYSERR;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   for (p = publish_head; NULL != p; p = p->next)
-    p->task = GNUNET_SCHEDULER_add_delayed(p->delay,
-                                           &start_publish, p);
+    p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
+                                            &start_publish, p);
   for (p = download_head; NULL != p; p = p->next)
-    p->task = GNUNET_SCHEDULER_add_delayed(p->delay,
-                                           &start_download, p);
+    p->task = GNUNET_SCHEDULER_add_delayed (p->delay,
+                                            &start_download, p);
 }
 
 
@@ -647,19 +652,20 @@ run(void *cls, char *const *args GNUNET_UNUSED,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   static const struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
   return (GNUNET_OK ==
-          GNUNET_PROGRAM_run(argc, argv, "gnunet-daemon-fsprofiler",
-                             gettext_noop
-                               ("Daemon to use file-sharing to measure its performance."),
-                             options, &run, NULL)) ? global_ret : 1;
+          GNUNET_PROGRAM_run (argc, argv, "gnunet-daemon-fsprofiler",
+                              gettext_noop
+                              (
+                                "Daemon to use file-sharing to measure its performance."),
+                              options, &run, NULL)) ? global_ret : 1;
 }
 
 /* end of gnunet-daemon-fsprofiler.c */
diff --git a/src/fs/gnunet-directory.c b/src/fs/gnunet-directory.c
index f33db109f..8819d1777 100644
--- a/src/fs/gnunet-directory.c
+++ b/src/fs/gnunet-directory.c
@@ -40,32 +40,32 @@ static int ret;
  * @return always 0 (to continue iterating)
  */
 static int
-item_printer(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_size)
+item_printer (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_size)
 {
   if (type == EXTRACTOR_METATYPE_GNUNET_FULL_DATA)
-    {
-      printf(_("\t<original file embedded in %u bytes of meta data>\n"),
-             (unsigned int)data_size);
-      return 0;
-    }
+  {
+    printf (_ ("\t<original file embedded in %u bytes of meta data>\n"),
+            (unsigned int) data_size);
+    return 0;
+  }
   if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
       (format != EXTRACTOR_METAFORMAT_C_STRING))
     return 0;
   if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
     return 0;
 #if HAVE_LIBEXTRACTOR
-  printf("\t%20s: %s\n",
-         dgettext(LIBEXTRACTOR_GETTEXT_DOMAIN,
-                  EXTRACTOR_metatype_to_string(type)),
-         data);
+  printf ("\t%20s: %s\n",
+          dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN,
+                    EXTRACTOR_metatype_to_string (type)),
+          data);
 #else
-  printf("\t%20d: %s\n", type, data);
+  printf ("\t%20d: %s\n", type, data);
 #endif
   return 0;
 }
@@ -87,34 +87,34 @@ item_printer(void *cls,
  * @param data data available for the file (length bytes)
  */
 static void
-print_entry(void *cls,
-            const char *filename,
-            const struct GNUNET_FS_Uri *uri,
-            const struct GNUNET_CONTAINER_MetaData *meta,
-            size_t length,
-            const void *data)
+print_entry (void *cls,
+             const char *filename,
+             const struct GNUNET_FS_Uri *uri,
+             const struct GNUNET_CONTAINER_MetaData *meta,
+             size_t length,
+             const void *data)
 {
   char *string;
   char *name;
 
-  name = GNUNET_CONTAINER_meta_data_get_by_type(
+  name = GNUNET_CONTAINER_meta_data_get_by_type (
     meta,
     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
   if (uri == NULL)
-    {
-      printf(_("Directory `%s' meta data:\n"), name ? name : "");
-      GNUNET_CONTAINER_meta_data_iterate(meta, &item_printer, NULL);
-      printf("\n");
-      printf(_("Directory `%s' contents:\n"), name ? name : "");
-      GNUNET_free_non_null(name);
-      return;
-    }
-  string = GNUNET_FS_uri_to_string(uri);
-  printf("%s (%s):\n", name ? name : "", string);
-  GNUNET_free(string);
-  GNUNET_CONTAINER_meta_data_iterate(meta, &item_printer, NULL);
-  printf("\n");
-  GNUNET_free_non_null(name);
+  {
+    printf (_ ("Directory `%s' meta data:\n"), name ? name : "");
+    GNUNET_CONTAINER_meta_data_iterate (meta, &item_printer, NULL);
+    printf ("\n");
+    printf (_ ("Directory `%s' contents:\n"), name ? name : "");
+    GNUNET_free_non_null (name);
+    return;
+  }
+  string = GNUNET_FS_uri_to_string (uri);
+  printf ("%s (%s):\n", name ? name : "", string);
+  GNUNET_free (string);
+  GNUNET_CONTAINER_meta_data_iterate (meta, &item_printer, NULL);
+  printf ("\n");
+  GNUNET_free_non_null (name);
 }
 
 
@@ -127,10 +127,10 @@ print_entry(void *cls,
  * @param cfg configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_DISK_MapHandle *map;
   struct GNUNET_DISK_FileHandle *h;
@@ -141,37 +141,37 @@ run(void *cls,
   int i;
 
   if (NULL == args[0])
-    {
-      fprintf(stderr, "%s", _("You must specify a filename to inspect.\n"));
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, "%s", _ ("You must specify a filename to inspect.\n"));
+    ret = 1;
+    return;
+  }
   i = 0;
   while (NULL != (filename = args[i++]))
+  {
+    if ((GNUNET_OK !=
+         GNUNET_DISK_file_size (filename, &size, GNUNET_YES, GNUNET_YES)) ||
+        (NULL == (h = GNUNET_DISK_file_open (filename,
+                                             GNUNET_DISK_OPEN_READ,
+                                             GNUNET_DISK_PERM_NONE))))
     {
-      if ((GNUNET_OK !=
-           GNUNET_DISK_file_size(filename, &size, GNUNET_YES, GNUNET_YES)) ||
-          (NULL == (h = GNUNET_DISK_file_open(filename,
-                                              GNUNET_DISK_OPEN_READ,
-                                              GNUNET_DISK_PERM_NONE))))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                     _("Failed to read directory `%s'\n"),
-                     filename);
-          ret = 1;
-          continue;
-        }
-      len = (size_t)size;
-      data = GNUNET_DISK_file_map(h, &map, GNUNET_DISK_MAP_TYPE_READ, len);
-      GNUNET_assert(NULL != data);
-      if (GNUNET_OK !=
-          GNUNET_FS_directory_list_contents(len, data, 0, &print_entry, NULL))
-        fprintf(stdout, _("`%s' is not a GNUnet directory\n"), filename);
-      else
-        printf("\n");
-      GNUNET_DISK_file_unmap(map);
-      GNUNET_DISK_file_close(h);
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _ ("Failed to read directory `%s'\n"),
+                  filename);
+      ret = 1;
+      continue;
     }
+    len = (size_t) size;
+    data = GNUNET_DISK_file_map (h, &map, GNUNET_DISK_MAP_TYPE_READ, len);
+    GNUNET_assert (NULL != data);
+    if (GNUNET_OK !=
+        GNUNET_FS_directory_list_contents (len, data, 0, &print_entry, NULL))
+      fprintf (stdout, _ ("`%s' is not a GNUnet directory\n"), filename);
+    else
+      printf ("\n");
+    GNUNET_DISK_file_unmap (map);
+    GNUNET_DISK_file_close (h);
+  }
 }
 
 /**
@@ -182,27 +182,27 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   static struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
   ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run(argc,
-                            argv,
-                            "gnunet-directory [OPTIONS] FILENAME",
-                            gettext_noop(
-                              "Display contents of a GNUnet directory"),
-                            options,
-                            &run,
-                            NULL))
+         GNUNET_PROGRAM_run (argc,
+                             argv,
+                             "gnunet-directory [OPTIONS] FILENAME",
+                             gettext_noop (
+                               "Display contents of a GNUnet directory"),
+                             options,
+                             &run,
+                             NULL))
         ? ret
         : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }
 
diff --git a/src/fs/gnunet-download.c b/src/fs/gnunet-download.c
index 14a43e6ec..05e102eac 100644
--- a/src/fs/gnunet-download.c
+++ b/src/fs/gnunet-download.c
@@ -54,21 +54,21 @@ static int local_only;
 
 
 static void
-cleanup_task(void *cls)
+cleanup_task (void *cls)
 {
-  GNUNET_FS_stop(ctx);
+  GNUNET_FS_stop (ctx);
   ctx = NULL;
 }
 
 
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   if (NULL != dc)
-    {
-      GNUNET_FS_download_stop(dc, delete_incomplete);
-      dc = NULL;
-    }
+  {
+    GNUNET_FS_download_stop (dc, delete_incomplete);
+    dc = NULL;
+  }
 }
 
 
@@ -80,25 +80,25 @@ shutdown_task(void *cls)
  * @param w desired number of steps in the progress bar
  */
 static void
-display_bar(unsigned long long x, unsigned long long n, unsigned int w)
+display_bar (unsigned long long x, unsigned long long n, unsigned int w)
 {
   char buf[w + 20];
   unsigned int p;
   unsigned int endeq;
   float ratio_complete;
 
-  if (0 == isatty(1))
+  if (0 == isatty (1))
     return;
-  ratio_complete = x / (float)n;
+  ratio_complete = x / (float) n;
   endeq = ratio_complete * w;
-  GNUNET_snprintf(buf, sizeof(buf), "%3d%% [", (int)(ratio_complete * 100));
+  GNUNET_snprintf (buf, sizeof(buf), "%3d%% [", (int) (ratio_complete * 100));
   for (p = 0; p < endeq; p++)
-    strcat(buf, "=");
+    strcat (buf, "=");
   for (p = endeq; p < w; p++)
-    strcat(buf, " ");
-  strcat(buf, "]\r");
-  printf("%s", buf);
-  fflush(stdout);
+    strcat (buf, " ");
+  strcat (buf, "]\r");
+  printf ("%s", buf);
+  fflush (stdout);
 }
 
 
@@ -116,96 +116,96 @@ display_bar(unsigned long long x, unsigned long long n, unsigned int w)
  *         field in the `struct GNUNET_FS_ProgressInfo`
  */
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   char *s;
   const char *s2;
   char *t;
 
   switch (info->status)
+  {
+  case GNUNET_FS_STATUS_DOWNLOAD_START:
+    if (verbose > 1)
+      fprintf (stderr,
+               _ ("Starting download `%s'.\n"),
+               info->value.download.filename);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    if (verbose)
     {
-    case GNUNET_FS_STATUS_DOWNLOAD_START:
-      if (verbose > 1)
-        fprintf(stderr,
-                _("Starting download `%s'.\n"),
-                info->value.download.filename);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
-      if (verbose)
-        {
-          s = GNUNET_strdup(
-            GNUNET_STRINGS_relative_time_to_string(info->value.download.eta,
-                                                   GNUNET_YES));
-          if (info->value.download.specifics.progress.block_download_duration
-              .rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
-            s2 = _("<unknown time>");
-          else
-            s2 = GNUNET_STRINGS_relative_time_to_string(info->value.download
-                                                        .specifics.progress
-                                                        .block_download_duration,
-                                                        GNUNET_YES);
-          t = GNUNET_STRINGS_byte_size_fancy(
-            info->value.download.completed * 1000LL /
-            (info->value.download.duration.rel_value_us + 1));
-          fprintf(
-            stdout,
-            _(
-              "Downloading `%s' at %llu/%llu (%s remaining, %s/s). Block took %s to download\n"),
-            info->value.download.filename,
-            (unsigned long long)info->value.download.completed,
-            (unsigned long long)info->value.download.size,
-            s,
-            t,
-            s2);
-          GNUNET_free(s);
-          GNUNET_free(t);
-        }
+      s = GNUNET_strdup (
+        GNUNET_STRINGS_relative_time_to_string (info->value.download.eta,
+                                                GNUNET_YES));
+      if (info->value.download.specifics.progress.block_download_duration
+          .rel_value_us == GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
+        s2 = _ ("<unknown time>");
       else
-        {
-          display_bar(info->value.download.completed,
-                      info->value.download.size,
-                      60);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
-      if (0 != isatty(1))
-        fprintf(stdout, "\n");
-      fprintf(stderr,
-              _("Error downloading: %s.\n"),
-              info->value.download.specifics.error.message);
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      s = GNUNET_STRINGS_byte_size_fancy(
-        info->value.download.completed * 1000 /
-        (info->value.download.duration.rel_value_us + 1));
-      if (0 != isatty(1))
-        fprintf(stdout, "\n");
-      fprintf(stdout,
-              _("Downloading `%s' done (%s/s).\n"),
-              info->value.download.filename,
-              s);
-      GNUNET_free(s);
-      if (info->value.download.dc == dc)
-        GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
-      if (info->value.download.dc == dc)
-        GNUNET_SCHEDULER_add_now(&cleanup_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-    case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
-      break;
-
-    default:
-      fprintf(stderr, _("Unexpected status: %d\n"), info->status);
-      break;
+        s2 = GNUNET_STRINGS_relative_time_to_string (info->value.download
+                                                     .specifics.progress
+                                                     .block_download_duration,
+                                                     GNUNET_YES);
+      t = GNUNET_STRINGS_byte_size_fancy (
+        info->value.download.completed * 1000LL
+        / (info->value.download.duration.rel_value_us + 1));
+      fprintf (
+        stdout,
+        _ (
+          "Downloading `%s' at %llu/%llu (%s remaining, %s/s). Block took %s to download\n"),
+        info->value.download.filename,
+        (unsigned long long) info->value.download.completed,
+        (unsigned long long) info->value.download.size,
+        s,
+        t,
+        s2);
+      GNUNET_free (s);
+      GNUNET_free (t);
+    }
+    else
+    {
+      display_bar (info->value.download.completed,
+                   info->value.download.size,
+                   60);
     }
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+    if (0 != isatty (1))
+      fprintf (stdout, "\n");
+    fprintf (stderr,
+             _ ("Error downloading: %s.\n"),
+             info->value.download.specifics.error.message);
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    s = GNUNET_STRINGS_byte_size_fancy (
+      info->value.download.completed * 1000
+      / (info->value.download.duration.rel_value_us + 1));
+    if (0 != isatty (1))
+      fprintf (stdout, "\n");
+    fprintf (stdout,
+             _ ("Downloading `%s' done (%s/s).\n"),
+             info->value.download.filename,
+             s);
+    GNUNET_free (s);
+    if (info->value.download.dc == dc)
+      GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+    if (info->value.download.dc == dc)
+      GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+    break;
+
+  default:
+    fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
+    break;
+  }
   return NULL;
 }
 
@@ -219,84 +219,84 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
  * @param c configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct GNUNET_FS_Uri *uri;
   char *emsg;
   enum GNUNET_FS_DownloadOptions options;
 
   if (NULL == args[0])
-    {
-      fprintf(stderr, "%s", _("You need to specify a URI argument.\n"));
-      return;
-    }
-  uri = GNUNET_FS_uri_parse(args[0], &emsg);
+  {
+    fprintf (stderr, "%s", _ ("You need to specify a URI argument.\n"));
+    return;
+  }
+  uri = GNUNET_FS_uri_parse (args[0], &emsg);
   if (NULL == uri)
-    {
-      fprintf(stderr, _("Failed to parse URI: %s\n"), emsg);
-      GNUNET_free(emsg);
-      ret = 1;
-      return;
-    }
-  if ((!GNUNET_FS_uri_test_chk(uri)) && (!GNUNET_FS_uri_test_loc(uri)))
-    {
-      fprintf(stderr, "%s", _("Only CHK or LOC URIs supported.\n"));
-      ret = 1;
-      GNUNET_FS_uri_destroy(uri);
-      return;
-    }
+  {
+    fprintf (stderr, _ ("Failed to parse URI: %s\n"), emsg);
+    GNUNET_free (emsg);
+    ret = 1;
+    return;
+  }
+  if ((! GNUNET_FS_uri_test_chk (uri)) && (! GNUNET_FS_uri_test_loc (uri)))
+  {
+    fprintf (stderr, "%s", _ ("Only CHK or LOC URIs supported.\n"));
+    ret = 1;
+    GNUNET_FS_uri_destroy (uri);
+    return;
+  }
   if (NULL == filename)
-    {
-      fprintf(stderr, "%s", _("Target filename must be specified.\n"));
-      ret = 1;
-      GNUNET_FS_uri_destroy(uri);
-      return;
-    }
+  {
+    fprintf (stderr, "%s", _ ("Target filename must be specified.\n"));
+    ret = 1;
+    GNUNET_FS_uri_destroy (uri);
+    return;
+  }
   cfg = c;
-  ctx = GNUNET_FS_start(cfg,
-                        "gnunet-download",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM,
-                        parallelism,
-                        GNUNET_FS_OPTIONS_REQUEST_PARALLELISM,
-                        request_parallelism,
-                        GNUNET_FS_OPTIONS_END);
+  ctx = GNUNET_FS_start (cfg,
+                         "gnunet-download",
+                         &progress_cb,
+                         NULL,
+                         GNUNET_FS_FLAGS_NONE,
+                         GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM,
+                         parallelism,
+                         GNUNET_FS_OPTIONS_REQUEST_PARALLELISM,
+                         request_parallelism,
+                         GNUNET_FS_OPTIONS_END);
   if (NULL == ctx)
-    {
-      fprintf(stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
-      GNUNET_FS_uri_destroy(uri);
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
+    GNUNET_FS_uri_destroy (uri);
+    ret = 1;
+    return;
+  }
   options = GNUNET_FS_DOWNLOAD_OPTION_NONE;
   if (do_recursive)
     options |= GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE;
   if (local_only)
     options |= GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY;
-  dc = GNUNET_FS_download_start(ctx,
-                                uri,
-                                NULL,
-                                filename,
-                                NULL,
-                                0,
-                                GNUNET_FS_uri_chk_get_file_size(uri),
-                                anonymity,
-                                options,
-                                NULL,
-                                NULL);
-  GNUNET_FS_uri_destroy(uri);
+  dc = GNUNET_FS_download_start (ctx,
+                                 uri,
+                                 NULL,
+                                 filename,
+                                 NULL,
+                                 0,
+                                 GNUNET_FS_uri_chk_get_file_size (uri),
+                                 anonymity,
+                                 options,
+                                 NULL,
+                                 NULL);
+  GNUNET_FS_uri_destroy (uri);
   if (dc == NULL)
-    {
-      GNUNET_FS_stop(ctx);
-      ctx = NULL;
-      return;
-    }
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
+  {
+    GNUNET_FS_stop (ctx);
+    ctx = NULL;
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 }
 
 
@@ -308,75 +308,75 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] =
-  { GNUNET_GETOPT_option_uint('a',
-                              "anonymity",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired LEVEL of receiver-anonymity"),
-                              &anonymity),
-
-    GNUNET_GETOPT_option_flag(
+  { GNUNET_GETOPT_option_uint ('a',
+                               "anonymity",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired LEVEL of receiver-anonymity"),
+                               &anonymity),
+
+    GNUNET_GETOPT_option_flag (
       'D',
       "delete-incomplete",
-      gettext_noop("delete incomplete downloads (when aborted with CTRL-C)"),
+      gettext_noop ("delete incomplete downloads (when aborted with CTRL-C)"),
       &delete_incomplete),
 
-    GNUNET_GETOPT_option_flag(
+    GNUNET_GETOPT_option_flag (
       'n',
       "no-network",
-      gettext_noop("only search the local peer (no P2P network search)"),
+      gettext_noop ("only search the local peer (no P2P network search)"),
       &local_only),
-    GNUNET_GETOPT_option_string('o',
-                                "output",
-                                "FILENAME",
-                                gettext_noop("write the file to FILENAME"),
-                                &filename),
-    GNUNET_GETOPT_option_uint(
+    GNUNET_GETOPT_option_string ('o',
+                                 "output",
+                                 "FILENAME",
+                                 gettext_noop ("write the file to FILENAME"),
+                                 &filename),
+    GNUNET_GETOPT_option_uint (
       'p',
       "parallelism",
       "DOWNLOADS",
-      gettext_noop(
+      gettext_noop (
         "set the maximum number of parallel downloads that is allowed"),
       &parallelism),
-    GNUNET_GETOPT_option_uint(
+    GNUNET_GETOPT_option_uint (
       'r',
       "request-parallelism",
       "REQUESTS",
-      gettext_noop(
+      gettext_noop (
         "set the maximum number of parallel requests for blocks that is allowed"),
       &request_parallelism),
-    GNUNET_GETOPT_option_flag('R',
-                              "recursive",
-                              gettext_noop(
-                                "download a GNUnet directory recursively"),
-                              &do_recursive),
-    GNUNET_GETOPT_option_increment_uint(
+    GNUNET_GETOPT_option_flag ('R',
+                               "recursive",
+                               gettext_noop (
+                                 "download a GNUnet directory recursively"),
+                               &do_recursive),
+    GNUNET_GETOPT_option_increment_uint (
       'V',
       "verbose",
-      gettext_noop("be verbose (print progress information)"),
+      gettext_noop ("be verbose (print progress information)"),
       &verbose),
     GNUNET_GETOPT_OPTION_END };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run(
+     GNUNET_PROGRAM_run (
        argc,
        argv,
        "gnunet-download [OPTIONS] URI",
-       gettext_noop(
+       gettext_noop (
          "Download files from GNUnet using a GNUnet CHK or LOC URI (gnunet://fs/chk/...)"),
        options,
        &run,
        NULL))
     ? ret
     : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }
 
diff --git a/src/fs/gnunet-fs-profiler.c b/src/fs/gnunet-fs-profiler.c
index d47ca8b29..a6e248213 100644
--- a/src/fs/gnunet-fs-profiler.c
+++ b/src/fs/gnunet-fs-profiler.c
@@ -50,7 +50,7 @@ static struct GNUNET_TIME_Relative timeout;
 /**
  * Handle to the task run during termination.
  */
-static struct GNUNET_SCHEDULER_Task * terminate_taskid;
+static struct GNUNET_SCHEDULER_Task *terminate_taskid;
 
 
 /**
@@ -62,15 +62,15 @@ static struct GNUNET_SCHEDULER_Task * terminate_taskid;
  *          operation has executed successfully.
  */
 static void
-shutdown_task(void *cls,
-              struct GNUNET_TESTBED_Operation *op,
-              const char *emsg)
+shutdown_task (void *cls,
+               struct GNUNET_TESTBED_Operation *op,
+               const char *emsg)
 {
   if (NULL != emsg)
-    fprintf(stderr,
-            "Error collecting statistics: %s\n",
-            emsg);
-  GNUNET_SCHEDULER_shutdown();
+    fprintf (stderr,
+             "Error collecting statistics: %s\n",
+             emsg);
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -87,19 +87,19 @@ shutdown_task(void *cls,
  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
  */
 static int
-process_stats(void *cls,
-              const struct GNUNET_TESTBED_Peer *peer,
-              const char *subsystem,
-              const char *name,
-              uint64_t value,
-              int is_persistent)
+process_stats (void *cls,
+               const struct GNUNET_TESTBED_Peer *peer,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
 {
-  fprintf(stdout,
-          "%p-%s: %s = %llu\n",
-          peer,
-          subsystem,
-          name,
-          (unsigned long long)value);
+  fprintf (stdout,
+           "%p-%s: %s = %llu\n",
+           peer,
+           subsystem,
+           name,
+           (unsigned long long) value);
   return GNUNET_OK;
 }
 
@@ -111,18 +111,18 @@ process_stats(void *cls,
  * @param cls NULL
  */
 static void
-terminate_task(void *cls)
+terminate_task (void *cls)
 {
   if (NULL != terminate_taskid)
-    {
-      GNUNET_SCHEDULER_cancel(terminate_taskid);
-      terminate_taskid = NULL;
-    }
-  GNUNET_TESTBED_get_statistics(0, NULL,
-                                NULL, NULL,
-                                &process_stats,
-                                &shutdown_task,
-                                NULL);
+  {
+    GNUNET_SCHEDULER_cancel (terminate_taskid);
+    terminate_taskid = NULL;
+  }
+  GNUNET_TESTBED_get_statistics (0, NULL,
+                                 NULL, NULL,
+                                 &process_stats,
+                                 &shutdown_task,
+                                 NULL);
 }
 
 
@@ -133,10 +133,10 @@ terminate_task(void *cls)
  * @param cls NULL
  */
 static void
-timeout_task(void *cls)
+timeout_task (void *cls)
 {
   terminate_taskid = NULL;
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -153,23 +153,23 @@ timeout_task(void *cls)
  *          failed
  */
 static void
-test_master(void *cls,
-            struct GNUNET_TESTBED_RunHandle *h,
-            unsigned int num_peers,
-            struct GNUNET_TESTBED_Peer **peers,
-            unsigned int links_succeeded,
-            unsigned int links_failed)
+test_master (void *cls,
+             struct GNUNET_TESTBED_RunHandle *h,
+             unsigned int num_peers,
+             struct GNUNET_TESTBED_Peer **peers,
+             unsigned int links_succeeded,
+             unsigned int links_failed)
 {
   // const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
   // FIXME: enable clients to signal 'completion' before timeout;
   // in that case, run the 'terminate_task' "immediately"
 
   if (0 != timeout.rel_value_us)
-    terminate_taskid = GNUNET_SCHEDULER_add_delayed(timeout,
-                                                    &timeout_task,
-                                                    NULL);
-  GNUNET_SCHEDULER_add_shutdown(&terminate_task,
-                                NULL);
+    terminate_taskid = GNUNET_SCHEDULER_add_delayed (timeout,
+                                                     &timeout_task,
+                                                     NULL);
+  GNUNET_SCHEDULER_add_shutdown (&terminate_task,
+                                 NULL);
 }
 
 
@@ -182,14 +182,14 @@ test_master(void *cls,
  * @param cfg configuration
  */
 static void
-run(void *cls, char *const *args, const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  GNUNET_TESTBED_run(host_filename,
-                     cfg,
-                     num_peers,
-                     0, NULL, NULL,
-                     &test_master, (void *)cfg);
+  GNUNET_TESTBED_run (host_filename,
+                      cfg,
+                      num_peers,
+                      0, NULL, NULL,
+                      &test_master, (void *) cfg);
 }
 
 
@@ -201,38 +201,43 @@ run(void *cls, char *const *args, const char *cfgfile,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_uint('n',
-                              "num-peers",
-                              "COUNT",
-                              gettext_noop("run the experiment with COUNT peers"),
-                              &num_peers),
-
-    GNUNET_GETOPT_option_string('H',
-                                "hosts",
-                                "HOSTFILE",
-                                gettext_noop("specifies name of a file with the HOSTS the testbed should use"),
-                                &host_filename),
-
-    GNUNET_GETOPT_option_relative_time('t',
-                                       "timeout",
-                                       "DELAY",
-                                       gettext_noop("automatically terminate experiment after DELAY"),
-                                       &timeout),
+    GNUNET_GETOPT_option_uint ('n',
+                               "num-peers",
+                               "COUNT",
+                               gettext_noop (
+                                 "run the experiment with COUNT peers"),
+                               &num_peers),
+
+    GNUNET_GETOPT_option_string ('H',
+                                 "hosts",
+                                 "HOSTFILE",
+                                 gettext_noop (
+                                   "specifies name of a file with the HOSTS the testbed should use"),
+                                 &host_filename),
+
+    GNUNET_GETOPT_option_relative_time ('t',
+                                        "timeout",
+                                        "DELAY",
+                                        gettext_noop (
+                                          "automatically terminate experiment after DELAY"),
+                                        &timeout),
 
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
   ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run(argc, argv, "gnunet-fs-profiler",
-                            gettext_noop("run a testbed to measure file-sharing performance"), options, &run,
-                            NULL)) ? ret : 1;
-  GNUNET_free((void*)argv);
+         GNUNET_PROGRAM_run (argc, argv, "gnunet-fs-profiler",
+                             gettext_noop (
+                               "run a testbed to measure file-sharing performance"),
+                             options, &run,
+                             NULL)) ? ret : 1;
+  GNUNET_free ((void*) argv);
   return ret;
 }
 
diff --git a/src/fs/gnunet-fs.c b/src/fs/gnunet-fs.c
index 3fa65d6cb..a44fcdf7a 100644
--- a/src/fs/gnunet-fs.c
+++ b/src/fs/gnunet-fs.c
@@ -55,20 +55,20 @@ static unsigned int verbose;
  * @return GNUNET_OK to continue iteration
  */
 static int
-print_indexed(void *cls,
-              const char *filename,
-              const struct GNUNET_HashCode *file_id)
+print_indexed (void *cls,
+               const char *filename,
+               const struct GNUNET_HashCode *file_id)
 {
   if (NULL == filename)
-    {
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    return GNUNET_OK;
+  }
   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;
 }
 
@@ -82,32 +82,32 @@ print_indexed(void *cls,
  * @param cfg configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   if (list_indexed_files)
+  {
+    fs = GNUNET_FS_start (cfg,
+                          "gnunet-fs",
+                          NULL,
+                          NULL,
+                          GNUNET_FS_FLAGS_NONE,
+                          GNUNET_FS_OPTIONS_END);
+    if (NULL == fs)
     {
-      fs = GNUNET_FS_start(cfg,
-                           "gnunet-fs",
-                           NULL,
-                           NULL,
-                           GNUNET_FS_FLAGS_NONE,
-                           GNUNET_FS_OPTIONS_END);
-      if (NULL == fs)
-        {
-          ret = 1;
-          return;
-        }
-      if (NULL == GNUNET_FS_get_indexed_files(fs, &print_indexed, NULL))
-        {
-          ret = 2;
-          GNUNET_FS_stop(fs);
-          fs = NULL;
-          return;
-        }
+      ret = 1;
+      return;
+    }
+    if (NULL == GNUNET_FS_get_indexed_files (fs, &print_indexed, NULL))
+    {
+      ret = 2;
+      GNUNET_FS_stop (fs);
+      fs = NULL;
+      return;
     }
+  }
 }
 
 /**
@@ -118,32 +118,32 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_flag('i',
-                              "list-indexed",
-                              gettext_noop(
-                                "print a list of all indexed files"),
-                              &list_indexed_files),
+    GNUNET_GETOPT_option_flag ('i',
+                               "list-indexed",
+                               gettext_noop (
+                                 "print a list of all indexed files"),
+                               &list_indexed_files),
 
-    GNUNET_GETOPT_option_verbose(&verbose),
+    GNUNET_GETOPT_option_verbose (&verbose),
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
   ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run(argc,
-                            argv,
-                            "gnunet-fs [OPTIONS]",
-                            gettext_noop("Special file-sharing operations"),
-                            options,
-                            &run,
-                            NULL))
+         GNUNET_PROGRAM_run (argc,
+                             argv,
+                             "gnunet-fs [OPTIONS]",
+                             gettext_noop ("Special file-sharing operations"),
+                             options,
+                             &run,
+                             NULL))
         ? ret
         : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }
 
diff --git a/src/fs/gnunet-helper-fs-publish.c b/src/fs/gnunet-helper-fs-publish.c
index a6776d84f..fb5f7497d 100644
--- a/src/fs/gnunet-helper-fs-publish.c
+++ b/src/fs/gnunet-helper-fs-publish.c
@@ -33,7 +33,8 @@
 /**
  * A node of a directory tree.
  */
-struct ScanTreeNode {
+struct ScanTreeNode
+{
   /**
    * This is a doubly-linked list
    */
@@ -111,41 +112,41 @@ static int output_stream;
  * @return always 0 to continue extracting
  */
 static int
-add_to_md(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)
+add_to_md (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_MetaData *md = cls;
 
   if (((EXTRACTOR_METAFORMAT_UTF8 == format) ||
        (EXTRACTOR_METAFORMAT_C_STRING == format)) &&
       ('\0' != data[data_len - 1]))
-    {
-      char zdata[data_len + 1];
-      GNUNET_memcpy(zdata, data, data_len);
-      zdata[data_len] = '\0';
-      (void)GNUNET_CONTAINER_meta_data_insert(md,
+  {
+    char zdata[data_len + 1];
+    GNUNET_memcpy (zdata, data, data_len);
+    zdata[data_len] = '\0';
+    (void) GNUNET_CONTAINER_meta_data_insert (md,
                                               plugin_name,
                                               type,
                                               format,
                                               data_mime_type,
                                               zdata,
                                               data_len + 1);
-    }
+  }
   else
-    {
-      (void)GNUNET_CONTAINER_meta_data_insert(md,
+  {
+    (void) GNUNET_CONTAINER_meta_data_insert (md,
                                               plugin_name,
                                               type,
                                               format,
                                               data_mime_type,
                                               data,
                                               data_len);
-    }
+  }
   return 0;
 }
 #endif
@@ -157,18 +158,18 @@ add_to_md(void *cls,
  * @param tree tree to free
  */
 static void
-free_tree(struct ScanTreeNode *tree)
+free_tree (struct ScanTreeNode *tree)
 {
   struct ScanTreeNode *pos;
 
   while (NULL != (pos = tree->children_head))
-    free_tree(pos);
+    free_tree (pos);
   if (NULL != tree->parent)
-    GNUNET_CONTAINER_DLL_remove(tree->parent->children_head,
-                                tree->parent->children_tail,
-                                tree);
-  GNUNET_free(tree->filename);
-  GNUNET_free(tree);
+    GNUNET_CONTAINER_DLL_remove (tree->parent->children_head,
+                                 tree->parent->children_tail,
+                                 tree);
+  GNUNET_free (tree->filename);
+  GNUNET_free (tree);
 }
 
 
@@ -180,7 +181,7 @@ free_tree(struct ScanTreeNode *tree)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-write_all(const void *buf, size_t size)
+write_all (const void *buf, size_t size)
 {
   const char *cbuf = buf;
   size_t total;
@@ -188,16 +189,16 @@ write_all(const void *buf, size_t size)
 
   total = 0;
   do
-    {
-      wr = write(output_stream, &cbuf[total], size - total);
-      if (wr > 0)
-        total += wr;
-    }
+  {
+    wr = write (output_stream, &cbuf[total], size - total);
+    if (wr > 0)
+      total += wr;
+  }
   while ((wr > 0) && (total < size));
   if (wr <= 0)
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "Failed to write to stdout: %s\n",
-               strerror(errno));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to write to stdout: %s\n",
+                strerror (errno));
   return (total == size) ? GNUNET_OK : GNUNET_SYSERR;
 }
 
@@ -211,20 +212,20 @@ write_all(const void *buf, size_t size)
  * @return #GNUNET_SYSERR to stop scanning (the pipe was broken somehow)
  */
 static int
-write_message(uint16_t message_type, const char *data, size_t data_length)
+write_message (uint16_t message_type, const char *data, size_t data_length)
 {
   struct GNUNET_MessageHeader hdr;
 
 #if 0
-  fprintf(stderr,
-          "Helper sends %u-byte message of type %u\n",
-          (unsigned int)(sizeof(struct GNUNET_MessageHeader) + data_length),
-          (unsigned int)message_type);
+  fprintf (stderr,
+           "Helper sends %u-byte message of type %u\n",
+           (unsigned int) (sizeof(struct GNUNET_MessageHeader) + data_length),
+           (unsigned int) message_type);
 #endif
-  hdr.type = htons(message_type);
-  hdr.size = htons(sizeof(struct GNUNET_MessageHeader) + data_length);
-  if ((GNUNET_OK != write_all(&hdr, sizeof(hdr))) ||
-      (GNUNET_OK != write_all(data, data_length)))
+  hdr.type = htons (message_type);
+  hdr.size = htons (sizeof(struct GNUNET_MessageHeader) + data_length);
+  if ((GNUNET_OK != write_all (&hdr, sizeof(hdr))) ||
+      (GNUNET_OK != write_all (data, data_length)))
     return GNUNET_SYSERR;
   return GNUNET_OK;
 }
@@ -241,13 +242,14 @@ write_message(uint16_t message_type, const char *data, size_t data_length)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-preprocess_file(const char *filename, struct ScanTreeNode **dst);
+preprocess_file (const char *filename, struct ScanTreeNode **dst);
 
 
 /**
  * Closure for the 'scan_callback'
  */
-struct RecursionContext {
+struct RecursionContext
+{
   /**
    * Parent to add the files to.
    */
@@ -270,22 +272,22 @@ struct RecursionContext {
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-scan_callback(void *cls, const char *filename)
+scan_callback (void *cls, const char *filename)
 {
   struct RecursionContext *rc = cls;
   struct ScanTreeNode *chld;
 
-  if (GNUNET_OK != preprocess_file(filename, &chld))
-    {
-      rc->stop = GNUNET_YES;
-      return GNUNET_SYSERR;
-    }
+  if (GNUNET_OK != preprocess_file (filename, &chld))
+  {
+    rc->stop = GNUNET_YES;
+    return GNUNET_SYSERR;
+  }
   if (NULL == chld)
     return GNUNET_OK;
   chld->parent = rc->parent;
-  GNUNET_CONTAINER_DLL_insert(rc->parent->children_head,
-                              rc->parent->children_tail,
-                              chld);
+  GNUNET_CONTAINER_DLL_insert (rc->parent->children_head,
+                               rc->parent->children_tail,
+                               chld);
   return GNUNET_OK;
 }
 
@@ -301,60 +303,60 @@ scan_callback(void *cls, const char *filename)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  */
 static int
-preprocess_file(const char *filename, struct ScanTreeNode **dst)
+preprocess_file (const char *filename, struct ScanTreeNode **dst)
 {
   struct ScanTreeNode *item;
   struct stat sbuf;
   uint64_t fsize = 0;
 
-  if ((0 != stat(filename, &sbuf)) ||
-      ((!S_ISDIR(sbuf.st_mode)) &&
+  if ((0 != stat (filename, &sbuf)) ||
+      ((! S_ISDIR (sbuf.st_mode)) &&
        (GNUNET_OK !=
-        GNUNET_DISK_file_size(filename, &fsize, GNUNET_NO, GNUNET_YES))))
-    {
-      /* If the file doesn't exist (or is not stat-able for any other reason)
-         skip it (but report it), but do continue. */
-      if (GNUNET_OK !=
-          write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_SKIP_FILE,
-                        filename,
-                        strlen(filename) + 1))
-        return GNUNET_SYSERR;
-      /* recoverable error, store 'NULL' in *dst */
-      *dst = NULL;
-      return GNUNET_OK;
-    }
+        GNUNET_DISK_file_size (filename, &fsize, GNUNET_NO, GNUNET_YES))))
+  {
+    /* If the file doesn't exist (or is not stat-able for any other reason)
+       skip it (but report it), but do continue. */
+    if (GNUNET_OK !=
+        write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_SKIP_FILE,
+                       filename,
+                       strlen (filename) + 1))
+      return GNUNET_SYSERR;
+    /* recoverable error, store 'NULL' in *dst */
+    *dst = NULL;
+    return GNUNET_OK;
+  }
 
   /* Report the progress */
   if (
     GNUNET_OK !=
-    write_message(S_ISDIR(sbuf.st_mode)
-                  ? GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_DIRECTORY
-                  : GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_FILE,
-                  filename,
-                  strlen(filename) + 1))
+    write_message (S_ISDIR (sbuf.st_mode)
+                   ? GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_DIRECTORY
+                   : GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_FILE,
+                   filename,
+                   strlen (filename) + 1))
     return GNUNET_SYSERR;
-  item = GNUNET_new(struct ScanTreeNode);
-  item->filename = GNUNET_strdup(filename);
-  item->is_directory = (S_ISDIR(sbuf.st_mode)) ? GNUNET_YES : GNUNET_NO;
+  item = GNUNET_new (struct ScanTreeNode);
+  item->filename = GNUNET_strdup (filename);
+  item->is_directory = (S_ISDIR (sbuf.st_mode)) ? GNUNET_YES : GNUNET_NO;
   item->file_size = fsize;
   if (GNUNET_YES == item->is_directory)
+  {
+    struct RecursionContext rc;
+
+    rc.parent = item;
+    rc.stop = GNUNET_NO;
+    GNUNET_DISK_directory_scan (filename, &scan_callback, &rc);
+    if (
+      (GNUNET_YES == rc.stop) ||
+      (GNUNET_OK !=
+       write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_DIRECTORY,
+                      "..",
+                      3)))
     {
-      struct RecursionContext rc;
-
-      rc.parent = item;
-      rc.stop = GNUNET_NO;
-      GNUNET_DISK_directory_scan(filename, &scan_callback, &rc);
-      if (
-        (GNUNET_YES == rc.stop) ||
-        (GNUNET_OK !=
-         write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_PROGRESS_DIRECTORY,
-                       "..",
-                       3)))
-        {
-          free_tree(item);
-          return GNUNET_SYSERR;
-        }
+      free_tree (item);
+      return GNUNET_SYSERR;
     }
+  }
   *dst = item;
   return GNUNET_OK;
 }
@@ -367,67 +369,67 @@ preprocess_file(const char *filename, struct ScanTreeNode **dst)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR on fatal errors
  */
 static int
-extract_files(struct ScanTreeNode *item)
+extract_files (struct ScanTreeNode *item)
 {
   struct GNUNET_CONTAINER_MetaData *meta;
   ssize_t size;
   size_t slen;
 
   if (GNUNET_YES == item->is_directory)
-    {
-      /* for directories, we simply only descent, no extraction, no
-         progress reporting */
-      struct ScanTreeNode *pos;
-
-      for (pos = item->children_head; NULL != pos; pos = pos->next)
-        if (GNUNET_OK != extract_files(pos))
-          return GNUNET_SYSERR;
-      return GNUNET_OK;
-    }
+  {
+    /* for directories, we simply only descent, no extraction, no
+       progress reporting */
+    struct ScanTreeNode *pos;
+
+    for (pos = item->children_head; NULL != pos; pos = pos->next)
+      if (GNUNET_OK != extract_files (pos))
+        return GNUNET_SYSERR;
+    return GNUNET_OK;
+  }
 
   /* this is the expensive operation, *afterwards* we'll check for aborts */
-  meta = GNUNET_CONTAINER_meta_data_create();
+  meta = GNUNET_CONTAINER_meta_data_create ();
 #if HAVE_LIBEXTRACTOR
-  EXTRACTOR_extract(plugins, item->filename, NULL, 0, &add_to_md, meta);
+  EXTRACTOR_extract (plugins, item->filename, NULL, 0, &add_to_md, meta);
 #endif
-  slen = strlen(item->filename) + 1;
-  size = GNUNET_CONTAINER_meta_data_get_serialized_size(meta);
+  slen = strlen (item->filename) + 1;
+  size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
   if (-1 == size)
-    {
-      /* no meta data */
-      GNUNET_CONTAINER_meta_data_destroy(meta);
-      if (GNUNET_OK !=
-          write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA,
-                        item->filename,
-                        slen))
-        return GNUNET_SYSERR;
-      return GNUNET_OK;
-    }
+  {
+    /* no meta data */
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    if (GNUNET_OK !=
+        write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA,
+                       item->filename,
+                       slen))
+      return GNUNET_SYSERR;
+    return GNUNET_OK;
+  }
   else if (size > (UINT16_MAX - sizeof(struct GNUNET_MessageHeader) - slen))
-    {
-      /* We can't transfer more than 64k bytes in one message. */
-      size = UINT16_MAX - sizeof(struct GNUNET_MessageHeader) - slen;
-    }
+  {
+    /* We can't transfer more than 64k bytes in one message. */
+    size = UINT16_MAX - sizeof(struct GNUNET_MessageHeader) - slen;
+  }
   {
     char buf[size + slen];
     char *dst = &buf[slen];
 
-    GNUNET_memcpy(buf, item->filename, slen);
-    size = GNUNET_CONTAINER_meta_data_serialize(
+    GNUNET_memcpy (buf, item->filename, slen);
+    size = GNUNET_CONTAINER_meta_data_serialize (
       meta,
       &dst,
       size,
       GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
     if (size < 0)
-      {
-        GNUNET_break(0);
-        size = 0;
-      }
-    GNUNET_CONTAINER_meta_data_destroy(meta);
+    {
+      GNUNET_break (0);
+      size = 0;
+    }
+    GNUNET_CONTAINER_meta_data_destroy (meta);
     if (GNUNET_OK !=
-        write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA,
-                      buf,
-                      slen + size))
+        write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_META_DATA,
+                       buf,
+                       slen + size))
       return GNUNET_SYSERR;
   }
   return GNUNET_OK;
@@ -438,23 +440,23 @@ extract_files(struct ScanTreeNode *item)
  * Install a signal handler to ignore SIGPIPE.
  */
 static void
-ignore_sigpipe()
+ignore_sigpipe ()
 {
   struct sigaction oldsig;
   struct sigaction sig;
 
-  memset(&sig, 0, sizeof(struct sigaction));
+  memset (&sig, 0, sizeof(struct sigaction));
   sig.sa_handler = SIG_IGN;
-  sigemptyset(&sig.sa_mask);
+  sigemptyset (&sig.sa_mask);
 #ifdef SA_INTERRUPT
   sig.sa_flags = SA_INTERRUPT; /* SunOS */
 #else
   sig.sa_flags = SA_RESTART;
 #endif
-  if (0 != sigaction(SIGPIPE, &sig, &oldsig))
-    fprintf(stderr,
-            "Failed to install SIGPIPE handler: %s\n",
-            strerror(errno));
+  if (0 != sigaction (SIGPIPE, &sig, &oldsig))
+    fprintf (stderr,
+             "Failed to install SIGPIPE handler: %s\n",
+             strerror (errno));
 }
 
 
@@ -465,17 +467,17 @@ ignore_sigpipe()
  * @param flags flags to use (O_RDONLY or O_WRONLY)
  */
 static void
-make_dev_zero(int fd, int flags)
+make_dev_zero (int fd, int flags)
 {
   int z;
 
-  GNUNET_assert(0 == close(fd));
-  z = open("/dev/null", flags);
-  GNUNET_assert(-1 != z);
+  GNUNET_assert (0 == close (fd));
+  z = open ("/dev/null", flags);
+  GNUNET_assert (-1 != z);
   if (z == fd)
     return;
-  GNUNET_break(fd == dup2(z, fd));
-  GNUNET_assert(0 == close(z));
+  GNUNET_break (fd == dup2 (z, fd));
+  GNUNET_assert (0 == close (z));
 }
 
 
@@ -490,82 +492,82 @@ make_dev_zero(int fd, int flags)
  * @return 0 on success
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   const char *filename_expanded;
   const char *ex;
   struct ScanTreeNode *root;
 
-  ignore_sigpipe();
+  ignore_sigpipe ();
   /* move stdout to some other FD for IPC, bind
      stdout/stderr to /dev/null */
-  output_stream = dup(1);
-  make_dev_zero(1, O_WRONLY);
-  make_dev_zero(2, O_WRONLY);
+  output_stream = dup (1);
+  make_dev_zero (1, O_WRONLY);
+  make_dev_zero (2, O_WRONLY);
 
   /* parse command line */
   if ((3 != argc) && (2 != argc))
-    {
-      fprintf(stderr,
-              "%s",
-              "gnunet-helper-fs-publish needs exactly one or two arguments\n");
-      return 1;
-    }
+  {
+    fprintf (stderr,
+             "%s",
+             "gnunet-helper-fs-publish needs exactly one or two arguments\n");
+    return 1;
+  }
   filename_expanded = argv[1];
   ex = argv[2];
-  if ((NULL == ex) || (0 != strcmp(ex, "-")))
-    {
+  if ((NULL == ex) || (0 != strcmp (ex, "-")))
+  {
 #if HAVE_LIBEXTRACTOR
-      plugins = EXTRACTOR_plugin_add_defaults(EXTRACTOR_OPTION_DEFAULT_POLICY);
-      if (NULL != ex)
-        plugins = EXTRACTOR_plugin_add_config(plugins,
-                                              ex,
-                                              EXTRACTOR_OPTION_DEFAULT_POLICY);
+    plugins = EXTRACTOR_plugin_add_defaults (EXTRACTOR_OPTION_DEFAULT_POLICY);
+    if (NULL != ex)
+      plugins = EXTRACTOR_plugin_add_config (plugins,
+                                             ex,
+                                             EXTRACTOR_OPTION_DEFAULT_POLICY);
 #endif
-    }
+  }
 
   /* scan tree to find out how much work there is to be done */
-  if (GNUNET_OK != preprocess_file(filename_expanded, &root))
-    {
-      (void)write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_ERROR, NULL, 0);
+  if (GNUNET_OK != preprocess_file (filename_expanded, &root))
+  {
+    (void) write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_ERROR, NULL, 0);
 #if HAVE_LIBEXTRACTOR
-      EXTRACTOR_plugin_remove_all(plugins);
+    EXTRACTOR_plugin_remove_all (plugins);
 #endif
-      return 2;
-    }
+    return 2;
+  }
   /* signal that we're done counting files, so that a percentage of
      progress can now be calculated */
   if (GNUNET_OK !=
-      write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_COUNTING_DONE,
-                    NULL,
-                    0))
-    {
+      write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_COUNTING_DONE,
+                     NULL,
+                     0))
+  {
 #if HAVE_LIBEXTRACTOR
-      EXTRACTOR_plugin_remove_all(plugins);
+    EXTRACTOR_plugin_remove_all (plugins);
 #endif
-      return 3;
-    }
+    return 3;
+  }
   if (NULL != root)
+  {
+    if (GNUNET_OK != extract_files (root))
     {
-      if (GNUNET_OK != extract_files(root))
-        {
-          (void)write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_ERROR,
-                              NULL,
-                              0);
-          free_tree(root);
+      (void) write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_ERROR,
+                            NULL,
+                            0);
+      free_tree (root);
 #if HAVE_LIBEXTRACTOR
-          EXTRACTOR_plugin_remove_all(plugins);
+      EXTRACTOR_plugin_remove_all (plugins);
 #endif
-          return 4;
-        }
-      free_tree(root);
+      return 4;
     }
+    free_tree (root);
+  }
   /* enable "clean" shutdown by telling parent that we are done */
-  (void)write_message(GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_FINISHED,
-                      NULL,
-                      0);
+  (void) write_message (GNUNET_MESSAGE_TYPE_FS_PUBLISH_HELPER_FINISHED,
+                        NULL,
+                        0);
 #if HAVE_LIBEXTRACTOR
-  EXTRACTOR_plugin_remove_all(plugins);
+  EXTRACTOR_plugin_remove_all (plugins);
 #endif
   return 0;
 }
diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index 24baa4d38..ff56dac8c 100644
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -148,41 +148,41 @@ static struct GNUNET_IDENTITY_Handle *identity;
  * @param cls NULL
  */
 static void
-do_stop_task(void *cls)
+do_stop_task (void *cls)
 {
   struct GNUNET_FS_PublishContext *p;
 
   if (NULL != ds)
-    {
-      GNUNET_FS_directory_scan_abort(ds);
-      ds = NULL;
-    }
+  {
+    GNUNET_FS_directory_scan_abort (ds);
+    ds = NULL;
+  }
   if (NULL != identity)
-    {
-      GNUNET_IDENTITY_disconnect(identity);
-      identity = NULL;
-    }
+  {
+    GNUNET_IDENTITY_disconnect (identity);
+    identity = NULL;
+  }
   if (NULL != pc)
-    {
-      p = pc;
-      pc = NULL;
-      GNUNET_FS_publish_stop(p);
-    }
+  {
+    p = pc;
+    pc = NULL;
+    GNUNET_FS_publish_stop (p);
+  }
   if (NULL != ctx)
-    {
-      GNUNET_FS_stop(ctx);
-      ctx = NULL;
-    }
+  {
+    GNUNET_FS_stop (ctx);
+    ctx = NULL;
+  }
   if (NULL != meta)
-    {
-      GNUNET_CONTAINER_meta_data_destroy(meta);
-      meta = NULL;
-    }
+  {
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    meta = NULL;
+  }
   if (NULL != uri)
-    {
-      GNUNET_FS_uri_destroy(uri);
-      uri = NULL;
-    }
+  {
+    GNUNET_FS_uri_destroy (uri);
+    uri = NULL;
+  }
 }
 
 
@@ -200,105 +200,105 @@ do_stop_task(void *cls)
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   const char *s;
   char *suri;
 
   switch (info->status)
+  {
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    if (verbose)
     {
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      if (verbose)
-        {
-          s = GNUNET_STRINGS_relative_time_to_string(info->value.publish.eta,
-                                                     GNUNET_YES);
-          fprintf(stdout,
-                  _("Publishing `%s' at %llu/%llu (%s remaining)\n"),
-                  info->value.publish.filename,
-                  (unsigned long long)info->value.publish.completed,
-                  (unsigned long long)info->value.publish.size,
-                  s);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      if (verbose)
-        {
-          s = GNUNET_STRINGS_relative_time_to_string(info->value.publish.specifics
-                                                     .progress_directory.eta,
-                                                     GNUNET_YES);
-          fprintf(stdout,
-                  _("Publishing `%s' at %llu/%llu (%s remaining)\n"),
-                  info->value.publish.filename,
-                  (unsigned long long)
-                  info->value.publish.specifics.progress_directory.completed,
-                  (unsigned long long)
-                  info->value.publish.specifics.progress_directory.total,
-                  s);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr,
-              _("Error publishing: %s.\n"),
-              info->value.publish.specifics.error.message);
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      fprintf(stdout,
-              _("Publishing `%s' done.\n"),
-              info->value.publish.filename);
-      suri =
-        GNUNET_FS_uri_to_string(info->value.publish.specifics.completed.chk_uri);
-      fprintf(stdout, _("URI is `%s'.\n"), suri);
-      GNUNET_free(suri);
-      if (NULL != info->value.publish.specifics.completed.sks_uri)
-        {
-          suri = GNUNET_FS_uri_to_string(
-            info->value.publish.specifics.completed.sks_uri);
-          fprintf(stdout, _("Namespace URI is `%s'.\n"), suri);
-          GNUNET_free(suri);
-        }
-      if (NULL == info->value.publish.pctx)
-        {
-          ret = 0;
-          GNUNET_SCHEDULER_shutdown();
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_break(NULL == pc);
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_START:
-      fprintf(stderr, "%s", _("Starting cleanup after abort\n"));
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
-      fprintf(stderr, "%s", _("Cleanup after abort completed.\n"));
-      GNUNET_FS_unindex_stop(info->value.unindex.uc);
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_ERROR:
-      fprintf(stderr, "%s", _("Cleanup after abort failed.\n"));
-      GNUNET_FS_unindex_stop(info->value.unindex.uc);
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_STOPPED:
-      return NULL;
-
-    default:
-      fprintf(stderr, _("Unexpected status: %d\n"), info->status);
-      return NULL;
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.eta,
+                                                  GNUNET_YES);
+      fprintf (stdout,
+               _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
+               info->value.publish.filename,
+               (unsigned long long) info->value.publish.completed,
+               (unsigned long long) info->value.publish.size,
+               s);
     }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    if (verbose)
+    {
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.specifics
+                                                  .progress_directory.eta,
+                                                  GNUNET_YES);
+      fprintf (stdout,
+               _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
+               info->value.publish.filename,
+               (unsigned long long)
+               info->value.publish.specifics.progress_directory.completed,
+               (unsigned long long)
+               info->value.publish.specifics.progress_directory.total,
+               s);
+    }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr,
+             _ ("Error publishing: %s.\n"),
+             info->value.publish.specifics.error.message);
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    fprintf (stdout,
+             _ ("Publishing `%s' done.\n"),
+             info->value.publish.filename);
+    suri =
+      GNUNET_FS_uri_to_string (info->value.publish.specifics.completed.chk_uri);
+    fprintf (stdout, _ ("URI is `%s'.\n"), suri);
+    GNUNET_free (suri);
+    if (NULL != info->value.publish.specifics.completed.sks_uri)
+    {
+      suri = GNUNET_FS_uri_to_string (
+        info->value.publish.specifics.completed.sks_uri);
+      fprintf (stdout, _ ("Namespace URI is `%s'.\n"), suri);
+      GNUNET_free (suri);
+    }
+    if (NULL == info->value.publish.pctx)
+    {
+      ret = 0;
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_break (NULL == pc);
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_START:
+    fprintf (stderr, "%s", _ ("Starting cleanup after abort\n"));
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
+    fprintf (stderr, "%s", _ ("Cleanup after abort completed.\n"));
+    GNUNET_FS_unindex_stop (info->value.unindex.uc);
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_ERROR:
+    fprintf (stderr, "%s", _ ("Cleanup after abort failed.\n"));
+    GNUNET_FS_unindex_stop (info->value.unindex.uc);
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_STOPPED:
+    return NULL;
+
+  default:
+    fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
+    return NULL;
+  }
   return ""; /* non-null */
 }
 
@@ -317,13 +317,13 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
  * @return always 0
  */
 static int
-meta_printer(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_size)
+meta_printer (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_size)
 {
   if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
       (EXTRACTOR_METAFORMAT_C_STRING != format))
@@ -331,9 +331,9 @@ meta_printer(void *cls,
   if (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type)
     return 0;
 #if HAVE_LIBEXTRACTOR
-  fprintf(stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string(type), data);
+  fprintf (stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string (type), data);
 #else
-  fprintf(stdout, "\t%d - %s\n", type, data);
+  fprintf (stdout, "\t%d - %s\n", type, data);
 #endif
   return 0;
 }
@@ -348,9 +348,9 @@ meta_printer(void *cls,
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to abort
  */
 static int
-keyword_printer(void *cls, const char *keyword, int is_mandatory)
+keyword_printer (void *cls, const char *keyword, int is_mandatory)
 {
-  fprintf(stdout, "\t%s\n", keyword);
+  fprintf (stdout, "\t%s\n", keyword);
   return GNUNET_OK;
 }
 
@@ -373,14 +373,14 @@ keyword_printer(void *cls, const char *keyword, int is_mandatory)
  *         to abort the iteration
  */
 static int
-publish_inspector(void *cls,
-                  struct GNUNET_FS_FileInformation *fi,
-                  uint64_t length,
-                  struct GNUNET_CONTAINER_MetaData *m,
-                  struct GNUNET_FS_Uri **uri,
-                  struct GNUNET_FS_BlockOptions *bo,
-                  int *do_index,
-                  void **client_info)
+publish_inspector (void *cls,
+                   struct GNUNET_FS_FileInformation *fi,
+                   uint64_t length,
+                   struct GNUNET_CONTAINER_MetaData *m,
+                   struct GNUNET_FS_Uri **uri,
+                   struct GNUNET_FS_BlockOptions *bo,
+                   int *do_index,
+                   void **client_info)
 {
   char *fn;
   char *fs;
@@ -389,50 +389,50 @@ publish_inspector(void *cls,
   if (cls == fi)
     return GNUNET_OK;
   if ((disable_extractor) && (NULL != *uri))
-    {
-      GNUNET_FS_uri_destroy(*uri);
-      *uri = NULL;
-    }
+  {
+    GNUNET_FS_uri_destroy (*uri);
+    *uri = NULL;
+  }
   if (NULL != topKeywords)
+  {
+    if (NULL != *uri)
     {
-      if (NULL != *uri)
-        {
-          new_uri = GNUNET_FS_uri_ksk_merge(topKeywords, *uri);
-          GNUNET_FS_uri_destroy(*uri);
-          *uri = new_uri;
-          GNUNET_FS_uri_destroy(topKeywords);
-        }
-      else
-        {
-          *uri = topKeywords;
-        }
-      topKeywords = NULL;
+      new_uri = GNUNET_FS_uri_ksk_merge (topKeywords, *uri);
+      GNUNET_FS_uri_destroy (*uri);
+      *uri = new_uri;
+      GNUNET_FS_uri_destroy (topKeywords);
     }
-  if (NULL != meta)
+    else
     {
-      GNUNET_CONTAINER_meta_data_merge(m, meta);
-      GNUNET_CONTAINER_meta_data_destroy(meta);
-      meta = NULL;
+      *uri = topKeywords;
     }
+    topKeywords = NULL;
+  }
+  if (NULL != meta)
+  {
+    GNUNET_CONTAINER_meta_data_merge (m, meta);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    meta = NULL;
+  }
   if (enable_creation_time)
-    GNUNET_CONTAINER_meta_data_add_publication_date(m);
+    GNUNET_CONTAINER_meta_data_add_publication_date (m);
   if (extract_only)
-    {
-      fn = GNUNET_CONTAINER_meta_data_get_by_type(
-        m,
-        EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
-      fs = GNUNET_STRINGS_byte_size_fancy(length);
-      fprintf(stdout, _("Meta data for file `%s' (%s)\n"), fn, fs);
-      GNUNET_CONTAINER_meta_data_iterate(m, &meta_printer, NULL);
-      fprintf(stdout, _("Keywords for file `%s' (%s)\n"), fn, fs);
-      GNUNET_free(fn);
-      GNUNET_free(fs);
-      if (NULL != *uri)
-        GNUNET_FS_uri_ksk_get_keywords(*uri, &keyword_printer, NULL);
-      fprintf(stdout, "%s", "\n");
-    }
-  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(m))
-    GNUNET_FS_file_information_inspect(fi, &publish_inspector, fi);
+  {
+    fn = GNUNET_CONTAINER_meta_data_get_by_type (
+      m,
+      EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+    fs = GNUNET_STRINGS_byte_size_fancy (length);
+    fprintf (stdout, _ ("Meta data for file `%s' (%s)\n"), fn, fs);
+    GNUNET_CONTAINER_meta_data_iterate (m, &meta_printer, NULL);
+    fprintf (stdout, _ ("Keywords for file `%s' (%s)\n"), fn, fs);
+    GNUNET_free (fn);
+    GNUNET_free (fs);
+    if (NULL != *uri)
+      GNUNET_FS_uri_ksk_get_keywords (*uri, &keyword_printer, NULL);
+    fprintf (stdout, "%s", "\n");
+  }
+  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (m))
+    GNUNET_FS_file_information_inspect (fi, &publish_inspector, fi);
   return GNUNET_OK;
 }
 
@@ -447,16 +447,16 @@ publish_inspector(void *cls,
  * @param emsg error message, NULL on success
  */
 static void
-uri_sks_continuation(void *cls,
-                     const struct GNUNET_FS_Uri *sks_uri,
-                     const char *emsg)
+uri_sks_continuation (void *cls,
+                      const struct GNUNET_FS_Uri *sks_uri,
+                      const char *emsg)
 {
   if (NULL != emsg)
-    {
-      fprintf(stderr, "%s\n", emsg);
-      ret = 1;
-    }
-  GNUNET_SCHEDULER_shutdown();
+  {
+    fprintf (stderr, "%s\n", emsg);
+    ret = 1;
+  }
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -470,33 +470,33 @@ uri_sks_continuation(void *cls,
  * @param emsg error message, NULL on success
  */
 static void
-uri_ksk_continuation(void *cls,
-                     const struct GNUNET_FS_Uri *ksk_uri,
-                     const char *emsg)
+uri_ksk_continuation (void *cls,
+                      const struct GNUNET_FS_Uri *ksk_uri,
+                      const char *emsg)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
 
   if (NULL != emsg)
-    {
-      fprintf(stderr, "%s\n", emsg);
-      ret = 1;
-    }
+  {
+    fprintf (stderr, "%s\n", emsg);
+    ret = 1;
+  }
   if (NULL == namespace)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  priv = GNUNET_IDENTITY_ego_get_private_key(namespace);
-  GNUNET_FS_publish_sks(ctx,
-                        priv,
-                        this_id,
-                        next_id,
-                        meta,
-                        uri,
-                        &bo,
-                        GNUNET_FS_PUBLISH_OPTION_NONE,
-                        &uri_sks_continuation,
-                        NULL);
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
+  GNUNET_FS_publish_sks (ctx,
+                         priv,
+                         this_id,
+                         next_id,
+                         meta,
+                         uri,
+                         &bo,
+                         GNUNET_FS_PUBLISH_OPTION_NONE,
+                         &uri_sks_continuation,
+                         NULL);
 }
 
 
@@ -508,52 +508,52 @@ uri_ksk_continuation(void *cls,
  * @return handle with the information for the publishing operation
  */
 static struct GNUNET_FS_FileInformation *
-get_file_information(struct GNUNET_FS_ShareTreeItem *item)
+get_file_information (struct GNUNET_FS_ShareTreeItem *item)
 {
   struct GNUNET_FS_FileInformation *fi;
   struct GNUNET_FS_FileInformation *fic;
   struct GNUNET_FS_ShareTreeItem *child;
 
   if (GNUNET_YES == item->is_directory)
+  {
+    if (NULL == item->meta)
+      item->meta = GNUNET_CONTAINER_meta_data_create ();
+    GNUNET_CONTAINER_meta_data_delete (item->meta,
+                                       EXTRACTOR_METATYPE_MIMETYPE,
+                                       NULL,
+                                       0);
+    GNUNET_FS_meta_data_make_directory (item->meta);
+    if (NULL == item->ksk_uri)
     {
-      if (NULL == item->meta)
-        item->meta = GNUNET_CONTAINER_meta_data_create();
-      GNUNET_CONTAINER_meta_data_delete(item->meta,
-                                        EXTRACTOR_METATYPE_MIMETYPE,
-                                        NULL,
-                                        0);
-      GNUNET_FS_meta_data_make_directory(item->meta);
-      if (NULL == item->ksk_uri)
-        {
-          const char *mime = GNUNET_FS_DIRECTORY_MIME;
-          item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args(1, &mime);
-        }
-      else
-        GNUNET_FS_uri_ksk_add_keyword(item->ksk_uri,
-                                      GNUNET_FS_DIRECTORY_MIME,
-                                      GNUNET_NO);
-      fi = GNUNET_FS_file_information_create_empty_directory(ctx,
-                                                             NULL,
-                                                             item->ksk_uri,
-                                                             item->meta,
-                                                             &bo,
-                                                             item->filename);
-      for (child = item->children_head; child; child = child->next)
-        {
-          fic = get_file_information(child);
-          GNUNET_break(GNUNET_OK == GNUNET_FS_file_information_add(fi, fic));
-        }
+      const char *mime = GNUNET_FS_DIRECTORY_MIME;
+      item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &mime);
     }
-  else
+    else
+      GNUNET_FS_uri_ksk_add_keyword (item->ksk_uri,
+                                     GNUNET_FS_DIRECTORY_MIME,
+                                     GNUNET_NO);
+    fi = GNUNET_FS_file_information_create_empty_directory (ctx,
+                                                            NULL,
+                                                            item->ksk_uri,
+                                                            item->meta,
+                                                            &bo,
+                                                            item->filename);
+    for (child = item->children_head; child; child = child->next)
     {
-      fi = GNUNET_FS_file_information_create_from_file(ctx,
-                                                       NULL,
-                                                       item->filename,
-                                                       item->ksk_uri,
-                                                       item->meta,
-                                                       !do_insert,
-                                                       &bo);
+      fic = get_file_information (child);
+      GNUNET_break (GNUNET_OK == GNUNET_FS_file_information_add (fi, fic));
     }
+  }
+  else
+  {
+    fi = GNUNET_FS_file_information_create_from_file (ctx,
+                                                      NULL,
+                                                      item->filename,
+                                                      item->ksk_uri,
+                                                      item->meta,
+                                                      ! do_insert,
+                                                      &bo);
+  }
   return fi;
 }
 
@@ -565,46 +565,46 @@ get_file_information(struct GNUNET_FS_ShareTreeItem *item)
  * @param directory_scan_result result from the directory scan, freed in this function
  */
 static void
-directory_trim_complete(struct GNUNET_FS_ShareTreeItem *directory_scan_result)
+directory_trim_complete (struct GNUNET_FS_ShareTreeItem *directory_scan_result)
 {
   struct GNUNET_FS_FileInformation *fi;
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
 
-  fi = get_file_information(directory_scan_result);
-  GNUNET_FS_share_tree_free(directory_scan_result);
+  fi = get_file_information (directory_scan_result);
+  GNUNET_FS_share_tree_free (directory_scan_result);
   if (NULL == fi)
-    {
-      fprintf(stderr, "%s", _("Could not publish\n"));
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GNUNET_FS_file_information_inspect(fi, &publish_inspector, NULL);
+  {
+    fprintf (stderr, "%s", _ ("Could not publish\n"));
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_FS_file_information_inspect (fi, &publish_inspector, NULL);
   if (extract_only)
-    {
-      GNUNET_FS_file_information_destroy(fi, NULL, NULL);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_FS_file_information_destroy (fi, NULL, NULL);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (NULL == namespace)
     priv = NULL;
   else
-    priv = GNUNET_IDENTITY_ego_get_private_key(namespace);
-  pc = GNUNET_FS_publish_start(ctx,
-                               fi,
-                               priv,
-                               this_id,
-                               next_id,
-                               (do_simulate)
-                               ? GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
-                               : GNUNET_FS_PUBLISH_OPTION_NONE);
+    priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
+  pc = GNUNET_FS_publish_start (ctx,
+                                fi,
+                                priv,
+                                this_id,
+                                next_id,
+                                (do_simulate)
+                                ? GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
+                                : GNUNET_FS_PUBLISH_OPTION_NONE);
   if (NULL == pc)
-    {
-      fprintf(stderr, "%s", _("Could not start publishing.\n"));
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    fprintf (stderr, "%s", _ ("Could not start publishing.\n"));
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 }
 
 
@@ -620,63 +620,63 @@ directory_trim_complete(struct GNUNET_FS_ShareTreeItem *directory_scan_result)
  * @param reason kind of progress we are making
  */
 static void
-directory_scan_cb(void *cls,
-                  const char *filename,
-                  int is_directory,
-                  enum GNUNET_FS_DirScannerProgressUpdateReason reason)
+directory_scan_cb (void *cls,
+                   const char *filename,
+                   int is_directory,
+                   enum GNUNET_FS_DirScannerProgressUpdateReason reason)
 {
   struct GNUNET_FS_ShareTreeItem *directory_scan_result;
 
   switch (reason)
+  {
+  case GNUNET_FS_DIRSCANNER_FILE_START:
+    if (verbose > 1)
     {
-    case GNUNET_FS_DIRSCANNER_FILE_START:
-      if (verbose > 1)
-        {
-          if (is_directory == GNUNET_YES)
-            fprintf(stdout, _("Scanning directory `%s'.\n"), filename);
-          else
-            fprintf(stdout, _("Scanning file `%s'.\n"), filename);
-        }
-      break;
-
-    case GNUNET_FS_DIRSCANNER_FILE_IGNORED:
-      fprintf(stderr,
-              _("There was trouble processing file `%s', skipping it.\n"),
-              filename);
-      break;
-
-    case GNUNET_FS_DIRSCANNER_ALL_COUNTED:
-      if (verbose)
-        fprintf(stdout, "%s", _("Preprocessing complete.\n"));
-      break;
-
-    case GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED:
-      if (verbose > 2)
-        fprintf(stdout,
-                _("Extracting meta data from file `%s' complete.\n"),
-                filename);
-      break;
-
-    case GNUNET_FS_DIRSCANNER_FINISHED:
-      if (verbose > 1)
-        fprintf(stdout, "%s", _("Meta data extraction has finished.\n"));
-      directory_scan_result = GNUNET_FS_directory_scan_get_result(ds);
-      ds = NULL;
-      GNUNET_FS_share_tree_trim(directory_scan_result);
-      directory_trim_complete(directory_scan_result);
-      break;
-
-    case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
-      fprintf(stdout, "%s", _("Error scanning directory.\n"));
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    default:
-      GNUNET_assert(0);
-      break;
+      if (is_directory == GNUNET_YES)
+        fprintf (stdout, _ ("Scanning directory `%s'.\n"), filename);
+      else
+        fprintf (stdout, _ ("Scanning file `%s'.\n"), filename);
     }
-  fflush(stdout);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_FILE_IGNORED:
+    fprintf (stderr,
+             _ ("There was trouble processing file `%s', skipping it.\n"),
+             filename);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_ALL_COUNTED:
+    if (verbose)
+      fprintf (stdout, "%s", _ ("Preprocessing complete.\n"));
+    break;
+
+  case GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED:
+    if (verbose > 2)
+      fprintf (stdout,
+               _ ("Extracting meta data from file `%s' complete.\n"),
+               filename);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_FINISHED:
+    if (verbose > 1)
+      fprintf (stdout, "%s", _ ("Meta data extraction has finished.\n"));
+    directory_scan_result = GNUNET_FS_directory_scan_get_result (ds);
+    ds = NULL;
+    GNUNET_FS_share_tree_trim (directory_scan_result);
+    directory_trim_complete (directory_scan_result);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
+    fprintf (stdout, "%s", _ ("Error scanning directory.\n"));
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+  fflush (stdout);
 }
 
 
@@ -687,67 +687,67 @@ directory_scan_cb(void *cls,
  * @param args0 filename to publish
  */
 static void
-identity_continuation(const char *args0)
+identity_continuation (const char *args0)
 {
   char *ex;
   char *emsg;
 
   if ((NULL != pseudonym) && (NULL == namespace))
-    {
-      fprintf(stderr, _("Selected pseudonym `%s' unknown\n"), pseudonym);
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    fprintf (stderr, _ ("Selected pseudonym `%s' unknown\n"), pseudonym);
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (NULL != uri_string)
+  {
+    emsg = NULL;
+    if (NULL == (uri = GNUNET_FS_uri_parse (uri_string, &emsg)))
     {
-      emsg = NULL;
-      if (NULL == (uri = GNUNET_FS_uri_parse(uri_string, &emsg)))
-        {
-          fprintf(stderr, _("Failed to parse URI: %s\n"), emsg);
-          GNUNET_free(emsg);
-          ret = 1;
-          GNUNET_SCHEDULER_shutdown();
-          return;
-        }
-      GNUNET_FS_publish_ksk(ctx,
-                            topKeywords,
-                            meta,
-                            uri,
-                            &bo,
-                            GNUNET_FS_PUBLISH_OPTION_NONE,
-                            &uri_ksk_continuation,
-                            NULL);
+      fprintf (stderr, _ ("Failed to parse URI: %s\n"), emsg);
+      GNUNET_free (emsg);
+      ret = 1;
+      GNUNET_SCHEDULER_shutdown ();
       return;
     }
+    GNUNET_FS_publish_ksk (ctx,
+                           topKeywords,
+                           meta,
+                           uri,
+                           &bo,
+                           GNUNET_FS_PUBLISH_OPTION_NONE,
+                           &uri_ksk_continuation,
+                           NULL);
+    return;
+  }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(cfg, "FS", "EXTRACTORS", &ex))
+      GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
     ex = NULL;
-  if (0 != access(args0, R_OK))
-    {
-      fprintf(stderr,
-              _("Failed to access `%s': %s\n"),
-              args0,
-              strerror(errno));
-      GNUNET_free_non_null(ex);
-      return;
-    }
-  ds = GNUNET_FS_directory_scan_start(args0,
-                                      disable_extractor,
-                                      ex,
-                                      &directory_scan_cb,
-                                      NULL);
+  if (0 != access (args0, R_OK))
+  {
+    fprintf (stderr,
+             _ ("Failed to access `%s': %s\n"),
+             args0,
+             strerror (errno));
+    GNUNET_free_non_null (ex);
+    return;
+  }
+  ds = GNUNET_FS_directory_scan_start (args0,
+                                       disable_extractor,
+                                       ex,
+                                       &directory_scan_cb,
+                                       NULL);
   if (NULL == ds)
-    {
-      fprintf(
-        stderr,
-        "%s",
-        _(
-          "Failed to start meta directory scanner.  Is gnunet-helper-publish-fs installed?\n"));
-      GNUNET_free_non_null(ex);
-      return;
-    }
-  GNUNET_free_non_null(ex);
+  {
+    fprintf (
+      stderr,
+      "%s",
+      _ (
+        "Failed to start meta directory scanner.  Is gnunet-helper-publish-fs installed?\n"));
+    GNUNET_free_non_null (ex);
+    return;
+  }
+  GNUNET_free_non_null (ex);
 }
 
 
@@ -763,21 +763,21 @@ identity_continuation(const char *args0)
  *                   must thus no longer be used
  */
 static void
-identity_cb(void *cls,
-            struct GNUNET_IDENTITY_Ego *ego,
-            void **ctx,
-            const char *name)
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
 {
   const char *args0 = cls;
 
   if (NULL == ego)
-    {
-      identity_continuation(args0);
-      return;
-    }
+  {
+    identity_continuation (args0);
+    return;
+  }
   if (NULL == name)
     return;
-  if (0 == strcmp(name, pseudonym))
+  if (0 == strcmp (name, pseudonym))
     namespace = ego;
 }
 
@@ -791,82 +791,82 @@ identity_cb(void *cls,
  * @param c configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
   /* check arguments */
   if ((NULL != uri_string) && (extract_only))
-    {
-      printf(_("Cannot extract metadata from a URI!\n"));
-      ret = -1;
-      return;
-    }
+  {
+    printf (_ ("Cannot extract metadata from a URI!\n"));
+    ret = -1;
+    return;
+  }
   if (((NULL == uri_string) || (extract_only)) &&
       ((NULL == args[0]) || (NULL != args[1])))
+  {
+    printf (_ ("You must specify one and only one filename for insertion.\n"));
+    ret = -1;
+    return;
+  }
+  if ((NULL != uri_string) && (NULL != args[0]))
+  {
+    printf (_ ("You must NOT specify an URI and a filename.\n"));
+    ret = -1;
+    return;
+  }
+  if (NULL != pseudonym)
+  {
+    if (NULL == this_id)
     {
-      printf(_("You must specify one and only one filename for insertion.\n"));
+      fprintf (stderr,
+               _ ("Option `%s' is required when using option `%s'.\n"),
+               "-t",
+               "-P");
       ret = -1;
       return;
     }
-  if ((NULL != uri_string) && (NULL != args[0]))
+  }
+  else
+  {   /* ordinary insertion checks */
+    if (NULL != next_id)
     {
-      printf(_("You must NOT specify an URI and a filename.\n"));
+      fprintf (stderr,
+               _ ("Option `%s' makes no sense without option `%s'.\n"),
+               "-N",
+               "-P");
       ret = -1;
       return;
     }
-  if (NULL != pseudonym)
+    if (NULL != this_id)
     {
-      if (NULL == this_id)
-        {
-          fprintf(stderr,
-                  _("Option `%s' is required when using option `%s'.\n"),
-                  "-t",
-                  "-P");
-          ret = -1;
-          return;
-        }
-    }
-  else
-    { /* ordinary insertion checks */
-      if (NULL != next_id)
-        {
-          fprintf(stderr,
-                  _("Option `%s' makes no sense without option `%s'.\n"),
-                  "-N",
-                  "-P");
-          ret = -1;
-          return;
-        }
-      if (NULL != this_id)
-        {
-          fprintf(stderr,
-                  _("Option `%s' makes no sense without option `%s'.\n"),
-                  "-t",
-                  "-P");
-          ret = -1;
-          return;
-        }
+      fprintf (stderr,
+               _ ("Option `%s' makes no sense without option `%s'.\n"),
+               "-t",
+               "-P");
+      ret = -1;
+      return;
     }
+  }
   cfg = c;
-  ctx = GNUNET_FS_start(cfg,
-                        "gnunet-publish",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
+  ctx = GNUNET_FS_start (cfg,
+                         "gnunet-publish",
+                         &progress_cb,
+                         NULL,
+                         GNUNET_FS_FLAGS_NONE,
+                         GNUNET_FS_OPTIONS_END);
   if (NULL == ctx)
-    {
-      fprintf(stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
-      ret = 1;
-      return;
-    }
-  GNUNET_SCHEDULER_add_shutdown(&do_stop_task, NULL);
+  {
+    fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
+    ret = 1;
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
   if (NULL != pseudonym)
-    identity = GNUNET_IDENTITY_connect(cfg, &identity_cb, args[0]);
+    identity = GNUNET_IDENTITY_connect (cfg, &identity_cb, args[0]);
   else
-    identity_continuation(args[0]);
+    identity_continuation (args[0]);
 }
 
 
@@ -878,121 +878,121 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] =
-  { GNUNET_GETOPT_option_uint('a',
-                              "anonymity",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired LEVEL of sender-anonymity"),
-                              &bo.anonymity_level),
-    GNUNET_GETOPT_option_flag(
+  { GNUNET_GETOPT_option_uint ('a',
+                               "anonymity",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired LEVEL of sender-anonymity"),
+                               &bo.anonymity_level),
+    GNUNET_GETOPT_option_flag (
       'D',
       "disable-extractor",
-      gettext_noop("do not use libextractor to add keywords or metadata"),
+      gettext_noop ("do not use libextractor to add keywords or metadata"),
       &disable_extractor),
-    GNUNET_GETOPT_option_flag('E',
-                              "enable-creation-time",
-                              gettext_noop(
-                                "enable adding the creation time to the "
-                                "metadata of the uploaded file"),
-                              &enable_creation_time),
-    GNUNET_GETOPT_option_flag('e',
-                              "extract",
-                              gettext_noop(
-                                "print list of extracted keywords that would "
-                                "be used, but do not perform upload"),
-                              &extract_only),
-    GNUNET_FS_GETOPT_KEYWORDS(
+    GNUNET_GETOPT_option_flag ('E',
+                               "enable-creation-time",
+                               gettext_noop (
+                                 "enable adding the creation time to the "
+                                 "metadata of the uploaded file"),
+                               &enable_creation_time),
+    GNUNET_GETOPT_option_flag ('e',
+                               "extract",
+                               gettext_noop (
+                                 "print list of extracted keywords that would "
+                                 "be used, but do not perform upload"),
+                               &extract_only),
+    GNUNET_FS_GETOPT_KEYWORDS (
       'k',
       "key",
       "KEYWORD",
-      gettext_noop(
+      gettext_noop (
         "add an additional keyword for the top-level "
         "file or directory (this option can be specified multiple times)"),
       &topKeywords),
-    GNUNET_FS_GETOPT_METADATA(
+    GNUNET_FS_GETOPT_METADATA (
       'm',
       "meta",
       "TYPE:VALUE",
-      gettext_noop("set the meta-data for the given TYPE to the given VALUE"),
+      gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
       &meta),
-    GNUNET_GETOPT_option_flag(
+    GNUNET_GETOPT_option_flag (
       'n',
       "noindex",
-      gettext_noop("do not index, perform full insertion (stores "
-                   "entire file in encrypted form in GNUnet database)"),
+      gettext_noop ("do not index, perform full insertion (stores "
+                    "entire file in encrypted form in GNUnet database)"),
       &do_insert),
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string (
       'N',
       "next",
       "ID",
-      gettext_noop("specify ID of an updated version to be "
-                   "published in the future (for namespace insertions only)"),
+      gettext_noop ("specify ID of an updated version to be "
+                    "published in the future (for namespace insertions only)"),
       &next_id),
-    GNUNET_GETOPT_option_uint('p',
-                              "priority",
-                              "PRIORITY",
-                              gettext_noop(
-                                "specify the priority of the content"),
-                              &bo.content_priority),
-    GNUNET_GETOPT_option_string('P',
-                                "pseudonym",
-                                "NAME",
-                                gettext_noop(
-                                  "publish the files under the pseudonym "
-                                  "NAME (place file into namespace)"),
-                                &pseudonym),
-    GNUNET_GETOPT_option_uint('r',
-                              "replication",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired replication LEVEL"),
-                              &bo.replication_level),
-    GNUNET_GETOPT_option_flag('s',
-                              "simulate-only",
-                              gettext_noop(
-                                "only simulate the process but do not do "
-                                "any actual publishing (useful to compute URIs)"),
-                              &do_simulate),
-    GNUNET_GETOPT_option_string('t',
-                                "this",
-                                "ID",
-                                gettext_noop(
-                                  "set the ID of this version of the publication "
-                                  "(for namespace insertions only)"),
-                                &this_id),
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_uint ('p',
+                               "priority",
+                               "PRIORITY",
+                               gettext_noop (
+                                 "specify the priority of the content"),
+                               &bo.content_priority),
+    GNUNET_GETOPT_option_string ('P',
+                                 "pseudonym",
+                                 "NAME",
+                                 gettext_noop (
+                                   "publish the files under the pseudonym "
+                                   "NAME (place file into namespace)"),
+                                 &pseudonym),
+    GNUNET_GETOPT_option_uint ('r',
+                               "replication",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired replication LEVEL"),
+                               &bo.replication_level),
+    GNUNET_GETOPT_option_flag ('s',
+                               "simulate-only",
+                               gettext_noop (
+                                 "only simulate the process but do not do "
+                                 "any actual publishing (useful to compute URIs)"),
+                               &do_simulate),
+    GNUNET_GETOPT_option_string ('t',
+                                 "this",
+                                 "ID",
+                                 gettext_noop (
+                                   "set the ID of this version of the publication "
+                                   "(for namespace insertions only)"),
+                                 &this_id),
+    GNUNET_GETOPT_option_string (
       'u',
       "uri",
       "URI",
-      gettext_noop(
+      gettext_noop (
         "URI to be published (can be used instead of passing a "
         "file to add keywords to the file with the respective URI)"),
       &uri_string),
 
-    GNUNET_GETOPT_option_verbose(&verbose),
+    GNUNET_GETOPT_option_verbose (&verbose),
 
     GNUNET_GETOPT_OPTION_END };
 
   bo.expiration_time =
-    GNUNET_TIME_year_to_time(GNUNET_TIME_get_current_year() + 2);
+    GNUNET_TIME_year_to_time (GNUNET_TIME_get_current_year () + 2);
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run(argc,
-                        argv,
-                        "gnunet-publish [OPTIONS] FILENAME",
-                        gettext_noop("Publish a file or directory on GNUnet"),
-                        options,
-                        &run,
-                        NULL))
+     GNUNET_PROGRAM_run (argc,
+                         argv,
+                         "gnunet-publish [OPTIONS] FILENAME",
+                         gettext_noop ("Publish a file or directory on GNUnet"),
+                         options,
+                         &run,
+                         NULL))
     ? ret
     : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }
 
diff --git a/src/fs/gnunet-search.c b/src/fs/gnunet-search.c
index ac31387e2..f11335985 100644
--- a/src/fs/gnunet-search.c
+++ b/src/fs/gnunet-search.c
@@ -76,13 +76,13 @@ static struct GNUNET_SCHEDULER_Task *tt;
  * @return 0 to continue extracting, 1 to abort
  */
 static int
-item_printer(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_size)
+item_printer (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_size)
 {
   if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
       (format != EXTRACTOR_METAFORMAT_C_STRING))
@@ -90,45 +90,45 @@ item_printer(void *cls,
   if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
     return 0;
 #if HAVE_LIBEXTRACTOR
-  printf("\t%20s: %s\n",
-         dgettext(LIBEXTRACTOR_GETTEXT_DOMAIN,
-                  EXTRACTOR_metatype_to_string(type)),
-         data);
+  printf ("\t%20s: %s\n",
+          dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN,
+                    EXTRACTOR_metatype_to_string (type)),
+          data);
 #else
-  printf("\t%20d: %s\n", type, data);
+  printf ("\t%20d: %s\n", type, data);
 #endif
   return 0;
 }
 
 
 static void
-clean_task(void *cls)
+clean_task (void *cls)
 {
   size_t dsize;
   void *ddata;
 
-  GNUNET_FS_stop(ctx);
+  GNUNET_FS_stop (ctx);
   ctx = NULL;
   if (output_filename == NULL)
     return;
-  if (GNUNET_OK != GNUNET_FS_directory_builder_finish(db, &dsize, &ddata))
-    {
-      GNUNET_break(0);
-      GNUNET_free(output_filename);
-      return;
-    }
-  if (dsize != GNUNET_DISK_fn_write(output_filename,
-                                    ddata,
-                                    dsize,
-                                    GNUNET_DISK_PERM_USER_READ |
-                                    GNUNET_DISK_PERM_USER_WRITE))
-    {
-      fprintf(stderr,
-              _("Failed to write directory with search results to `%s'\n"),
-              output_filename);
-    }
-  GNUNET_free_non_null(ddata);
-  GNUNET_free(output_filename);
+  if (GNUNET_OK != GNUNET_FS_directory_builder_finish (db, &dsize, &ddata))
+  {
+    GNUNET_break (0);
+    GNUNET_free (output_filename);
+    return;
+  }
+  if (dsize != GNUNET_DISK_fn_write (output_filename,
+                                     ddata,
+                                     dsize,
+                                     GNUNET_DISK_PERM_USER_READ
+                                     | GNUNET_DISK_PERM_USER_WRITE))
+  {
+    fprintf (stderr,
+             _ ("Failed to write directory with search results to `%s'\n"),
+             output_filename);
+  }
+  GNUNET_free_non_null (ddata);
+  GNUNET_free (output_filename);
 }
 
 
@@ -146,7 +146,7 @@ clean_task(void *cls)
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   static unsigned int cnt;
   int is_directory;
@@ -154,98 +154,98 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
   char *filename;
 
   switch (info->status)
+  {
+  case GNUNET_FS_STATUS_SEARCH_START:
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    if (db != NULL)
+      GNUNET_FS_directory_builder_add (db,
+                                       info->value.search.specifics.result.uri,
+                                       info->value.search.specifics.result.meta,
+                                       NULL);
+    uri = GNUNET_FS_uri_to_string (info->value.search.specifics.result.uri);
+    printf ("#%u:\n", ++cnt);
+    filename = GNUNET_CONTAINER_meta_data_get_by_type (
+      info->value.search.specifics.result.meta,
+      EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+    is_directory = GNUNET_FS_meta_data_test_for_directory (
+      info->value.search.specifics.result.meta);
+    if (NULL != filename)
     {
-    case GNUNET_FS_STATUS_SEARCH_START:
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT:
-      if (db != NULL)
-        GNUNET_FS_directory_builder_add(db,
-                                        info->value.search.specifics.result.uri,
-                                        info->value.search.specifics.result.meta,
-                                        NULL);
-      uri = GNUNET_FS_uri_to_string(info->value.search.specifics.result.uri);
-      printf("#%u:\n", ++cnt);
-      filename = GNUNET_CONTAINER_meta_data_get_by_type(
-        info->value.search.specifics.result.meta,
-        EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
-      is_directory = GNUNET_FS_meta_data_test_for_directory(
-        info->value.search.specifics.result.meta);
-      if (NULL != filename)
-        {
-          while ((filename[0] != '\0') && ('/' == filename[strlen(filename) - 1]))
-            filename[strlen(filename) - 1] = '\0';
-          GNUNET_DISK_filename_canonicalize(filename);
-          if (GNUNET_YES == is_directory)
-            printf("gnunet-download -o \"%s%s\" -R %s\n",
-                   filename,
-                   GNUNET_FS_DIRECTORY_EXT,
-                   uri);
-          else
-            printf("gnunet-download -o \"%s\" %s\n", filename, uri);
-        }
-      else if (GNUNET_YES == is_directory)
-        printf("gnunet-download -o \"collection%s\" -R %s\n",
-               GNUNET_FS_DIRECTORY_EXT,
-               uri);
+      while ((filename[0] != '\0') && ('/' == filename[strlen (filename) - 1]))
+        filename[strlen (filename) - 1] = '\0';
+      GNUNET_DISK_filename_canonicalize (filename);
+      if (GNUNET_YES == is_directory)
+        printf ("gnunet-download -o \"%s%s\" -R %s\n",
+                filename,
+                GNUNET_FS_DIRECTORY_EXT,
+                uri);
       else
-        printf("gnunet-download %s\n", uri);
-      if (verbose)
-        GNUNET_CONTAINER_meta_data_iterate(info->value.search.specifics.result
-                                           .meta,
-                                           &item_printer,
-                                           NULL);
-      printf("\n");
-      fflush(stdout);
-      GNUNET_free_non_null(filename);
-      GNUNET_free(uri);
-      results++;
-      if ((results_limit > 0) && (results >= results_limit))
-        GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_UPDATE:
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
-      /* ignore */
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf(stderr,
-              _("Error searching: %s.\n"),
-              info->value.search.specifics.error.message);
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_STOPPED:
-      GNUNET_SCHEDULER_add_now(&clean_task, NULL);
-      break;
-
-    default:
-      fprintf(stderr, _("Unexpected status: %d\n"), info->status);
-      break;
+        printf ("gnunet-download -o \"%s\" %s\n", filename, uri);
     }
+    else if (GNUNET_YES == is_directory)
+      printf ("gnunet-download -o \"collection%s\" -R %s\n",
+              GNUNET_FS_DIRECTORY_EXT,
+              uri);
+    else
+      printf ("gnunet-download %s\n", uri);
+    if (verbose)
+      GNUNET_CONTAINER_meta_data_iterate (info->value.search.specifics.result
+                                          .meta,
+                                          &item_printer,
+                                          NULL);
+    printf ("\n");
+    fflush (stdout);
+    GNUNET_free_non_null (filename);
+    GNUNET_free (uri);
+    results++;
+    if ((results_limit > 0) && (results >= results_limit))
+      GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_UPDATE:
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+    /* ignore */
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr,
+             _ ("Error searching: %s.\n"),
+             info->value.search.specifics.error.message);
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    GNUNET_SCHEDULER_add_now (&clean_task, NULL);
+    break;
+
+  default:
+    fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   if (sc != NULL)
-    {
-      GNUNET_FS_search_stop(sc);
-      sc = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (sc);
+    sc = NULL;
+  }
 }
 
 
 static void
-timeout_task(void *cls)
+timeout_task (void *cls)
 {
   tt = NULL;
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -258,10 +258,10 @@ timeout_task(void *cls)
  * @param c configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct GNUNET_FS_Uri *uri;
   unsigned int argc;
@@ -270,46 +270,46 @@ run(void *cls,
   argc = 0;
   while (NULL != args[argc])
     argc++;
-  uri = GNUNET_FS_uri_ksk_create_from_args(argc, (const char **)args);
+  uri = GNUNET_FS_uri_ksk_create_from_args (argc, (const char **) args);
   if (NULL == uri)
-    {
-      fprintf(stderr,
-              "%s",
-              _("Could not create keyword URI from arguments.\n"));
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr,
+             "%s",
+             _ ("Could not create keyword URI from arguments.\n"));
+    ret = 1;
+    return;
+  }
   cfg = c;
-  ctx = GNUNET_FS_start(cfg,
-                        "gnunet-search",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
+  ctx = GNUNET_FS_start (cfg,
+                         "gnunet-search",
+                         &progress_cb,
+                         NULL,
+                         GNUNET_FS_FLAGS_NONE,
+                         GNUNET_FS_OPTIONS_END);
   if (NULL == ctx)
-    {
-      fprintf(stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
-      GNUNET_FS_uri_destroy(uri);
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
+    GNUNET_FS_uri_destroy (uri);
+    ret = 1;
+    return;
+  }
   if (output_filename != NULL)
-    db = GNUNET_FS_directory_builder_create(NULL);
+    db = GNUNET_FS_directory_builder_create (NULL);
   options = GNUNET_FS_SEARCH_OPTION_NONE;
   if (local_only)
     options |= GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY;
-  sc = GNUNET_FS_search_start(ctx, uri, anonymity, options, NULL);
-  GNUNET_FS_uri_destroy(uri);
+  sc = GNUNET_FS_search_start (ctx, uri, anonymity, options, NULL);
+  GNUNET_FS_uri_destroy (uri);
   if (NULL == sc)
-    {
-      fprintf(stderr, "%s", _("Could not start searching.\n"));
-      GNUNET_FS_stop(ctx);
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, "%s", _ ("Could not start searching.\n"));
+    GNUNET_FS_stop (ctx);
+    ret = 1;
+    return;
+  }
   if (0 != timeout.rel_value_us)
-    tt = GNUNET_SCHEDULER_add_delayed(timeout, &timeout_task, NULL);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
+    tt = GNUNET_SCHEDULER_add_delayed (timeout, &timeout_task, NULL);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 }
 
 
@@ -321,57 +321,57 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] =
-  { GNUNET_GETOPT_option_uint('a',
-                              "anonymity",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired LEVEL of receiver-anonymity"),
-                              &anonymity),
-    GNUNET_GETOPT_option_flag(
+  { GNUNET_GETOPT_option_uint ('a',
+                               "anonymity",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired LEVEL of receiver-anonymity"),
+                               &anonymity),
+    GNUNET_GETOPT_option_flag (
       'n',
       "no-network",
-      gettext_noop("only search the local peer (no P2P network search)"),
+      gettext_noop ("only search the local peer (no P2P network search)"),
       &local_only),
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string (
       'o',
       "output",
       "PREFIX",
-      gettext_noop("write search results to file starting with PREFIX"),
+      gettext_noop ("write search results to file starting with PREFIX"),
       &output_filename),
-    GNUNET_GETOPT_option_relative_time(
+    GNUNET_GETOPT_option_relative_time (
       't',
       "timeout",
       "DELAY",
-      gettext_noop("automatically terminate search after DELAY"),
+      gettext_noop ("automatically terminate search after DELAY"),
       &timeout),
-    GNUNET_GETOPT_option_verbose(&verbose),
-    GNUNET_GETOPT_option_uint('N',
-                              "results",
-                              "VALUE",
-                              gettext_noop("automatically terminate search "
-                                           "after VALUE results are found"),
-                              &results_limit),
+    GNUNET_GETOPT_option_verbose (&verbose),
+    GNUNET_GETOPT_option_uint ('N',
+                               "results",
+                               "VALUE",
+                               gettext_noop ("automatically terminate search "
+                                             "after VALUE results are found"),
+                               &results_limit),
     GNUNET_GETOPT_OPTION_END };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run(argc,
-                        argv,
-                        "gnunet-search [OPTIONS] KEYWORD",
-                        gettext_noop(
-                          "Search GNUnet for files that were published on GNUnet"),
-                        options,
-                        &run,
-                        NULL))
+     GNUNET_PROGRAM_run (argc,
+                         argv,
+                         "gnunet-search [OPTIONS] KEYWORD",
+                         gettext_noop (
+                           "Search GNUnet for files that were published on GNUnet"),
+                         options,
+                         &run,
+                         NULL))
     ? ret
     : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }
 
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index 70aff8a75..40b3f6c1d 100644
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -59,7 +59,8 @@
  * time interval, remaining cover traffic counters are
  * decremented by 1/16th.
  */
-#define COVER_AGE_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
+#define COVER_AGE_FREQUENCY GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 5)
 
 /**
  * Collect an instane number of statistics?  May cause excessive IPC.
@@ -72,7 +73,8 @@
  * Doubly-linked list of requests we are performing
  * on behalf of the same client.
  */
-struct ClientRequest {
+struct ClientRequest
+{
   /**
    * This is a doubly-linked list.
    */
@@ -96,7 +98,7 @@ struct ClientRequest {
   /**
    * Task scheduled to destroy the request.
    */
-  struct GNUNET_SCHEDULER_Task * kill_task;
+  struct GNUNET_SCHEDULER_Task *kill_task;
 };
 
 
@@ -104,7 +106,8 @@ struct ClientRequest {
  * Replies to be transmitted to the client.  The actual
  * response message is allocated after this struct.
  */
-struct ClientResponse {
+struct ClientResponse
+{
   /**
    * This is a doubly-linked list.
    */
@@ -131,7 +134,8 @@ struct ClientResponse {
  * Information we track while handling an index
  * start request from a client.
  */
-struct IndexStartContext {
+struct IndexStartContext
+{
   /**
    * This is a doubly linked list.
    */
@@ -167,7 +171,8 @@ struct IndexStartContext {
 /**
  * A local client.
  */
-struct GSF_LocalClient {
+struct GSF_LocalClient
+{
   /**
    * ID of the client.
    */
@@ -316,7 +321,7 @@ static struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
 /**
  * ID of our task that we use to age the cover counters.
  */
-static struct GNUNET_SCHEDULER_Task * cover_age_task;
+static struct GNUNET_SCHEDULER_Task *cover_age_task;
 
 /**
  * Datastore 'GET' load tracking.
@@ -333,13 +338,13 @@ static struct GNUNET_LOAD_Value *datastore_get_load;
  * @return handle to local client entry
  */
 static void *
-client_connect_cb(void *cls,
-                  struct GNUNET_SERVICE_Client *client,
-                  struct GNUNET_MQ_Handle *mq)
+client_connect_cb (void *cls,
+                   struct GNUNET_SERVICE_Client *client,
+                   struct GNUNET_MQ_Handle *mq)
 {
   struct GSF_LocalClient *pos;
 
-  pos = GNUNET_new(struct GSF_LocalClient);
+  pos = GNUNET_new (struct GSF_LocalClient);
   pos->client = client;
   pos->mq = mq;
   return pos;
@@ -352,22 +357,22 @@ client_connect_cb(void *cls,
  * @param cls the client request to free
  */
 static void
-client_request_destroy(void *cls)
+client_request_destroy (void *cls)
 {
   struct ClientRequest *cr = cls;
   struct GSF_LocalClient *lc = cr->lc;
 
   cr->kill_task = NULL;
-  GNUNET_CONTAINER_DLL_remove(lc->cr_head,
-                              lc->cr_tail,
-                              cr);
-  GSF_pending_request_cancel_(cr->pr,
-                              GNUNET_YES);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# client searches active"),
-                           -1,
-                           GNUNET_NO);
-  GNUNET_free(cr);
+  GNUNET_CONTAINER_DLL_remove (lc->cr_head,
+                               lc->cr_tail,
+                               cr);
+  GSF_pending_request_cancel_ (cr->pr,
+                               GNUNET_YES);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# client searches active"),
+                            -1,
+                            GNUNET_NO);
+  GNUNET_free (cr);
 }
 
 
@@ -390,15 +395,15 @@ client_request_destroy(void *cls)
  * @param data_len number of bytes in @a data
  */
 static void
-client_response_handler(void *cls,
-                        enum GNUNET_BLOCK_EvaluationResult eval,
-                        struct GSF_PendingRequest *pr,
-                        uint32_t reply_anonymity_level,
-                        struct GNUNET_TIME_Absolute expiration,
-                        struct GNUNET_TIME_Absolute last_transmission,
-                        enum GNUNET_BLOCK_Type type,
-                        const void *data,
-                        size_t data_len)
+client_response_handler (void *cls,
+                         enum GNUNET_BLOCK_EvaluationResult eval,
+                         struct GSF_PendingRequest *pr,
+                         uint32_t reply_anonymity_level,
+                         struct GNUNET_TIME_Absolute expiration,
+                         struct GNUNET_TIME_Absolute last_transmission,
+                         enum GNUNET_BLOCK_Type type,
+                         const void *data,
+                         size_t data_len)
 {
   struct ClientRequest *cr = cls;
   struct GSF_LocalClient *lc;
@@ -407,52 +412,52 @@ client_response_handler(void *cls,
   const struct GSF_PendingRequestData *prd;
 
   if (NULL == data)
-    {
-      /* local-only request, with no result, clean up. */
-      if (NULL == cr->kill_task)
-        cr->kill_task = GNUNET_SCHEDULER_add_now(&client_request_destroy,
-                                                 cr);
-      return;
-    }
-  prd = GSF_pending_request_get_data_(pr);
-  GNUNET_break(type != GNUNET_BLOCK_TYPE_ANY);
+  {
+    /* local-only request, with no result, clean up. */
+    if (NULL == cr->kill_task)
+      cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
+                                                cr);
+    return;
+  }
+  prd = GSF_pending_request_get_data_ (pr);
+  GNUNET_break (type != GNUNET_BLOCK_TYPE_ANY);
   if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop
-                             ("# replies received for local clients"), 1,
-                           GNUNET_NO);
-  GNUNET_assert(pr == cr->pr);
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop
+                              ("# replies received for local clients"), 1,
+                            GNUNET_NO);
+  GNUNET_assert (pr == cr->pr);
   lc = cr->lc;
-  env = GNUNET_MQ_msg_extra(pm,
-                            data_len,
-                            GNUNET_MESSAGE_TYPE_FS_PUT);
-  pm->type = htonl(type);
-  pm->expiration = GNUNET_TIME_absolute_hton(expiration);
-  pm->last_transmission = GNUNET_TIME_absolute_hton(last_transmission);
-  pm->num_transmissions = htonl(prd->num_transmissions);
-  pm->respect_offered = htonl(prd->respect_offered);
-  GNUNET_memcpy(&pm[1],
-                data,
-                data_len);
-  GNUNET_MQ_send(lc->mq,
-                 env);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Queued reply to query `%s' for local client\n",
-             GNUNET_h2s(&prd->query));
+  env = GNUNET_MQ_msg_extra (pm,
+                             data_len,
+                             GNUNET_MESSAGE_TYPE_FS_PUT);
+  pm->type = htonl (type);
+  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
+  pm->last_transmission = GNUNET_TIME_absolute_hton (last_transmission);
+  pm->num_transmissions = htonl (prd->num_transmissions);
+  pm->respect_offered = htonl (prd->respect_offered);
+  GNUNET_memcpy (&pm[1],
+                 data,
+                 data_len);
+  GNUNET_MQ_send (lc->mq,
+                  env);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Queued reply to query `%s' for local client\n",
+              GNUNET_h2s (&prd->query));
   if (GNUNET_BLOCK_EVALUATION_OK_LAST != eval)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Evaluation %d - keeping query alive\n",
-                 (int)eval);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Evaluation %d - keeping query alive\n",
+                (int) eval);
+    return;
+  }
   if (NULL == cr->kill_task)
-    cr->kill_task = GNUNET_SCHEDULER_add_now(&client_request_destroy,
-                                             cr);
+    cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
+                                              cr);
 }
 
 
@@ -465,9 +470,9 @@ client_response_handler(void *cls,
  * @param app_ctx the `struct GSF_LocalClient`
  */
 static void
-client_disconnect_cb(void *cls,
-                     struct GNUNET_SERVICE_Client *client,
-                     void *app_ctx)
+client_disconnect_cb (void *cls,
+                      struct GNUNET_SERVICE_Client *client,
+                      void *app_ctx)
 {
   struct GSF_LocalClient *lc = app_ctx;
   struct IndexStartContext *isc;
@@ -475,27 +480,27 @@ client_disconnect_cb(void *cls,
   struct ClientResponse *res;
 
   while (NULL != (cr = lc->cr_head))
-    {
-      if (NULL != cr->kill_task)
-        GNUNET_SCHEDULER_cancel(cr->kill_task);
-      client_request_destroy(cr);
-    }
+  {
+    if (NULL != cr->kill_task)
+      GNUNET_SCHEDULER_cancel (cr->kill_task);
+    client_request_destroy (cr);
+  }
   while (NULL != (res = lc->res_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(lc->res_head,
-                                  lc->res_tail,
-                                  res);
-      GNUNET_free(res);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (lc->res_head,
+                                 lc->res_tail,
+                                 res);
+    GNUNET_free (res);
+  }
   while (NULL != (isc = lc->isc_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(lc->isc_head,
-                                  lc->isc_tail,
-                                  isc);
-      GNUNET_CRYPTO_hash_file_cancel(isc->fhc);
-      GNUNET_free(isc);
-    }
-  GNUNET_free(lc);
+  {
+    GNUNET_CONTAINER_DLL_remove (lc->isc_head,
+                                 lc->isc_tail,
+                                 isc);
+    GNUNET_CRYPTO_hash_file_cancel (isc->fhc);
+    GNUNET_free (isc);
+  }
+  GNUNET_free (lc);
 }
 
 
@@ -508,14 +513,14 @@ client_disconnect_cb(void *cls,
  * @param cls unused closure
  */
 static void
-age_cover_counters(void *cls)
+age_cover_counters (void *cls)
 {
   GSF_cover_content_count = (GSF_cover_content_count * 15) / 16;
   GSF_cover_query_count = (GSF_cover_query_count * 15) / 16;
   cover_age_task =
-    GNUNET_SCHEDULER_add_delayed(COVER_AGE_FREQUENCY,
-                                 &age_cover_counters,
-                                 NULL);
+    GNUNET_SCHEDULER_add_delayed (COVER_AGE_FREQUENCY,
+                                  &age_cover_counters,
+                                  NULL);
 }
 
 
@@ -526,12 +531,12 @@ age_cover_counters(void *cls)
  * @param start time when the datastore request was issued
  */
 void
-GSF_update_datastore_delay_(struct GNUNET_TIME_Absolute start)
+GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start)
 {
   struct GNUNET_TIME_Relative delay;
 
-  delay = GNUNET_TIME_absolute_get_duration(start);
-  GNUNET_LOAD_update(datastore_get_load, delay.rel_value_us);
+  delay = GNUNET_TIME_absolute_get_duration (start);
+  GNUNET_LOAD_update (datastore_get_load, delay.rel_value_us);
 }
 
 
@@ -546,11 +551,11 @@ GSF_update_datastore_delay_(struct GNUNET_TIME_Absolute start)
  *         #GNUNET_SYSERR to process for free (load low)
  */
 int
-GSF_test_get_load_too_high_(uint32_t priority)
+GSF_test_get_load_too_high_ (uint32_t priority)
 {
   double ld;
 
-  ld = GNUNET_LOAD_get_load(datastore_get_load);
+  ld = GNUNET_LOAD_get_load (datastore_get_load);
   if (ld < 1)
     return GNUNET_SYSERR;
   if (ld <= priority)
@@ -571,30 +576,30 @@ GSF_test_get_load_too_high_(uint32_t priority)
  * @param prop performance data for the address (as far as known)
  */
 static void
-update_latencies(void *cls,
-                 const struct GNUNET_HELLO_Address *address,
-                 int active,
-                 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                 struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
-                 const struct GNUNET_ATS_Properties *prop)
+update_latencies (void *cls,
+                  const struct GNUNET_HELLO_Address *address,
+                  int active,
+                  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                  struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+                  const struct GNUNET_ATS_Properties *prop)
 {
   if (NULL == address)
-    {
-      /* ATS service temporarily disconnected */
-      return;
-    }
+  {
+    /* ATS service temporarily disconnected */
+    return;
+  }
 
   if (GNUNET_YES != active)
     return;
-  GSF_update_peer_latency_(&address->peer,
-                           prop->delay);
+  GSF_update_peer_latency_ (&address->peer,
+                            prop->delay);
   GSF_avg_latency.rel_value_us =
-    (GSF_avg_latency.rel_value_us * 31 +
-     GNUNET_MIN(5000, prop->delay.rel_value_us)) / 32;
-  GNUNET_STATISTICS_set(GSF_stats,
-                        gettext_noop("# running average P2P latency (ms)"),
-                        GSF_avg_latency.rel_value_us / 1000LL,
-                        GNUNET_NO);
+    (GSF_avg_latency.rel_value_us * 31
+     + GNUNET_MIN (5000, prop->delay.rel_value_us)) / 32;
+  GNUNET_STATISTICS_set (GSF_stats,
+                         gettext_noop ("# running average P2P latency (ms)"),
+                         GSF_avg_latency.rel_value_us / 1000LL,
+                         GNUNET_NO);
 }
 
 
@@ -607,17 +612,17 @@ update_latencies(void *cls,
  *         #GNUNET_SYSERR to close it (signal serious error)
  */
 static int
-check_p2p_put(void *cls,
-              const struct PutMessage *put)
+check_p2p_put (void *cls,
+               const struct PutMessage *put)
 {
   enum GNUNET_BLOCK_Type type;
 
-  type = ntohl(put->type);
+  type = ntohl (put->type);
   if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -632,25 +637,25 @@ check_p2p_put(void *cls,
  * @param ppd peer performance data
  */
 static void
-consider_request_for_forwarding(void *cls,
-                                const struct GNUNET_PeerIdentity *peer,
-                                struct GSF_ConnectedPeer *cp,
-                                const struct GSF_PeerPerformanceData *ppd)
+consider_request_for_forwarding (void *cls,
+                                 const struct GNUNET_PeerIdentity *peer,
+                                 struct GSF_ConnectedPeer *cp,
+                                 const struct GSF_PeerPerformanceData *ppd)
 {
   struct GSF_PendingRequest *pr = cls;
 
   if (GNUNET_YES !=
-      GSF_pending_request_test_target_(pr, peer))
-    {
+      GSF_pending_request_test_target_ (pr, peer))
+  {
 #if INSANE_STATISTICS
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# Loopback routes suppressed"), 1,
-                               GNUNET_NO);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# Loopback routes suppressed"), 1,
+                              GNUNET_NO);
 #endif
-      return;
-    }
-  GSF_plan_add_(cp,
-                pr);
+    return;
+  }
+  GSF_plan_add_ (cp,
+                 pr);
 }
 
 
@@ -665,17 +670,17 @@ consider_request_for_forwarding(void *cls,
  * @param result final datastore lookup result
  */
 void
-GSF_consider_forwarding(void *cls,
-                        struct GSF_PendingRequest *pr,
-                        enum GNUNET_BLOCK_EvaluationResult result)
+GSF_consider_forwarding (void *cls,
+                         struct GSF_PendingRequest *pr,
+                         enum GNUNET_BLOCK_EvaluationResult result)
 {
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
     return;                     /* we're done... */
   if (GNUNET_YES !=
-      GSF_pending_request_test_active_(pr))
+      GSF_pending_request_test_active_ (pr))
     return; /* request is not actually active, skip! */
-  GSF_iterate_connected_peers_(&consider_request_for_forwarding,
-                               pr);
+  GSF_iterate_connected_peers_ (&consider_request_for_forwarding,
+                                pr);
 }
 
 
@@ -688,35 +693,37 @@ GSF_consider_forwarding(void *cls,
  *         #GNUNET_SYSERR to close it (signal serious error)
  */
 static int
-check_p2p_get(void *cls,
-              const struct GetMessage *gm)
+check_p2p_get (void *cls,
+               const struct GetMessage *gm)
 {
   size_t msize;
   unsigned int bm;
   unsigned int bits;
   size_t bfsize;
 
-  msize = ntohs(gm->header.size);
-  bm = ntohl(gm->hash_bitmap);
+  msize = ntohs (gm->header.size);
+  bm = ntohl (gm->hash_bitmap);
   bits = 0;
   while (bm > 0)
-    {
-      if (1 == (bm & 1))
-        bits++;
-      bm >>= 1;
-    }
-  if (msize < sizeof(struct GetMessage) + bits * sizeof(struct GNUNET_PeerIdentity))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct GNUNET_PeerIdentity);
+  {
+    if (1 == (bm & 1))
+      bits++;
+    bm >>= 1;
+  }
+  if (msize < sizeof(struct GetMessage) + bits * sizeof(struct
+                                                        GNUNET_PeerIdentity))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
+                                                             GNUNET_PeerIdentity);
   /* bfsize must be power of 2, check! */
   if (0 != ((bfsize - 1) & bfsize))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -732,48 +739,48 @@ check_p2p_get(void *cls,
  * @param result final datastore lookup result
  */
 static void
-start_p2p_processing(void *cls,
-                     struct GSF_PendingRequest *pr,
-                     enum GNUNET_BLOCK_EvaluationResult result)
+start_p2p_processing (void *cls,
+                      struct GSF_PendingRequest *pr,
+                      enum GNUNET_BLOCK_EvaluationResult result)
 {
   struct GSF_LocalClient *lc = cls;
   struct GSF_PendingRequestData *prd;
 
-  GNUNET_SERVICE_client_continue(lc->client);
+  GNUNET_SERVICE_client_continue (lc->client);
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
     return;                     /* we're done, 'pr' was already destroyed... */
-  prd = GSF_pending_request_get_data_(pr);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Finished database lookup for local request `%s' with result %d\n",
-             GNUNET_h2s(&prd->query),
-             result);
+  prd = GSF_pending_request_get_data_ (pr);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finished database lookup for local request `%s' with result %d\n",
+              GNUNET_h2s (&prd->query),
+              result);
   if (0 == prd->anonymity_level)
+  {
+    switch (prd->type)
     {
-      switch (prd->type)
-        {
-        case GNUNET_BLOCK_TYPE_FS_DBLOCK:
-        case GNUNET_BLOCK_TYPE_FS_IBLOCK:
-          /* the above block types MAY be available via 'cadet' */
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Considering cadet-based download for block\n");
-          GSF_cadet_lookup_(pr);
-          break;
-
-        case GNUNET_BLOCK_TYPE_FS_UBLOCK:
-          /* the above block types are in the DHT */
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Considering DHT-based search for block\n");
-          GSF_dht_lookup_(pr);
-          break;
-
-        default:
-          GNUNET_break(0);
-          break;
-        }
+    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
+    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
+      /* the above block types MAY be available via 'cadet' */
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Considering cadet-based download for block\n");
+      GSF_cadet_lookup_ (pr);
+      break;
+
+    case GNUNET_BLOCK_TYPE_FS_UBLOCK:
+      /* the above block types are in the DHT */
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Considering DHT-based search for block\n");
+      GSF_dht_lookup_ (pr);
+      break;
+
+    default:
+      GNUNET_break (0);
+      break;
     }
-  GSF_consider_forwarding(NULL,
-                          pr,
-                          result);
+  }
+  GSF_consider_forwarding (NULL,
+                           pr,
+                           result);
 }
 
 
@@ -786,17 +793,17 @@ start_p2p_processing(void *cls,
  * @return #GNUNET_OK if @a sm is well-formed
  */
 static int
-check_client_start_search(void *cls,
-                          const struct SearchMessage *sm)
+check_client_start_search (void *cls,
+                           const struct SearchMessage *sm)
 {
   uint16_t msize;
 
-  msize = ntohs(sm->header.size) - sizeof(struct SearchMessage);
+  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
   if (0 != msize % sizeof(struct GNUNET_HashCode))
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -812,8 +819,8 @@ check_client_start_search(void *cls,
  * @param sm the actual message
  */
 static void
-handle_client_start_search(void *cls,
-                           const struct SearchMessage *sm)
+handle_client_start_search (void *cls,
+                            const struct SearchMessage *sm)
 {
   static struct GNUNET_PeerIdentity all_zeros;
   struct GSF_LocalClient *lc = cls;
@@ -824,90 +831,93 @@ handle_client_start_search(void *cls,
   enum GNUNET_BLOCK_Type type;
   enum GSF_PendingRequestOptions options;
 
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# client searches received"),
-                           1,
-                           GNUNET_NO);
-  msize = ntohs(sm->header.size) - sizeof(struct SearchMessage);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# client searches received"),
+                            1,
+                            GNUNET_NO);
+  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
   sc = msize / sizeof(struct GNUNET_HashCode);
-  type = ntohl(sm->type);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received request for `%s' of type %u from local client\n",
-             GNUNET_h2s(&sm->query),
-             (unsigned int)type);
+  type = ntohl (sm->type);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received request for `%s' of type %u from local client\n",
+              GNUNET_h2s (&sm->query),
+              (unsigned int) type);
   cr = NULL;
   /* detect duplicate UBLOCK requests */
   if ((type == GNUNET_BLOCK_TYPE_FS_UBLOCK) ||
       (type == GNUNET_BLOCK_TYPE_ANY))
+  {
+    cr = lc->cr_head;
+    while (NULL != cr)
     {
-      cr = lc->cr_head;
-      while (NULL != cr)
-        {
-          prd = GSF_pending_request_get_data_(cr->pr);
-          /* only unify with queries that hae not yet started local processing
-             (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
-             matching query and type */
-          if ((GNUNET_YES != prd->has_started) &&
-              (0 != memcmp(&prd->query,
-                           &sm->query,
-                           sizeof(struct GNUNET_HashCode))) &&
-              (prd->type == type))
-            break;
-          cr = cr->next;
-        }
+      prd = GSF_pending_request_get_data_ (cr->pr);
+      /* only unify with queries that hae not yet started local processing
+         (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
+         matching query and type */
+      if ((GNUNET_YES != prd->has_started) &&
+          (0 != memcmp (&prd->query,
+                        &sm->query,
+                        sizeof(struct GNUNET_HashCode))) &&
+          (prd->type == type))
+        break;
+      cr = cr->next;
     }
+  }
   if (NULL != cr)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Have existing request, merging content-seen lists.\n");
-      GSF_pending_request_update_(cr->pr,
-                                  (const struct GNUNET_HashCode *)&sm[1],
-                                  sc);
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# client searches updated (merged content seen list)"),
-                               1,
-                               GNUNET_NO);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Have existing request, merging content-seen lists.\n");
+    GSF_pending_request_update_ (cr->pr,
+                                 (const struct GNUNET_HashCode *) &sm[1],
+                                 sc);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# client searches updated (merged content seen list)"),
+                              1,
+                              GNUNET_NO);
+  }
   else
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# client searches active"),
-                               1,
-                               GNUNET_NO);
-      cr = GNUNET_new(struct ClientRequest);
-      cr->lc = lc;
-      GNUNET_CONTAINER_DLL_insert(lc->cr_head,
-                                  lc->cr_tail,
-                                  cr);
-      options = GSF_PRO_LOCAL_REQUEST;
-      if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl(sm->options)))
-        options |= GSF_PRO_LOCAL_ONLY;
-      cr->pr = GSF_pending_request_create_(options, type,
-                                           &sm->query,
-                                           (0 !=
-                                            memcmp(&sm->target,
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# client searches active"),
+                              1,
+                              GNUNET_NO);
+    cr = GNUNET_new (struct ClientRequest);
+    cr->lc = lc;
+    GNUNET_CONTAINER_DLL_insert (lc->cr_head,
+                                 lc->cr_tail,
+                                 cr);
+    options = GSF_PRO_LOCAL_REQUEST;
+    if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
+      options |= GSF_PRO_LOCAL_ONLY;
+    cr->pr = GSF_pending_request_create_ (options, type,
+                                          &sm->query,
+                                          (0 !=
+                                           memcmp (&sm->target,
                                                    &all_zeros,
-                                                   sizeof(struct GNUNET_PeerIdentity)))
-                                           ? &sm->target : NULL, NULL, 0,
-                                           0 /* bf */,
-                                           ntohl(sm->anonymity_level),
-                                           0 /* priority */,
-                                           0 /* ttl */,
-                                           0 /* sender PID */,
-                                           0 /* origin PID */,
-                                           (const struct GNUNET_HashCode *)&sm[1], sc,
-                                           &client_response_handler,
-                                           cr);
-    }
-  if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl(sm->options)))
-    {
-      GNUNET_SERVICE_client_continue(lc->client);
-      return;
-    }
-  GSF_pending_request_get_data_(cr->pr)->has_started = GNUNET_YES;
-  GSF_local_lookup_(cr->pr,
-                    &start_p2p_processing,
-                    lc);
+                                                   sizeof(struct
+                                                          GNUNET_PeerIdentity)))
+                                          ? &sm->target : NULL, NULL, 0,
+                                          0 /* bf */,
+                                          ntohl (sm->anonymity_level),
+                                          0 /* priority */,
+                                          0 /* ttl */,
+                                          0 /* sender PID */,
+                                          0 /* origin PID */,
+                                          (const struct
+                                           GNUNET_HashCode *) &sm[1], sc,
+                                          &client_response_handler,
+                                          cr);
+  }
+  if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl (sm->options)))
+  {
+    GNUNET_SERVICE_client_continue (lc->client);
+    return;
+  }
+  GSF_pending_request_get_data_ (cr->pr)->has_started = GNUNET_YES;
+  GSF_local_lookup_ (cr->pr,
+                     &start_p2p_processing,
+                     lc);
 }
 
 
@@ -918,8 +928,8 @@ handle_client_start_search(void *cls,
  * @param msg the actual message
  */
 static void
-handle_client_loc_sign(void *cls,
-                       const struct RequestLocSignatureMessage *msg)
+handle_client_loc_sign (void *cls,
+                        const struct RequestLocSignatureMessage *msg)
 {
   struct GSF_LocalClient *lc = cls;
   struct GNUNET_FS_Uri base;
@@ -927,24 +937,26 @@ handle_client_loc_sign(void *cls,
   struct GNUNET_MQ_Envelope *env;
   struct ResponseLocSignatureMessage *resp;
 
-  GNUNET_break(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT ==
-               ntohl(msg->purpose));
+  GNUNET_break (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT ==
+                ntohl (msg->purpose));
   base.type = GNUNET_FS_URI_CHK;
   base.data.chk.chk = msg->chk;
-  base.data.chk.file_length = GNUNET_ntohll(msg->file_length);
-  loc = GNUNET_FS_uri_loc_create(&base,
-                                 pk,
-                                 GNUNET_TIME_absolute_ntoh(msg->expiration_time));
-  env = GNUNET_MQ_msg(resp,
-                      GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE);
-  resp->purpose = htonl(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
-  resp->expiration_time = GNUNET_TIME_absolute_hton(loc->data.loc.expirationTime);
+  base.data.chk.file_length = GNUNET_ntohll (msg->file_length);
+  loc = GNUNET_FS_uri_loc_create (&base,
+                                  pk,
+                                  GNUNET_TIME_absolute_ntoh (
+                                    msg->expiration_time));
+  env = GNUNET_MQ_msg (resp,
+                       GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE);
+  resp->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
+  resp->expiration_time = GNUNET_TIME_absolute_hton (
+    loc->data.loc.expirationTime);
   resp->signature = loc->data.loc.contentSignature;
   resp->peer = loc->data.loc.peer;
-  GNUNET_FS_uri_destroy(loc);
-  GNUNET_MQ_send(lc->mq,
-                 env);
-  GNUNET_SERVICE_client_continue(lc->client);
+  GNUNET_FS_uri_destroy (loc);
+  GNUNET_MQ_send (lc->mq,
+                  env);
+  GNUNET_SERVICE_client_continue (lc->client);
 }
 
 
@@ -956,24 +968,24 @@ handle_client_loc_sign(void *cls,
  * @return #GNUNET_OK if @a ism is well-formed
  */
 static int
-check_client_index_start(void *cls,
-                         const struct IndexStartMessage *ism)
+check_client_index_start (void *cls,
+                          const struct IndexStartMessage *ism)
 {
   char *fn;
 
-  GNUNET_MQ_check_zero_termination(ism);
+  GNUNET_MQ_check_zero_termination (ism);
   if (0 != ism->reserved)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
-  fn = GNUNET_STRINGS_filename_expand((const char *)&ism[1]);
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
   if (NULL == fn)
-    {
-      GNUNET_break(0);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_free(fn);
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_free (fn);
   return GNUNET_OK;
 }
 
@@ -985,21 +997,21 @@ check_client_index_start(void *cls,
  * @param isc the data about the index info entry for the request
  */
 static void
-signal_index_ok(struct IndexStartContext *isc)
+signal_index_ok (struct IndexStartContext *isc)
 {
   struct GSF_LocalClient *lc = isc->lc;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
 
-  GNUNET_FS_add_to_index(isc->filename,
-                         &isc->file_id);
-  env = GNUNET_MQ_msg(msg,
-                      GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
-  GNUNET_MQ_send(lc->mq,
-                 env);
-  GNUNET_free(isc->filename);
-  GNUNET_free(isc);
-  GNUNET_SERVICE_client_continue(lc->client);
+  GNUNET_FS_add_to_index (isc->filename,
+                          &isc->file_id);
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
+  GNUNET_MQ_send (lc->mq,
+                  env);
+  GNUNET_free (isc->filename);
+  GNUNET_free (isc);
+  GNUNET_SERVICE_client_continue (lc->client);
 }
 
 
@@ -1011,36 +1023,37 @@ signal_index_ok(struct IndexStartContext *isc)
  * @param res resulting hash, NULL on error
  */
 static void
-hash_for_index_val(void *cls,
-                   const struct GNUNET_HashCode *res)
+hash_for_index_val (void *cls,
+                    const struct GNUNET_HashCode *res)
 {
   struct IndexStartContext *isc = cls;
   struct GSF_LocalClient *lc = isc->lc;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
 
-  GNUNET_CONTAINER_DLL_remove(lc->isc_head,
-                              lc->isc_tail,
-                              isc);
+  GNUNET_CONTAINER_DLL_remove (lc->isc_head,
+                               lc->isc_tail,
+                               isc);
   isc->fhc = NULL;
   if ((NULL == res) ||
-      (0 != memcmp(res,
-                   &isc->file_id,
-                   sizeof(struct GNUNET_HashCode))))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
-                 isc->filename,
-                 GNUNET_h2s(&isc->file_id));
-      env = GNUNET_MQ_msg(msg,
-                          GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
-      GNUNET_MQ_send(lc->mq,
-                     env);
-      GNUNET_SERVICE_client_continue(lc->client);
-      GNUNET_free(isc);
-      return;
-    }
-  signal_index_ok(isc);
+      (0 != memcmp (res,
+                    &isc->file_id,
+                    sizeof(struct GNUNET_HashCode))))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
+                isc->filename,
+                GNUNET_h2s (&isc->file_id));
+    env = GNUNET_MQ_msg (msg,
+                         GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
+    GNUNET_MQ_send (lc->mq,
+                    env);
+    GNUNET_SERVICE_client_continue (lc->client);
+    GNUNET_free (isc);
+    return;
+  }
+  signal_index_ok (isc);
 }
 
 
@@ -1051,8 +1064,8 @@ hash_for_index_val(void *cls,
  * @param message the actual message
  */
 static void
-handle_client_index_start(void *cls,
-                          const struct IndexStartMessage *ism)
+handle_client_index_start (void *cls,
+                           const struct IndexStartMessage *ism)
 {
   struct GSF_LocalClient *lc = cls;
   struct IndexStartContext *isc;
@@ -1062,49 +1075,49 @@ handle_client_index_start(void *cls,
   uint64_t mydev;
   uint64_t myino;
 
-  fn = GNUNET_STRINGS_filename_expand((const char *)&ism[1]);
-  GNUNET_assert(NULL != fn);
-  dev = GNUNET_ntohll(ism->device);
-  ino = GNUNET_ntohll(ism->inode);
-  isc = GNUNET_new(struct IndexStartContext);
+  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
+  GNUNET_assert (NULL != fn);
+  dev = GNUNET_ntohll (ism->device);
+  ino = GNUNET_ntohll (ism->inode);
+  isc = GNUNET_new (struct IndexStartContext);
   isc->filename = fn;
   isc->file_id = ism->file_id;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received START_INDEX message for file `%s'\n",
-             isc->filename);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received START_INDEX message for file `%s'\n",
+              isc->filename);
   isc->lc = lc;
   mydev = 0;
   myino = 0;
   if (((dev != 0) ||
        (ino != 0)) &&
-      (GNUNET_OK == GNUNET_DISK_file_get_identifiers(fn,
-                                                     &mydev,
-                                                     &myino)) &&
+      (GNUNET_OK == GNUNET_DISK_file_get_identifiers (fn,
+                                                      &mydev,
+                                                      &myino)) &&
       (dev == mydev) &&
       (ino == myino))
-    {
-      /* fast validation OK! */
-      signal_index_ok(isc);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
-             (unsigned long long)ino,
-             (unsigned long long)myino,
-             (unsigned int)dev,
-             (unsigned int)mydev);
+  {
+    /* fast validation OK! */
+    signal_index_ok (isc);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
+              (unsigned long long) ino,
+              (unsigned long long) myino,
+              (unsigned int) dev,
+              (unsigned int) mydev);
   /* slow validation, need to hash full file (again) */
-  GNUNET_CONTAINER_DLL_insert(lc->isc_head,
-                              lc->isc_tail,
-                              isc);
-  isc->fhc = GNUNET_CRYPTO_hash_file(GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                     isc->filename,
-                                     HASHING_BLOCKSIZE,
-                                     &hash_for_index_val,
-                                     isc);
+  GNUNET_CONTAINER_DLL_insert (lc->isc_head,
+                               lc->isc_tail,
+                               isc);
+  isc->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
+                                      isc->filename,
+                                      HASHING_BLOCKSIZE,
+                                      &hash_for_index_val,
+                                      isc);
   if (NULL == isc->fhc)
-    hash_for_index_val(isc,
-                       NULL);
+    hash_for_index_val (isc,
+                        NULL);
 }
 
 
@@ -1115,13 +1128,13 @@ handle_client_index_start(void *cls,
  * @param message the actual message
  */
 static void
-handle_client_index_list_get(void *cls,
-                             const struct GNUNET_MessageHeader *message)
+handle_client_index_list_get (void *cls,
+                              const struct GNUNET_MessageHeader *message)
 {
   struct GSF_LocalClient *lc = cls;
 
-  GNUNET_FS_indexing_send_list(lc->mq);
-  GNUNET_SERVICE_client_continue(lc->client);
+  GNUNET_FS_indexing_send_list (lc->mq);
+  GNUNET_SERVICE_client_continue (lc->client);
 }
 
 
@@ -1132,25 +1145,25 @@ handle_client_index_list_get(void *cls,
  * @param message the actual message
  */
 static void
-handle_client_unindex(void *cls,
-                      const struct UnindexMessage *um)
+handle_client_unindex (void *cls,
+                       const struct UnindexMessage *um)
 {
   struct GSF_LocalClient *lc = cls;
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
   int found;
 
-  GNUNET_break(0 == um->reserved);
-  found = GNUNET_FS_indexing_do_unindex(&um->file_id);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Client requested unindexing of file `%s': %s\n",
-             GNUNET_h2s(&um->file_id),
-             found ? "found" : "not found");
-  env = GNUNET_MQ_msg(msg,
-                      GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
-  GNUNET_MQ_send(lc->mq,
-                 env);
-  GNUNET_SERVICE_client_continue(lc->client);
+  GNUNET_break (0 == um->reserved);
+  found = GNUNET_FS_indexing_do_unindex (&um->file_id);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Client requested unindexing of file `%s': %s\n",
+              GNUNET_h2s (&um->file_id),
+              found ? "found" : "not found");
+  env = GNUNET_MQ_msg (msg,
+                       GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
+  GNUNET_MQ_send (lc->mq,
+                  env);
+  GNUNET_SERVICE_client_continue (lc->client);
 }
 
 
@@ -1160,44 +1173,44 @@ handle_client_unindex(void *cls,
  * @param cls unused
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
-  GSF_cadet_stop_server();
+  GSF_cadet_stop_server ();
   if (NULL != GSF_core)
-    {
-      GNUNET_CORE_disconnect(GSF_core);
-      GSF_core = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (GSF_core);
+    GSF_core = NULL;
+  }
   if (NULL != GSF_ats)
-    {
-      GNUNET_ATS_performance_done(GSF_ats);
-      GSF_ats = NULL;
-    }
-  GSF_put_done_();
-  GSF_push_done_();
-  GSF_pending_request_done_();
-  GSF_plan_done();
-  GSF_connected_peer_done_();
-  GNUNET_DATASTORE_disconnect(GSF_dsh,
-                              GNUNET_NO);
+  {
+    GNUNET_ATS_performance_done (GSF_ats);
+    GSF_ats = NULL;
+  }
+  GSF_put_done_ ();
+  GSF_push_done_ ();
+  GSF_pending_request_done_ ();
+  GSF_plan_done ();
+  GSF_connected_peer_done_ ();
+  GNUNET_DATASTORE_disconnect (GSF_dsh,
+                               GNUNET_NO);
   GSF_dsh = NULL;
-  GNUNET_DHT_disconnect(GSF_dht);
+  GNUNET_DHT_disconnect (GSF_dht);
   GSF_dht = NULL;
-  GNUNET_BLOCK_context_destroy(GSF_block_ctx);
+  GNUNET_BLOCK_context_destroy (GSF_block_ctx);
   GSF_block_ctx = NULL;
-  GNUNET_CONFIGURATION_destroy(block_cfg);
+  GNUNET_CONFIGURATION_destroy (block_cfg);
   block_cfg = NULL;
-  GNUNET_STATISTICS_destroy(GSF_stats, GNUNET_NO);
+  GNUNET_STATISTICS_destroy (GSF_stats, GNUNET_NO);
   GSF_stats = NULL;
   if (NULL != cover_age_task)
-    {
-      GNUNET_SCHEDULER_cancel(cover_age_task);
-      cover_age_task = NULL;
-    }
-  GNUNET_FS_indexing_done();
-  GNUNET_LOAD_value_free(datastore_get_load);
+  {
+    GNUNET_SCHEDULER_cancel (cover_age_task);
+    cover_age_task = NULL;
+  }
+  GNUNET_FS_indexing_done ();
+  GNUNET_LOAD_value_free (datastore_get_load);
   datastore_get_load = NULL;
-  GNUNET_LOAD_value_free(GSF_rt_entry_lifetime);
+  GNUNET_LOAD_value_free (GSF_rt_entry_lifetime);
   GSF_rt_entry_lifetime = NULL;
 }
 
@@ -1213,16 +1226,16 @@ shutdown_task(void *cls)
  * @param my_identity ID of this peer, NULL if we failed
  */
 static void
-peer_init_handler(void *cls,
-                  const struct GNUNET_PeerIdentity *my_identity)
+peer_init_handler (void *cls,
+                   const struct GNUNET_PeerIdentity *my_identity)
 {
-  if (0 != GNUNET_memcmp(&GSF_my_id,
-                         my_identity))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Peer identity mismatch, refusing to start!\n");
-      GNUNET_SCHEDULER_shutdown();
-    }
+  if (0 != GNUNET_memcmp (&GSF_my_id,
+                          my_identity))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Peer identity mismatch, refusing to start!\n");
+    GNUNET_SCHEDULER_shutdown ();
+  }
 }
 
 
@@ -1232,25 +1245,25 @@ peer_init_handler(void *cls,
  * @param c configuration to use
  */
 static int
-main_init(const struct GNUNET_CONFIGURATION_Handle *c)
+main_init (const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
-    GNUNET_MQ_hd_var_size(p2p_get,
-                          GNUNET_MESSAGE_TYPE_FS_GET,
-                          struct GetMessage,
-                          NULL),
-    GNUNET_MQ_hd_var_size(p2p_put,
-                          GNUNET_MESSAGE_TYPE_FS_PUT,
-                          struct PutMessage,
-                          NULL),
-    GNUNET_MQ_hd_fixed_size(p2p_migration_stop,
-                            GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
-                            struct MigrationStopMessage,
-                            NULL),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_var_size (p2p_get,
+                           GNUNET_MESSAGE_TYPE_FS_GET,
+                           struct GetMessage,
+                           NULL),
+    GNUNET_MQ_hd_var_size (p2p_put,
+                           GNUNET_MESSAGE_TYPE_FS_PUT,
+                           struct PutMessage,
+                           NULL),
+    GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
+                             GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
+                             struct MigrationStopMessage,
+                             NULL),
+    GNUNET_MQ_handler_end ()
   };
   int anon_p2p_off;
   char *keyfile;
@@ -1258,54 +1271,55 @@ main_init(const struct GNUNET_CONFIGURATION_Handle *c)
   /* this option is really only for testcases that need to disable
      _anonymous_ file-sharing for some reason */
   anon_p2p_off = (GNUNET_YES ==
-                  GNUNET_CONFIGURATION_get_value_yesno(GSF_cfg,
-                                                       "fs",
-                                                       "DISABLE_ANON_TRANSFER"));
+                  GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg,
+                                                        "fs",
+                                                        "DISABLE_ANON_TRANSFER"));
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename(GSF_cfg,
-                                              "PEER",
-                                              "PRIVATE_KEY",
-                                              &keyfile))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("FS service is lacking HOSTKEY configuration setting.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown();
-      return GNUNET_SYSERR;
-    }
-  pk = GNUNET_CRYPTO_eddsa_key_create_from_file(keyfile);
-  GNUNET_free(keyfile);
-  GNUNET_assert(NULL != pk);
-  GNUNET_CRYPTO_eddsa_key_get_public(pk,
-                                     &GSF_my_id.public_key);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "I am peer %s\n",
-             GNUNET_i2s(&GSF_my_id));
+      GNUNET_CONFIGURATION_get_value_filename (GSF_cfg,
+                                               "PEER",
+                                               "PRIVATE_KEY",
+                                               &keyfile))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ (
+                  "FS service is lacking HOSTKEY configuration setting.  Exiting.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    return GNUNET_SYSERR;
+  }
+  pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
+  GNUNET_free (keyfile);
+  GNUNET_assert (NULL != pk);
+  GNUNET_CRYPTO_eddsa_key_get_public (pk,
+                                      &GSF_my_id.public_key);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "I am peer %s\n",
+              GNUNET_i2s (&GSF_my_id));
   GSF_core
-    = GNUNET_CORE_connect(GSF_cfg,
-                          NULL,
-                          &peer_init_handler,
-                          &GSF_peer_connect_handler,
-                          &GSF_peer_disconnect_handler,
-                          (GNUNET_YES == anon_p2p_off)
-                          ? no_p2p_handlers
-                          : p2p_handlers);
+    = GNUNET_CORE_connect (GSF_cfg,
+                           NULL,
+                           &peer_init_handler,
+                           &GSF_peer_connect_handler,
+                           &GSF_peer_disconnect_handler,
+                           (GNUNET_YES == anon_p2p_off)
+                           ? no_p2p_handlers
+                           : p2p_handlers);
   if (NULL == GSF_core)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Failed to connect to `%s' service.\n"),
-                 "core");
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Failed to connect to `%s' service.\n"),
+                "core");
+    return GNUNET_SYSERR;
+  }
   cover_age_task =
-    GNUNET_SCHEDULER_add_delayed(COVER_AGE_FREQUENCY,
-                                 &age_cover_counters,
+    GNUNET_SCHEDULER_add_delayed (COVER_AGE_FREQUENCY,
+                                  &age_cover_counters,
+                                  NULL);
+  datastore_get_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
+  GSF_cadet_start_server ();
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                  NULL);
-  datastore_get_load = GNUNET_LOAD_value_init(DATASTORE_LOAD_AUTODECLINE);
-  GSF_cadet_start_server();
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
-                                NULL);
   return GNUNET_OK;
 }
 
@@ -1318,55 +1332,55 @@ main_init(const struct GNUNET_CONFIGURATION_Handle *c)
  * @param service the initialized service
  */
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_SERVICE_Handle *service)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_SERVICE_Handle *service)
 {
   unsigned long long dqs;
 
   GSF_cfg = cfg;
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_size(GSF_cfg,
-                                          "fs",
-                                          "DATASTORE_QUEUE_SIZE",
-                                          &dqs))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_INFO,
-                                "fs",
-                                "DATASTORE_QUEUE_SIZE");
-      dqs = 32;
-    }
-  GSF_datastore_queue_size = (unsigned int)dqs;
+      GNUNET_CONFIGURATION_get_value_size (GSF_cfg,
+                                           "fs",
+                                           "DATASTORE_QUEUE_SIZE",
+                                           &dqs))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
+                               "fs",
+                               "DATASTORE_QUEUE_SIZE");
+    dqs = 32;
+  }
+  GSF_datastore_queue_size = (unsigned int) dqs;
   GSF_enable_randomized_delays =
-    GNUNET_CONFIGURATION_get_value_yesno(cfg, "fs", "DELAY");
-  GSF_dsh = GNUNET_DATASTORE_connect(cfg);
+    GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
+  GSF_dsh = GNUNET_DATASTORE_connect (cfg);
   if (NULL == GSF_dsh)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GSF_rt_entry_lifetime = GNUNET_LOAD_value_init(GNUNET_TIME_UNIT_FOREVER_REL);
-  GSF_stats = GNUNET_STATISTICS_create("fs", cfg);
-  block_cfg = GNUNET_CONFIGURATION_create();
-  GSF_block_ctx = GNUNET_BLOCK_context_create(block_cfg);
-  GNUNET_assert(NULL != GSF_block_ctx);
-  GSF_dht = GNUNET_DHT_connect(cfg, FS_DHT_HT_SIZE);
-  GSF_plan_init();
-  GSF_pending_request_init_();
-  GSF_connected_peer_init_();
-  GSF_ats = GNUNET_ATS_performance_init(GSF_cfg,
-                                        &update_latencies,
-                                        NULL);
-  GSF_push_init_();
-  GSF_put_init_();
-  if ((GNUNET_OK != GNUNET_FS_indexing_init(cfg,
-                                            GSF_dsh)) ||
-      (GNUNET_OK != main_init(cfg)))
-    {
-      GNUNET_SCHEDULER_shutdown();
-      shutdown_task(NULL);
-      return;
-    }
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GSF_rt_entry_lifetime = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_FOREVER_REL);
+  GSF_stats = GNUNET_STATISTICS_create ("fs", cfg);
+  block_cfg = GNUNET_CONFIGURATION_create ();
+  GSF_block_ctx = GNUNET_BLOCK_context_create (block_cfg);
+  GNUNET_assert (NULL != GSF_block_ctx);
+  GSF_dht = GNUNET_DHT_connect (cfg, FS_DHT_HT_SIZE);
+  GSF_plan_init ();
+  GSF_pending_request_init_ ();
+  GSF_connected_peer_init_ ();
+  GSF_ats = GNUNET_ATS_performance_init (GSF_cfg,
+                                         &update_latencies,
+                                         NULL);
+  GSF_push_init_ ();
+  GSF_put_init_ ();
+  if ((GNUNET_OK != GNUNET_FS_indexing_init (cfg,
+                                             GSF_dsh)) ||
+      (GNUNET_OK != main_init (cfg)))
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    shutdown_task (NULL);
+    return;
+  }
 }
 
 
@@ -1380,27 +1394,27 @@ GNUNET_SERVICE_MAIN
   &client_connect_cb,
   &client_disconnect_cb,
   NULL,
-  GNUNET_MQ_hd_var_size(client_index_start,
-                        GNUNET_MESSAGE_TYPE_FS_INDEX_START,
-                        struct IndexStartMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(client_index_list_get,
-                          GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET,
-                          struct GNUNET_MessageHeader,
-                          NULL),
-  GNUNET_MQ_hd_fixed_size(client_unindex,
-                          GNUNET_MESSAGE_TYPE_FS_UNINDEX,
-                          struct UnindexMessage,
-                          NULL),
-  GNUNET_MQ_hd_var_size(client_start_search,
-                        GNUNET_MESSAGE_TYPE_FS_START_SEARCH,
-                        struct SearchMessage,
-                        NULL),
-  GNUNET_MQ_hd_fixed_size(client_loc_sign,
-                          GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN,
-                          struct RequestLocSignatureMessage,
-                          NULL),
-  GNUNET_MQ_handler_end());
+  GNUNET_MQ_hd_var_size (client_index_start,
+                         GNUNET_MESSAGE_TYPE_FS_INDEX_START,
+                         struct IndexStartMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (client_index_list_get,
+                           GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET,
+                           struct GNUNET_MessageHeader,
+                           NULL),
+  GNUNET_MQ_hd_fixed_size (client_unindex,
+                           GNUNET_MESSAGE_TYPE_FS_UNINDEX,
+                           struct UnindexMessage,
+                           NULL),
+  GNUNET_MQ_hd_var_size (client_start_search,
+                         GNUNET_MESSAGE_TYPE_FS_START_SEARCH,
+                         struct SearchMessage,
+                         NULL),
+  GNUNET_MQ_hd_fixed_size (client_loc_sign,
+                           GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN,
+                           struct RequestLocSignatureMessage,
+                           NULL),
+  GNUNET_MQ_handler_end ());
 
 
 /* end of gnunet-service-fs.c */
diff --git a/src/fs/gnunet-service-fs.h b/src/fs/gnunet-service-fs.h
index 21a822c6d..9c87115ed 100644
--- a/src/fs/gnunet-service-fs.h
+++ b/src/fs/gnunet-service-fs.h
@@ -48,7 +48,8 @@
  * automatically (since if we don't use it, clearly the
  * load must be going down).
  */
-#define DATASTORE_LOAD_AUTODECLINE GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS, 250)
+#define DATASTORE_LOAD_AUTODECLINE GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MILLISECONDS, 250)
 
 /**
  * Only the (mandatory) query is included.
@@ -79,7 +80,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
 /**
  * Message sent between peers asking for FS-content.
  */
-struct GetMessage {
+struct GetMessage
+{
   /**
    * Message type will be #GNUNET_MESSAGE_TYPE_FS_GET.
    */
@@ -134,7 +136,8 @@ struct GetMessage {
  * Message send by a peer that wants to be excluded
  * from migration for a while.
  */
-struct MigrationStopMessage {
+struct MigrationStopMessage
+{
   /**
    * Message type will be
    * GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP.
@@ -275,9 +278,9 @@ extern unsigned int GSF_datastore_queue_size;
  * @param result final datastore lookup result
  */
 void
-GSF_consider_forwarding(void *cls,
-                        struct GSF_PendingRequest *pr,
-                        enum GNUNET_BLOCK_EvaluationResult result);
+GSF_consider_forwarding (void *cls,
+                         struct GSF_PendingRequest *pr,
+                         enum GNUNET_BLOCK_EvaluationResult result);
 
 
 /**
@@ -290,7 +293,7 @@ GSF_consider_forwarding(void *cls,
  *         #GNUNET_SYSERR to process for free (load low)
  */
 int
-GSF_test_get_load_too_high_(uint32_t priority);
+GSF_test_get_load_too_high_ (uint32_t priority);
 
 
 /**
@@ -300,7 +303,7 @@ GSF_test_get_load_too_high_(uint32_t priority);
  * @param start time when the datastore request was issued
  */
 void
-GSF_update_datastore_delay_(struct GNUNET_TIME_Absolute start);
+GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_cadet.h b/src/fs/gnunet-service-fs_cadet.h
index 61bd8b314..b8c255047 100644
--- a/src/fs/gnunet-service-fs_cadet.h
+++ b/src/fs/gnunet-service-fs_cadet.h
@@ -60,11 +60,11 @@ typedef void
  * @return handle to cancel the operation
  */
 struct GSF_CadetRequest *
-GSF_cadet_query(const struct GNUNET_PeerIdentity *target,
-                const struct GNUNET_HashCode *query,
-                enum GNUNET_BLOCK_Type type,
-                GSF_CadetReplyProcessor proc,
-                void *proc_cls);
+GSF_cadet_query (const struct GNUNET_PeerIdentity *target,
+                 const struct GNUNET_HashCode *query,
+                 enum GNUNET_BLOCK_Type type,
+                 GSF_CadetReplyProcessor proc,
+                 void *proc_cls);
 
 /**
  * Function called on each active cadets to shut them down.
@@ -75,9 +75,9 @@ GSF_cadet_query(const struct GNUNET_PeerIdentity *target,
  * @return #GNUNET_YES (continue to iterate)
  */
 int
-GSF_cadet_release_clients(void *cls,
-                          const struct GNUNET_PeerIdentity *key,
-                          void *value);
+GSF_cadet_release_clients (void *cls,
+                           const struct GNUNET_PeerIdentity *key,
+                           void *value);
 
 
 /**
@@ -87,21 +87,21 @@ GSF_cadet_release_clients(void *cls,
  * @param sr request to cancel
  */
 void
-GSF_cadet_query_cancel(struct GSF_CadetRequest *sr);
+GSF_cadet_query_cancel (struct GSF_CadetRequest *sr);
 
 
 /**
  * Initialize subsystem for non-anonymous file-sharing.
  */
 void
-GSF_cadet_start_server(void);
+GSF_cadet_start_server (void);
 
 
 /**
  * Shutdown subsystem for non-anonymous file-sharing.
  */
 void
-GSF_cadet_stop_server(void);
+GSF_cadet_stop_server (void);
 
 /**
  * Cadet channel for creating outbound channels.
@@ -120,7 +120,8 @@ GNUNET_NETWORK_STRUCT_BEGIN
 /**
  * Query from one peer, asking the other for CHK-data.
  */
-struct CadetQueryMessage {
+struct CadetQueryMessage
+{
   /**
    * Type is GNUNET_MESSAGE_TYPE_FS_CADET_QUERY.
    */
@@ -141,7 +142,8 @@ struct CadetQueryMessage {
 /**
  * Reply to a CadetQueryMessage.
  */
-struct CadetReplyMessage {
+struct CadetReplyMessage
+{
   /**
    * Type is GNUNET_MESSAGE_TYPE_FS_CADET_REPLY.
    */
diff --git a/src/fs/gnunet-service-fs_cadet_client.c b/src/fs/gnunet-service-fs_cadet_client.c
index a494ba751..96ccf8232 100644
--- a/src/fs/gnunet-service-fs_cadet_client.c
+++ b/src/fs/gnunet-service-fs_cadet_client.c
@@ -42,7 +42,7 @@
  * After how long do we reset connections without replies?
  */
 #define CLIENT_RETRY_TIMEOUT \
-  GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
+  GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
 
 
 /**
@@ -54,7 +54,8 @@ struct CadetHandle;
 /**
  * Handle for a request that is going out via cadet API.
  */
-struct GSF_CadetRequest {
+struct GSF_CadetRequest
+{
   /**
    * DLL.
    */
@@ -101,7 +102,8 @@ struct GSF_CadetRequest {
 /**
  * Handle for a cadet to another peer.
  */
-struct CadetHandle {
+struct CadetHandle
+{
   /**
    * Head of DLL of pending requests on this cadet.
    */
@@ -165,7 +167,7 @@ struct GNUNET_CONTAINER_MultiPeerMap *cadet_map;
  * @param cls `struct CadetHandle` to process
  */
 static void
-transmit_pending(void *cls);
+transmit_pending (void *cls);
 
 
 /**
@@ -178,15 +180,15 @@ transmit_pending(void *cls);
  * @return #GNUNET_YES (continue to iterate)
  */
 static int
-move_to_pending(void *cls, const struct GNUNET_HashCode *key, void *value)
+move_to_pending (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct CadetHandle *mh = cls;
   struct GSF_CadetRequest *sr = value;
 
-  GNUNET_assert(
+  GNUNET_assert (
     GNUNET_YES ==
-    GNUNET_CONTAINER_multihashmap_remove(mh->waiting_map, key, value));
-  GNUNET_CONTAINER_DLL_insert(mh->pending_head, mh->pending_tail, sr);
+    GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, key, value));
+  GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr);
   sr->was_transmitted = GNUNET_NO;
   return GNUNET_YES;
 }
@@ -201,7 +203,7 @@ move_to_pending(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @return #GNUNET_OK on success, #GNUNET_SYSERR to stop further processing
  */
 static int
-check_reply(void *cls, const struct CadetReplyMessage *srm)
+check_reply (void *cls, const struct CadetReplyMessage *srm)
 {
   /* We check later... */
   return GNUNET_OK;
@@ -214,7 +216,7 @@ check_reply(void *cls, const struct CadetReplyMessage *srm)
  * @param cls the `struct CadetHandle` to tear down
  */
 static void
-reset_cadet_task(void *cls);
+reset_cadet_task (void *cls);
 
 
 /**
@@ -224,18 +226,19 @@ reset_cadet_task(void *cls);
  * @param mh cadet to reset
  */
 static void
-reset_cadet_async(struct CadetHandle *mh)
+reset_cadet_async (struct CadetHandle *mh)
 {
   if (NULL != mh->reset_task)
-    GNUNET_SCHEDULER_cancel(mh->reset_task);
-  mh->reset_task = GNUNET_SCHEDULER_add_now(&reset_cadet_task, mh);
+    GNUNET_SCHEDULER_cancel (mh->reset_task);
+  mh->reset_task = GNUNET_SCHEDULER_add_now (&reset_cadet_task, mh);
 }
 
 
 /**
  * Closure for handle_reply().
  */
-struct HandleReplyClosure {
+struct HandleReplyClosure
+{
   /**
    * Reply payload.
    */
@@ -273,18 +276,18 @@ struct HandleReplyClosure {
  * @return #GNUNET_YES (continue to iterate)
  */
 static int
-process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
+process_reply (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct HandleReplyClosure *hrc = cls;
   struct GSF_CadetRequest *sr = value;
 
-  sr->proc(sr->proc_cls,
-           hrc->type,
-           hrc->expiration,
-           hrc->data_size,
-           hrc->data);
+  sr->proc (sr->proc_cls,
+            hrc->type,
+            hrc->expiration,
+            hrc->data_size,
+            hrc->data);
   sr->proc = NULL;
-  GSF_cadet_query_cancel(sr);
+  GSF_cadet_query_cancel (sr);
   hrc->found = GNUNET_YES;
   return GNUNET_YES;
 }
@@ -301,11 +304,11 @@ process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @return #GNUNET_YES (continue to iterate)
  */
 static int
-free_waiting_entry(void *cls, const struct GNUNET_HashCode *key, void *value)
+free_waiting_entry (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GSF_CadetRequest *sr = value;
 
-  GSF_cadet_query_cancel(sr);
+  GSF_cadet_query_cancel (sr);
   return GNUNET_YES;
 }
 
@@ -318,7 +321,7 @@ free_waiting_entry(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @param srm the actual message
  */
 static void
-handle_reply(void *cls, const struct CadetReplyMessage *srm)
+handle_reply (void *cls, const struct CadetReplyMessage *srm)
 {
   struct CadetHandle *mh = cls;
   struct HandleReplyClosure hrc;
@@ -326,47 +329,47 @@ handle_reply(void *cls, const struct CadetReplyMessage *srm)
   enum GNUNET_BLOCK_Type type;
   struct GNUNET_HashCode query;
 
-  msize = ntohs(srm->header.size) - sizeof(struct CadetReplyMessage);
-  type = (enum GNUNET_BLOCK_Type)ntohl(srm->type);
+  msize = ntohs (srm->header.size) - sizeof(struct CadetReplyMessage);
+  type = (enum GNUNET_BLOCK_Type) ntohl (srm->type);
   if (GNUNET_YES !=
-      GNUNET_BLOCK_get_key(GSF_block_ctx, type, &srm[1], msize, &query))
-    {
-      GNUNET_break_op(0);
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_WARNING,
-        "Received bogus reply of type %u with %u bytes via cadet from peer %s\n",
-        type,
-        msize,
-        GNUNET_i2s(&mh->target));
-      reset_cadet_async(mh);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received reply `%s' via cadet from peer %s\n",
-             GNUNET_h2s(&query),
-             GNUNET_i2s(&mh->target));
-  GNUNET_CADET_receive_done(mh->channel);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# replies received via cadet"),
-                           1,
-                           GNUNET_NO);
+      GNUNET_BLOCK_get_key (GSF_block_ctx, type, &srm[1], msize, &query))
+  {
+    GNUNET_break_op (0);
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_WARNING,
+      "Received bogus reply of type %u with %u bytes via cadet from peer %s\n",
+      type,
+      msize,
+      GNUNET_i2s (&mh->target));
+    reset_cadet_async (mh);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received reply `%s' via cadet from peer %s\n",
+              GNUNET_h2s (&query),
+              GNUNET_i2s (&mh->target));
+  GNUNET_CADET_receive_done (mh->channel);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# replies received via cadet"),
+                            1,
+                            GNUNET_NO);
   hrc.data = &srm[1];
   hrc.data_size = msize;
-  hrc.expiration = GNUNET_TIME_absolute_ntoh(srm->expiration);
+  hrc.expiration = GNUNET_TIME_absolute_ntoh (srm->expiration);
   hrc.type = type;
   hrc.found = GNUNET_NO;
-  GNUNET_CONTAINER_multihashmap_get_multiple(mh->waiting_map,
-                                             &query,
-                                             &process_reply,
-                                             &hrc);
+  GNUNET_CONTAINER_multihashmap_get_multiple (mh->waiting_map,
+                                              &query,
+                                              &process_reply,
+                                              &hrc);
   if (GNUNET_NO == hrc.found)
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop(
-                                 "# replies received via cadet dropped"),
-                               1,
-                               GNUNET_NO);
-    }
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# replies received via cadet dropped"),
+                              1,
+                              GNUNET_NO);
+  }
 }
 
 
@@ -378,34 +381,34 @@ handle_reply(void *cls, const struct CadetReplyMessage *srm)
  * @param channel channel of the disconnecting client
  */
 static void
-disconnect_cb(void *cls, const struct GNUNET_CADET_Channel *channel)
+disconnect_cb (void *cls, const struct GNUNET_CADET_Channel *channel)
 {
   struct CadetHandle *mh = cls;
   struct GSF_CadetRequest *sr;
 
   if (NULL == mh->channel)
     return; /* being destroyed elsewhere */
-  GNUNET_assert(channel == mh->channel);
+  GNUNET_assert (channel == mh->channel);
   mh->channel = NULL;
   while (NULL != (sr = mh->pending_head))
-    GSF_cadet_query_cancel(sr);
+    GSF_cadet_query_cancel (sr);
   /* first remove `mh` from the `cadet_map`, so that if the
      callback from `free_waiting_entry()` happens to re-issue
      the request, we don't immediately have it back in the
      `waiting_map`. */
-  GNUNET_assert(GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove(cadet_map,
-                                                                  &mh->target,
-                                                                  mh));
-  GNUNET_CONTAINER_multihashmap_iterate(mh->waiting_map,
-                                        &free_waiting_entry,
-                                        mh);
+  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multipeermap_remove (cadet_map,
+                                                                    &mh->target,
+                                                                    mh));
+  GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map,
+                                         &free_waiting_entry,
+                                         mh);
   if (NULL != mh->timeout_task)
-    GNUNET_SCHEDULER_cancel(mh->timeout_task);
+    GNUNET_SCHEDULER_cancel (mh->timeout_task);
   if (NULL != mh->reset_task)
-    GNUNET_SCHEDULER_cancel(mh->reset_task);
-  GNUNET_assert(0 == GNUNET_CONTAINER_multihashmap_size(mh->waiting_map));
-  GNUNET_CONTAINER_multihashmap_destroy(mh->waiting_map);
-  GNUNET_free(mh);
+    GNUNET_SCHEDULER_cancel (mh->reset_task);
+  GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map));
+  GNUNET_CONTAINER_multihashmap_destroy (mh->waiting_map);
+  GNUNET_free (mh);
 }
 
 
@@ -424,16 +427,16 @@ disconnect_cb(void *cls, const struct GNUNET_CADET_Channel *channel)
  *                    this value will be negative..
  */
 static void
-window_change_cb(void *cls,
-                 const struct GNUNET_CADET_Channel *channel,
-                 int window_size)
+window_change_cb (void *cls,
+                  const struct GNUNET_CADET_Channel *channel,
+                  int window_size)
 {
   /* FIXME: for flow control, implement? */
 #if 0
   /* Something like this instead of the GNUNET_MQ_notify_sent() in
      transmit_pending() might be good (once the window change CB works...) */
   if (0 < window_size) /* test needed? */
-    transmit_pending(mh);
+    transmit_pending (mh);
 #endif
 }
 
@@ -444,38 +447,38 @@ window_change_cb(void *cls,
  * @param mh cadet to reset
  */
 static void
-reset_cadet(struct CadetHandle *mh)
+reset_cadet (struct CadetHandle *mh)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Resetting cadet channel to %s\n",
-             GNUNET_i2s(&mh->target));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Resetting cadet channel to %s\n",
+              GNUNET_i2s (&mh->target));
   if (NULL != mh->channel)
-    {
-      GNUNET_CADET_channel_destroy(mh->channel);
-      mh->channel = NULL;
-    }
-  GNUNET_CONTAINER_multihashmap_iterate(mh->waiting_map, &move_to_pending, mh);
+  {
+    GNUNET_CADET_channel_destroy (mh->channel);
+    mh->channel = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (mh->waiting_map, &move_to_pending, mh);
   {
     struct GNUNET_MQ_MessageHandler handlers[] =
-    { GNUNET_MQ_hd_var_size(reply,
-                            GNUNET_MESSAGE_TYPE_FS_CADET_REPLY,
-                            struct CadetReplyMessage,
-                            mh),
-      GNUNET_MQ_handler_end() };
+    { GNUNET_MQ_hd_var_size (reply,
+                             GNUNET_MESSAGE_TYPE_FS_CADET_REPLY,
+                             struct CadetReplyMessage,
+                             mh),
+      GNUNET_MQ_handler_end () };
     struct GNUNET_HashCode port;
 
-    GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
-                       strlen(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
-                       &port);
-    mh->channel = GNUNET_CADET_channel_create(cadet_handle,
-                                              mh,
-                                              &mh->target,
-                                              &port,
-                                              &window_change_cb,
-                                              &disconnect_cb,
-                                              handlers);
+    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
+                        strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
+                        &port);
+    mh->channel = GNUNET_CADET_channel_create (cadet_handle,
+                                               mh,
+                                               &mh->target,
+                                               &port,
+                                               &window_change_cb,
+                                               &disconnect_cb,
+                                               handlers);
   }
-  transmit_pending(mh);
+  transmit_pending (mh);
 }
 
 
@@ -485,19 +488,19 @@ reset_cadet(struct CadetHandle *mh)
  * @param cls the `struct CadetHandle` to tear down
  */
 static void
-cadet_timeout(void *cls)
+cadet_timeout (void *cls)
 {
   struct CadetHandle *mh = cls;
   struct GNUNET_CADET_Channel *tun;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Timeout on cadet channel to %s\n",
-             GNUNET_i2s(&mh->target));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Timeout on cadet channel to %s\n",
+              GNUNET_i2s (&mh->target));
   mh->timeout_task = NULL;
   tun = mh->channel;
   mh->channel = NULL;
   if (NULL != tun)
-    GNUNET_CADET_channel_destroy(tun);
+    GNUNET_CADET_channel_destroy (tun);
 }
 
 
@@ -507,12 +510,12 @@ cadet_timeout(void *cls)
  * @param cls the `struct CadetHandle` to tear down
  */
 static void
-reset_cadet_task(void *cls)
+reset_cadet_task (void *cls)
 {
   struct CadetHandle *mh = cls;
 
   mh->reset_task = NULL;
-  reset_cadet(mh);
+  reset_cadet (mh);
 }
 
 
@@ -522,36 +525,36 @@ reset_cadet_task(void *cls)
  * @param cls `struct CadetHandle` to process
  */
 static void
-transmit_pending(void *cls)
+transmit_pending (void *cls)
 {
   struct CadetHandle *mh = cls;
-  struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq(mh->channel);
+  struct GNUNET_MQ_Handle *mq = GNUNET_CADET_get_mq (mh->channel);
   struct GSF_CadetRequest *sr;
   struct GNUNET_MQ_Envelope *env;
   struct CadetQueryMessage *sqm;
 
-  if ((0 != GNUNET_MQ_get_length(mq)) || (NULL == (sr = mh->pending_head)))
+  if ((0 != GNUNET_MQ_get_length (mq)) || (NULL == (sr = mh->pending_head)))
     return;
-  GNUNET_CONTAINER_DLL_remove(mh->pending_head, mh->pending_tail, sr);
-  GNUNET_assert(GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(
-                  mh->waiting_map,
-                  &sr->query,
-                  sr,
-                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr);
+  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (
+                   mh->waiting_map,
+                   &sr->query,
+                   sr,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
   sr->was_transmitted = GNUNET_YES;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Sending query for %s via cadet to %s\n",
-             GNUNET_h2s(&sr->query),
-             GNUNET_i2s(&mh->target));
-  env = GNUNET_MQ_msg(sqm, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY);
-  GNUNET_MQ_env_set_options(env,
-                            GNUNET_MQ_PREF_GOODPUT |
-                            GNUNET_MQ_PREF_CORK_ALLOWED |
-                            GNUNET_MQ_PREF_OUT_OF_ORDER);
-  sqm->type = htonl(sr->type);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Sending query for %s via cadet to %s\n",
+              GNUNET_h2s (&sr->query),
+              GNUNET_i2s (&mh->target));
+  env = GNUNET_MQ_msg (sqm, GNUNET_MESSAGE_TYPE_FS_CADET_QUERY);
+  GNUNET_MQ_env_set_options (env,
+                             GNUNET_MQ_PREF_GOODPUT
+                             | GNUNET_MQ_PREF_CORK_ALLOWED
+                             | GNUNET_MQ_PREF_OUT_OF_ORDER);
+  sqm->type = htonl (sr->type);
   sqm->query = sr->query;
-  GNUNET_MQ_notify_sent(env, &transmit_pending, mh);
-  GNUNET_MQ_send(mq, env);
+  GNUNET_MQ_notify_sent (env, &transmit_pending, mh);
+  GNUNET_MQ_send (mq, env);
 }
 
 
@@ -561,53 +564,53 @@ transmit_pending(void *cls)
  * @param target peer we want to communicate with
  */
 static struct CadetHandle *
-get_cadet(const struct GNUNET_PeerIdentity *target)
+get_cadet (const struct GNUNET_PeerIdentity *target)
 {
   struct CadetHandle *mh;
 
-  mh = GNUNET_CONTAINER_multipeermap_get(cadet_map, target);
+  mh = GNUNET_CONTAINER_multipeermap_get (cadet_map, target);
   if (NULL != mh)
+  {
+    if (NULL != mh->timeout_task)
     {
-      if (NULL != mh->timeout_task)
-        {
-          GNUNET_SCHEDULER_cancel(mh->timeout_task);
-          mh->timeout_task = NULL;
-        }
-      return mh;
+      GNUNET_SCHEDULER_cancel (mh->timeout_task);
+      mh->timeout_task = NULL;
     }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Creating cadet channel to %s\n",
-             GNUNET_i2s(target));
-  mh = GNUNET_new(struct CadetHandle);
+    return mh;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating cadet channel to %s\n",
+              GNUNET_i2s (target));
+  mh = GNUNET_new (struct CadetHandle);
   mh->reset_task =
-    GNUNET_SCHEDULER_add_delayed(CLIENT_RETRY_TIMEOUT, &reset_cadet_task, mh);
-  mh->waiting_map = GNUNET_CONTAINER_multihashmap_create(16, GNUNET_YES);
+    GNUNET_SCHEDULER_add_delayed (CLIENT_RETRY_TIMEOUT, &reset_cadet_task, mh);
+  mh->waiting_map = GNUNET_CONTAINER_multihashmap_create (16, GNUNET_YES);
   mh->target = *target;
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multipeermap_put(
-                  cadet_map,
-                  &mh->target,
-                  mh,
-                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multipeermap_put (
+                   cadet_map,
+                   &mh->target,
+                   mh,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   {
     struct GNUNET_MQ_MessageHandler handlers[] =
-    { GNUNET_MQ_hd_var_size(reply,
-                            GNUNET_MESSAGE_TYPE_FS_CADET_REPLY,
-                            struct CadetReplyMessage,
-                            mh),
-      GNUNET_MQ_handler_end() };
+    { GNUNET_MQ_hd_var_size (reply,
+                             GNUNET_MESSAGE_TYPE_FS_CADET_REPLY,
+                             struct CadetReplyMessage,
+                             mh),
+      GNUNET_MQ_handler_end () };
     struct GNUNET_HashCode port;
 
-    GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
-                       strlen(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
-                       &port);
-    mh->channel = GNUNET_CADET_channel_create(cadet_handle,
-                                              mh,
-                                              &mh->target,
-                                              &port,
-                                              &window_change_cb,
-                                              &disconnect_cb,
-                                              handlers);
+    GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
+                        strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
+                        &port);
+    mh->channel = GNUNET_CADET_channel_create (cadet_handle,
+                                               mh,
+                                               &mh->target,
+                                               &port,
+                                               &window_change_cb,
+                                               &disconnect_cb,
+                                               handlers);
   }
   return mh;
 }
@@ -624,28 +627,28 @@ get_cadet(const struct GNUNET_PeerIdentity *target)
  * @return handle to cancel the operation
  */
 struct GSF_CadetRequest *
-GSF_cadet_query(const struct GNUNET_PeerIdentity *target,
-                const struct GNUNET_HashCode *query,
-                enum GNUNET_BLOCK_Type type,
-                GSF_CadetReplyProcessor proc,
-                void *proc_cls)
+GSF_cadet_query (const struct GNUNET_PeerIdentity *target,
+                 const struct GNUNET_HashCode *query,
+                 enum GNUNET_BLOCK_Type type,
+                 GSF_CadetReplyProcessor proc,
+                 void *proc_cls)
 {
   struct CadetHandle *mh;
   struct GSF_CadetRequest *sr;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Preparing to send query for %s via cadet to %s\n",
-             GNUNET_h2s(query),
-             GNUNET_i2s(target));
-  mh = get_cadet(target);
-  sr = GNUNET_new(struct GSF_CadetRequest);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Preparing to send query for %s via cadet to %s\n",
+              GNUNET_h2s (query),
+              GNUNET_i2s (target));
+  mh = get_cadet (target);
+  sr = GNUNET_new (struct GSF_CadetRequest);
   sr->mh = mh;
   sr->proc = proc;
   sr->proc_cls = proc_cls;
   sr->type = type;
   sr->query = *query;
-  GNUNET_CONTAINER_DLL_insert(mh->pending_head, mh->pending_tail, sr);
-  transmit_pending(mh);
+  GNUNET_CONTAINER_DLL_insert (mh->pending_head, mh->pending_tail, sr);
+  transmit_pending (mh);
   return sr;
 }
 
@@ -657,7 +660,7 @@ GSF_cadet_query(const struct GNUNET_PeerIdentity *target,
  * @param sr request to cancel
  */
 void
-GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
+GSF_cadet_query_cancel (struct GSF_CadetRequest *sr)
 {
   struct CadetHandle *mh = sr->mh;
   GSF_CadetReplyProcessor p;
@@ -665,26 +668,26 @@ GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
   p = sr->proc;
   sr->proc = NULL;
   if (NULL != p)
-    {
-      /* signal failure / cancellation to callback */
-      p(sr->proc_cls, GNUNET_BLOCK_TYPE_ANY, GNUNET_TIME_UNIT_ZERO_ABS, 0, NULL);
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Cancelled query for %s via cadet to %s\n",
-             GNUNET_h2s(&sr->query),
-             GNUNET_i2s(&sr->mh->target));
+  {
+    /* signal failure / cancellation to callback */
+    p (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY, GNUNET_TIME_UNIT_ZERO_ABS, 0, NULL);
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cancelled query for %s via cadet to %s\n",
+              GNUNET_h2s (&sr->query),
+              GNUNET_i2s (&sr->mh->target));
   if (GNUNET_YES == sr->was_transmitted)
-    GNUNET_assert(
+    GNUNET_assert (
       GNUNET_OK ==
-      GNUNET_CONTAINER_multihashmap_remove(mh->waiting_map, &sr->query, sr));
+      GNUNET_CONTAINER_multihashmap_remove (mh->waiting_map, &sr->query, sr));
   else
-    GNUNET_CONTAINER_DLL_remove(mh->pending_head, mh->pending_tail, sr);
-  GNUNET_free(sr);
-  if ((0 == GNUNET_CONTAINER_multihashmap_size(mh->waiting_map)) &&
+    GNUNET_CONTAINER_DLL_remove (mh->pending_head, mh->pending_tail, sr);
+  GNUNET_free (sr);
+  if ((0 == GNUNET_CONTAINER_multihashmap_size (mh->waiting_map)) &&
       (NULL == mh->pending_head))
-    mh->timeout_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
-                                                    &cadet_timeout,
-                                                    mh);
+    mh->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                                     &cadet_timeout,
+                                                     mh);
 }
 
 
@@ -697,27 +700,27 @@ GSF_cadet_query_cancel(struct GSF_CadetRequest *sr)
  * @return #GNUNET_YES (continue to iterate)
  */
 int
-GSF_cadet_release_clients(void *cls,
-                          const struct GNUNET_PeerIdentity *key,
-                          void *value)
+GSF_cadet_release_clients (void *cls,
+                           const struct GNUNET_PeerIdentity *key,
+                           void *value)
 {
   struct CadetHandle *mh = value;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Timeout on cadet channel to %s\n",
-             GNUNET_i2s(&mh->target));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Timeout on cadet channel to %s\n",
+              GNUNET_i2s (&mh->target));
   if (NULL != mh->channel)
-    {
-      struct GNUNET_CADET_Channel *channel = mh->channel;
+  {
+    struct GNUNET_CADET_Channel *channel = mh->channel;
 
-      mh->channel = NULL;
-      GNUNET_CADET_channel_destroy(channel);
-    }
+    mh->channel = NULL;
+    GNUNET_CADET_channel_destroy (channel);
+  }
   if (NULL != mh->reset_task)
-    {
-      GNUNET_SCHEDULER_cancel(mh->reset_task);
-      mh->reset_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (mh->reset_task);
+    mh->reset_task = NULL;
+  }
   return GNUNET_YES;
 }
 
diff --git a/src/fs/gnunet-service-fs_cadet_server.c b/src/fs/gnunet-service-fs_cadet_server.c
index 68e87f092..34e4e6f58 100644
--- a/src/fs/gnunet-service-fs_cadet_server.c
+++ b/src/fs/gnunet-service-fs_cadet_server.c
@@ -40,13 +40,14 @@
 /**
  * After how long do we termiante idle connections?
  */
-#define IDLE_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2)
+#define IDLE_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 2)
 
 
 /**
  * A message in the queue to be written to the cadet.
  */
-struct WriteQueueItem {
+struct WriteQueueItem
+{
   /**
    * Kept in a DLL.
    */
@@ -67,7 +68,8 @@ struct WriteQueueItem {
 /**
  * Information we keep around for each active cadeting client.
  */
-struct CadetClient {
+struct CadetClient
+{
   /**
    * DLL
    */
@@ -101,12 +103,12 @@ struct CadetClient {
   /**
    * Task that is scheduled to asynchronously terminate the connection.
    */
-  struct GNUNET_SCHEDULER_Task * terminate_task;
+  struct GNUNET_SCHEDULER_Task *terminate_task;
 
   /**
    * Task that is scheduled to terminate idle connections.
    */
-  struct GNUNET_SCHEDULER_Task * timeout_task;
+  struct GNUNET_SCHEDULER_Task *timeout_task;
 
   /**
    * Size of the last write that was initiated.
@@ -148,7 +150,7 @@ static unsigned long long sc_count_max;
  * @param cls the 'struct CadetClient'
  */
 static void
-timeout_cadet_task(void *cls)
+timeout_cadet_task (void *cls)
 {
   struct CadetClient *sc = cls;
   struct GNUNET_CADET_Channel *tun;
@@ -156,10 +158,10 @@ timeout_cadet_task(void *cls)
   sc->timeout_task = NULL;
   tun = sc->channel;
   sc->channel = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Timeout for inactive cadet client %p\n",
-             sc);
-  GNUNET_CADET_channel_destroy(tun);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Timeout for inactive cadet client %p\n",
+              sc);
+  GNUNET_CADET_channel_destroy (tun);
 }
 
 
@@ -169,13 +171,13 @@ timeout_cadet_task(void *cls)
  * @param sc client handle to reset timeout for
  */
 static void
-refresh_timeout_task(struct CadetClient *sc)
+refresh_timeout_task (struct CadetClient *sc)
 {
   if (NULL != sc->timeout_task)
-    GNUNET_SCHEDULER_cancel(sc->timeout_task);
-  sc->timeout_task = GNUNET_SCHEDULER_add_delayed(IDLE_TIMEOUT,
-                                                  &timeout_cadet_task,
-                                                  sc);
+    GNUNET_SCHEDULER_cancel (sc->timeout_task);
+  sc->timeout_task = GNUNET_SCHEDULER_add_delayed (IDLE_TIMEOUT,
+                                                   &timeout_cadet_task,
+                                                   sc);
 }
 
 
@@ -186,23 +188,23 @@ refresh_timeout_task(struct CadetClient *sc)
  * @param cls where to process the write queue
  */
 static void
-continue_writing(void *cls)
+continue_writing (void *cls)
 {
   struct CadetClient *sc = cls;
   struct GNUNET_MQ_Handle *mq;
 
-  mq = GNUNET_CADET_get_mq(sc->channel);
-  if (0 != GNUNET_MQ_get_length(mq))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Write pending, waiting for it to complete\n");
-      return;
-    }
-  refresh_timeout_task(sc);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Finished processing cadet request from client %p, ready to receive the next one\n",
-             sc);
-  GNUNET_CADET_receive_done(sc->channel);
+  mq = GNUNET_CADET_get_mq (sc->channel);
+  if (0 != GNUNET_MQ_get_length (mq))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Write pending, waiting for it to complete\n");
+    return;
+  }
+  refresh_timeout_task (sc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finished processing cadet request from client %p, ready to receive the next one\n",
+              sc);
+  GNUNET_CADET_receive_done (sc->channel);
 }
 
 
@@ -222,16 +224,16 @@ continue_writing(void *cls)
  *        maybe 0 if no unique identifier is available
  */
 static void
-handle_datastore_reply(void *cls,
-                       const struct GNUNET_HashCode *key,
-                       size_t size,
-                       const void *data,
-                       enum GNUNET_BLOCK_Type type,
-                       uint32_t priority,
-                       uint32_t anonymity,
-                       uint32_t replication,
-                       struct GNUNET_TIME_Absolute expiration,
-                       uint64_t uid)
+handle_datastore_reply (void *cls,
+                        const struct GNUNET_HashCode *key,
+                        size_t size,
+                        const void *data,
+                        enum GNUNET_BLOCK_Type type,
+                        uint32_t priority,
+                        uint32_t anonymity,
+                        uint32_t replication,
+                        struct GNUNET_TIME_Absolute expiration,
+                        uint64_t uid)
 {
   struct CadetClient *sc = cls;
   size_t msize = size + sizeof(struct CadetReplyMessage);
@@ -240,85 +242,86 @@ handle_datastore_reply(void *cls,
 
   sc->qe = NULL;
   if (NULL == data)
+  {
+    /* no result, this should not really happen, as for
+       non-anonymous routing only peers that HAVE the
+       answers should be queried; OTOH, this is not a
+       hard error as we might have had the answer in the
+       past and the user might have unindexed it. Hence
+       we log at level "INFO" for now. */
+    if (NULL == key)
     {
-      /* no result, this should not really happen, as for
-         non-anonymous routing only peers that HAVE the
-         answers should be queried; OTOH, this is not a
-         hard error as we might have had the answer in the
-         past and the user might have unindexed it. Hence
-         we log at level "INFO" for now. */
-      if (NULL == key)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     "Have no answer and the query was NULL\n");
-        }
-      else
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-                     "Have no answer for query `%s'\n",
-                     GNUNET_h2s(key));
-        }
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# queries received via CADET not answered"),
-                               1,
-                               GNUNET_NO);
-      continue_writing(sc);
-      return;
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Have no answer and the query was NULL\n");
     }
-  if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
+    else
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Performing on-demand encoding for query %s\n",
-                 GNUNET_h2s(key));
-      if (GNUNET_OK !=
-          GNUNET_FS_handle_on_demand_block(key,
-                                           size,
-                                           data,
-                                           type,
-                                           priority,
-                                           anonymity,
-                                           replication,
-                                           expiration,
-                                           uid,
-                                           &handle_datastore_reply,
-                                           sc))
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "On-demand encoding request failed\n");
-          continue_writing(sc);
-        }
-      return;
+      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                  "Have no answer for query `%s'\n",
+                  GNUNET_h2s (key));
     }
-  if (msize > GNUNET_MAX_MESSAGE_SIZE)
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# queries received via CADET not answered"),
+                              1,
+                              GNUNET_NO);
+    continue_writing (sc);
+    return;
+  }
+  if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Performing on-demand encoding for query %s\n",
+                GNUNET_h2s (key));
+    if (GNUNET_OK !=
+        GNUNET_FS_handle_on_demand_block (key,
+                                          size,
+                                          data,
+                                          type,
+                                          priority,
+                                          anonymity,
+                                          replication,
+                                          expiration,
+                                          uid,
+                                          &handle_datastore_reply,
+                                          sc))
     {
-      GNUNET_break(0);
-      continue_writing(sc);
-      return;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "On-demand encoding request failed\n");
+      continue_writing (sc);
     }
-  GNUNET_break(GNUNET_BLOCK_TYPE_ANY != type);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Starting transmission of %u byte reply of type %d for query `%s' via cadet to %p\n",
-             (unsigned int)size,
-             (unsigned int)type,
-             GNUNET_h2s(key),
-             sc);
-  env = GNUNET_MQ_msg_extra(srm,
-                            size,
-                            GNUNET_MESSAGE_TYPE_FS_CADET_REPLY);
-  srm->type = htonl(type);
-  srm->expiration = GNUNET_TIME_absolute_hton(expiration);
-  GNUNET_memcpy(&srm[1],
-                data,
-                size);
-  GNUNET_MQ_notify_sent(env,
-                        &continue_writing,
-                        sc);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Blocks transferred via cadet"),
-                           1,
-                           GNUNET_NO);
-  GNUNET_MQ_send(GNUNET_CADET_get_mq(sc->channel),
-                 env);
+    return;
+  }
+  if (msize > GNUNET_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    continue_writing (sc);
+    return;
+  }
+  GNUNET_break (GNUNET_BLOCK_TYPE_ANY != type);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Starting transmission of %u byte reply of type %d for query `%s' via cadet to %p\n",
+              (unsigned int) size,
+              (unsigned int) type,
+              GNUNET_h2s (key),
+              sc);
+  env = GNUNET_MQ_msg_extra (srm,
+                             size,
+                             GNUNET_MESSAGE_TYPE_FS_CADET_REPLY);
+  srm->type = htonl (type);
+  srm->expiration = GNUNET_TIME_absolute_hton (expiration);
+  GNUNET_memcpy (&srm[1],
+                 data,
+                 size);
+  GNUNET_MQ_notify_sent (env,
+                         &continue_writing,
+                         sc);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Blocks transferred via cadet"),
+                            1,
+                            GNUNET_NO);
+  GNUNET_MQ_send (GNUNET_CADET_get_mq (sc->channel),
+                  env);
 }
 
 
@@ -330,35 +333,35 @@ handle_datastore_reply(void *cls,
  * @param sqm the actual message
  */
 static void
-handle_request(void *cls,
-               const struct CadetQueryMessage *sqm)
+handle_request (void *cls,
+                const struct CadetQueryMessage *sqm)
 {
   struct CadetClient *sc = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received query for `%s' via cadet from client %p\n",
-             GNUNET_h2s(&sqm->query),
-             sc);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# queries received via cadet"),
-                           1,
-                           GNUNET_NO);
-  refresh_timeout_task(sc);
-  sc->qe = GNUNET_DATASTORE_get_key(GSF_dsh,
-                                    0 /* next_uid */,
-                                    false /* random */,
-                                    &sqm->query,
-                                    ntohl(sqm->type),
-                                    0 /* priority */,
-                                    GSF_datastore_queue_size,
-                                    &handle_datastore_reply,
-                                    sc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received query for `%s' via cadet from client %p\n",
+              GNUNET_h2s (&sqm->query),
+              sc);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# queries received via cadet"),
+                            1,
+                            GNUNET_NO);
+  refresh_timeout_task (sc);
+  sc->qe = GNUNET_DATASTORE_get_key (GSF_dsh,
+                                     0 /* next_uid */,
+                                     false /* random */,
+                                     &sqm->query,
+                                     ntohl (sqm->type),
+                                     0 /* priority */,
+                                     GSF_datastore_queue_size,
+                                     &handle_datastore_reply,
+                                     sc);
   if (NULL == sc->qe)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Queueing request with datastore failed (queue full?)\n");
-      continue_writing(sc);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Queueing request with datastore failed (queue full?)\n");
+    continue_writing (sc);
+  }
 }
 
 
@@ -372,37 +375,38 @@ handle_request(void *cls,
  * @return initial channel context (our `struct CadetClient`)
  */
 static void *
-connect_cb(void *cls,
-           struct GNUNET_CADET_Channel *channel,
-           const struct GNUNET_PeerIdentity *initiator)
+connect_cb (void *cls,
+            struct GNUNET_CADET_Channel *channel,
+            const struct GNUNET_PeerIdentity *initiator)
 {
   struct CadetClient *sc;
 
-  GNUNET_assert(NULL != channel);
+  GNUNET_assert (NULL != channel);
   if (sc_count >= sc_count_max)
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# cadet client connections rejected"),
-                               1,
-                               GNUNET_NO);
-      GNUNET_CADET_channel_destroy(channel);
-      return NULL;
-    }
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# cadet connections active"),
-                           1,
-                           GNUNET_NO);
-  sc = GNUNET_new(struct CadetClient);
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# cadet client connections rejected"),
+                              1,
+                              GNUNET_NO);
+    GNUNET_CADET_channel_destroy (channel);
+    return NULL;
+  }
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# cadet connections active"),
+                            1,
+                            GNUNET_NO);
+  sc = GNUNET_new (struct CadetClient);
   sc->channel = channel;
-  GNUNET_CONTAINER_DLL_insert(sc_head,
-                              sc_tail,
-                              sc);
+  GNUNET_CONTAINER_DLL_insert (sc_head,
+                               sc_tail,
+                               sc);
   sc_count++;
-  refresh_timeout_task(sc);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Accepting inbound cadet connection from `%s' as client %p\n",
-             GNUNET_i2s(initiator),
-             sc);
+  refresh_timeout_task (sc);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Accepting inbound cadet connection from `%s' as client %p\n",
+              GNUNET_i2s (initiator),
+              sc);
   return sc;
 }
 
@@ -416,8 +420,8 @@ connect_cb(void *cls,
  * @param channel_ctx
  */
 static void
-disconnect_cb(void *cls,
-              const struct GNUNET_CADET_Channel *channel)
+disconnect_cb (void *cls,
+               const struct GNUNET_CADET_Channel *channel)
 {
   struct CadetClient *sc = cls;
   struct WriteQueueItem *wqi;
@@ -425,30 +429,30 @@ disconnect_cb(void *cls,
   if (NULL == sc)
     return;
   sc->channel = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Terminating cadet connection with client %p\n",
-             sc);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# cadet connections active"), -1,
-                           GNUNET_NO);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Terminating cadet connection with client %p\n",
+              sc);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# cadet connections active"), -1,
+                            GNUNET_NO);
   if (NULL != sc->terminate_task)
-    GNUNET_SCHEDULER_cancel(sc->terminate_task);
+    GNUNET_SCHEDULER_cancel (sc->terminate_task);
   if (NULL != sc->timeout_task)
-    GNUNET_SCHEDULER_cancel(sc->timeout_task);
+    GNUNET_SCHEDULER_cancel (sc->timeout_task);
   if (NULL != sc->qe)
-    GNUNET_DATASTORE_cancel(sc->qe);
+    GNUNET_DATASTORE_cancel (sc->qe);
   while (NULL != (wqi = sc->wqi_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(sc->wqi_head,
-                                  sc->wqi_tail,
-                                  wqi);
-      GNUNET_free(wqi);
-    }
-  GNUNET_CONTAINER_DLL_remove(sc_head,
-                              sc_tail,
-                              sc);
+  {
+    GNUNET_CONTAINER_DLL_remove (sc->wqi_head,
+                                 sc->wqi_tail,
+                                 wqi);
+    GNUNET_free (wqi);
+  }
+  GNUNET_CONTAINER_DLL_remove (sc_head,
+                               sc_tail,
+                               sc);
   sc_count--;
-  GNUNET_free(sc);
+  GNUNET_free (sc);
 }
 
 
@@ -467,9 +471,9 @@ disconnect_cb(void *cls,
  *                    this value will be negative..
  */
 static void
-window_change_cb(void *cls,
-                 const struct GNUNET_CADET_Channel *channel,
-                 int window_size)
+window_change_cb (void *cls,
+                  const struct GNUNET_CADET_Channel *channel,
+                  int window_size)
 {
   /* FIXME: could do flow control here... */
 }
@@ -479,39 +483,39 @@ window_change_cb(void *cls,
  * Initialize subsystem for non-anonymous file-sharing.
  */
 void
-GSF_cadet_start_server()
+GSF_cadet_start_server ()
 {
   struct GNUNET_MQ_MessageHandler handlers[] = {
-    GNUNET_MQ_hd_fixed_size(request,
-                            GNUNET_MESSAGE_TYPE_FS_CADET_QUERY,
-                            struct CadetQueryMessage,
-                            NULL),
-    GNUNET_MQ_handler_end()
+    GNUNET_MQ_hd_fixed_size (request,
+                             GNUNET_MESSAGE_TYPE_FS_CADET_QUERY,
+                             struct CadetQueryMessage,
+                             NULL),
+    GNUNET_MQ_handler_end ()
   };
   struct GNUNET_HashCode port;
 
   if (GNUNET_YES !=
-      GNUNET_CONFIGURATION_get_value_number(GSF_cfg,
-                                            "fs",
-                                            "MAX_CADET_CLIENTS",
-                                            &sc_count_max))
+      GNUNET_CONFIGURATION_get_value_number (GSF_cfg,
+                                             "fs",
+                                             "MAX_CADET_CLIENTS",
+                                             &sc_count_max))
     return;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Initializing cadet FS server with a limit of %llu connections\n",
-             sc_count_max);
-  cadet_map = GNUNET_CONTAINER_multipeermap_create(16, GNUNET_YES);
-  cadet_handle = GNUNET_CADET_connect(GSF_cfg);
-  GNUNET_assert(NULL != cadet_handle);
-  GNUNET_CRYPTO_hash(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
-                     strlen(GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
-                     &port);
-  cadet_port = GNUNET_CADET_open_port(cadet_handle,
-                                      &port,
-                                      &connect_cb,
-                                      NULL,
-                                      &window_change_cb,
-                                      &disconnect_cb,
-                                      handlers);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Initializing cadet FS server with a limit of %llu connections\n",
+              sc_count_max);
+  cadet_map = GNUNET_CONTAINER_multipeermap_create (16, GNUNET_YES);
+  cadet_handle = GNUNET_CADET_connect (GSF_cfg);
+  GNUNET_assert (NULL != cadet_handle);
+  GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER,
+                      strlen (GNUNET_APPLICATION_PORT_FS_BLOCK_TRANSFER),
+                      &port);
+  cadet_port = GNUNET_CADET_open_port (cadet_handle,
+                                       &port,
+                                       &connect_cb,
+                                       NULL,
+                                       &window_change_cb,
+                                       &disconnect_cb,
+                                       handlers);
 }
 
 
@@ -519,25 +523,25 @@ GSF_cadet_start_server()
  * Shutdown subsystem for non-anonymous file-sharing.
  */
 void
-GSF_cadet_stop_server()
+GSF_cadet_stop_server ()
 {
-  GNUNET_CONTAINER_multipeermap_iterate(cadet_map,
-                                        &GSF_cadet_release_clients,
-                                        NULL);
-  GNUNET_CONTAINER_multipeermap_destroy(cadet_map);
+  GNUNET_CONTAINER_multipeermap_iterate (cadet_map,
+                                         &GSF_cadet_release_clients,
+                                         NULL);
+  GNUNET_CONTAINER_multipeermap_destroy (cadet_map);
   cadet_map = NULL;
   if (NULL != cadet_port)
-    {
-      GNUNET_CADET_close_port(cadet_port);
-      cadet_port = NULL;
-    }
+  {
+    GNUNET_CADET_close_port (cadet_port);
+    cadet_port = NULL;
+  }
   if (NULL != cadet_handle)
-    {
-      GNUNET_CADET_disconnect(cadet_handle);
-      cadet_handle = NULL;
-    }
-  GNUNET_assert(NULL == sc_head);
-  GNUNET_assert(0 == sc_count);
+  {
+    GNUNET_CADET_disconnect (cadet_handle);
+    cadet_handle = NULL;
+  }
+  GNUNET_assert (NULL == sc_head);
+  GNUNET_assert (0 == sc_count);
 }
 
 /* end of gnunet-service-fs_cadet.c */
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index 6dab37869..dca8ae2a8 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -43,12 +43,14 @@
 /**
  * How often do we flush respect values to disk?
  */
-#define RESPECT_FLUSH_FREQ GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
+#define RESPECT_FLUSH_FREQ GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MINUTES, 5)
 
 /**
  * After how long do we discard a reply?
  */
-#define REPLY_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2)
+#define REPLY_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, \
+                                                     2)
 
 /**
  * Collect an instane number of statistics?  May cause excessive IPC.
@@ -59,7 +61,8 @@
 /**
  * Handle to cancel a transmission request.
  */
-struct GSF_PeerTransmitHandle {
+struct GSF_PeerTransmitHandle
+{
   /**
    * Kept in a doubly-linked list.
    */
@@ -105,7 +108,8 @@ struct GSF_PeerTransmitHandle {
 /**
  * Handle for an entry in our delay list.
  */
-struct GSF_DelayedHandle {
+struct GSF_DelayedHandle
+{
   /**
    * Kept in a doubly-linked list.
    */
@@ -141,7 +145,8 @@ struct GSF_DelayedHandle {
 /**
  * Information per peer and request.
  */
-struct PeerRequest {
+struct PeerRequest
+{
   /**
    * Handle to generic request (generic: from peer or local client).
    */
@@ -162,7 +167,8 @@ struct PeerRequest {
 /**
  * A connected peer.
  */
-struct GSF_ConnectedPeer {
+struct GSF_ConnectedPeer
+{
   /**
    * Performance data for this peer.
    */
@@ -293,16 +299,16 @@ static struct GNUNET_SCHEDULER_Task *fr_task;
  * @param latency current latency value
  */
 void
-GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id,
-                         struct GNUNET_TIME_Relative latency)
+GSF_update_peer_latency_ (const struct GNUNET_PeerIdentity *id,
+                          struct GNUNET_TIME_Relative latency)
 {
   struct GSF_ConnectedPeer *cp;
 
-  cp = GSF_peer_get_(id);
+  cp = GSF_peer_get_ (id);
   if (NULL == cp)
     return; /* we're not yet connected at the core level, ignore */
-  GNUNET_LOAD_value_set_decline(cp->ppd.transmission_delay,
-                                latency);
+  GNUNET_LOAD_value_set_decline (cp->ppd.transmission_delay,
+                                 latency);
 }
 
 
@@ -313,7 +319,7 @@ GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id,
  * @return performance data record for the peer
  */
 struct GSF_PeerPerformanceData *
-GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp)
+GSF_get_peer_performance_data_ (struct GSF_ConnectedPeer *cp)
 {
   return &cp->ppd;
 }
@@ -325,7 +331,7 @@ GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp)
  * @param cp which peer to send a message to
  */
 static void
-peer_transmit(struct GSF_ConnectedPeer *cp);
+peer_transmit (struct GSF_ConnectedPeer *cp);
 
 
 /**
@@ -339,10 +345,10 @@ peer_transmit(struct GSF_ConnectedPeer *cp);
  *        long should the client wait until re-trying?
  */
 static void
-ats_reserve_callback(void *cls,
-                     const struct GNUNET_PeerIdentity *peer,
-                     int32_t amount,
-                     struct GNUNET_TIME_Relative res_delay);
+ats_reserve_callback (void *cls,
+                      const struct GNUNET_PeerIdentity *peer,
+                      int32_t amount,
+                      struct GNUNET_TIME_Relative res_delay);
 
 
 /**
@@ -352,42 +358,42 @@ ats_reserve_callback(void *cls,
  * @param pth transmission handle to schedule
  */
 static void
-schedule_transmission(struct GSF_PeerTransmitHandle *pth)
+schedule_transmission (struct GSF_PeerTransmitHandle *pth)
 {
   struct GSF_ConnectedPeer *cp;
   struct GNUNET_PeerIdentity target;
 
   cp = pth->cp;
-  GNUNET_assert(0 != cp->ppd.pid);
-  GNUNET_PEER_resolve(cp->ppd.pid, &target);
+  GNUNET_assert (0 != cp->ppd.pid);
+  GNUNET_PEER_resolve (cp->ppd.pid, &target);
 
   if (0 != cp->inc_preference)
-    {
-      GNUNET_ATS_performance_change_preference(GSF_ats,
-                                               &target,
-                                               GNUNET_ATS_PREFERENCE_BANDWIDTH,
-                                               (double)cp->inc_preference,
-                                               GNUNET_ATS_PREFERENCE_END);
-      cp->inc_preference = 0;
-    }
+  {
+    GNUNET_ATS_performance_change_preference (GSF_ats,
+                                              &target,
+                                              GNUNET_ATS_PREFERENCE_BANDWIDTH,
+                                              (double) cp->inc_preference,
+                                              GNUNET_ATS_PREFERENCE_END);
+    cp->inc_preference = 0;
+  }
 
   if ((GNUNET_YES == pth->is_query) &&
       (GNUNET_YES != pth->was_reserved))
-    {
-      /* query, need reservation */
-      if (GNUNET_YES != cp->did_reserve)
-        return;                 /* not ready */
-      cp->did_reserve = GNUNET_NO;
-      /* reservation already done! */
-      pth->was_reserved = GNUNET_YES;
-      cp->rc = GNUNET_ATS_reserve_bandwidth(GSF_ats,
-                                            &target,
-                                            DBLOCK_SIZE,
-                                            &ats_reserve_callback,
-                                            cp);
-      return;
-    }
-  peer_transmit(cp);
+  {
+    /* query, need reservation */
+    if (GNUNET_YES != cp->did_reserve)
+      return;                   /* not ready */
+    cp->did_reserve = GNUNET_NO;
+    /* reservation already done! */
+    pth->was_reserved = GNUNET_YES;
+    cp->rc = GNUNET_ATS_reserve_bandwidth (GSF_ats,
+                                           &target,
+                                           DBLOCK_SIZE,
+                                           &ats_reserve_callback,
+                                           cp);
+    return;
+  }
+  peer_transmit (cp);
 }
 
 
@@ -397,38 +403,38 @@ schedule_transmission(struct GSF_PeerTransmitHandle *pth)
  * @param cp which peer to send a message to
  */
 static void
-peer_transmit(struct GSF_ConnectedPeer *cp)
+peer_transmit (struct GSF_ConnectedPeer *cp)
 {
   struct GSF_PeerTransmitHandle *pth = cp->pth_head;
   struct GSF_PeerTransmitHandle *pos;
 
   if (NULL == pth)
     return;
-  GNUNET_CONTAINER_DLL_remove(cp->pth_head,
-                              cp->pth_tail,
-                              pth);
+  GNUNET_CONTAINER_DLL_remove (cp->pth_head,
+                               cp->pth_tail,
+                               pth);
   if (GNUNET_YES == pth->is_query)
-    {
-      cp->ppd.last_request_times[(cp->last_request_times_off++) %
-                                 MAX_QUEUE_PER_PEER] =
-        GNUNET_TIME_absolute_get();
-      GNUNET_assert(0 < cp->ppd.pending_queries--);
-    }
+  {
+    cp->ppd.last_request_times[(cp->last_request_times_off++)
+                               % MAX_QUEUE_PER_PEER] =
+      GNUNET_TIME_absolute_get ();
+    GNUNET_assert (0 < cp->ppd.pending_queries--);
+  }
   else if (GNUNET_NO == pth->is_query)
-    {
-      GNUNET_assert(0 < cp->ppd.pending_replies--);
-    }
-  GNUNET_LOAD_update(cp->ppd.transmission_delay,
-                     GNUNET_TIME_absolute_get_duration
-                       (pth->transmission_request_start_time).rel_value_us);
-  GNUNET_MQ_send(cp->mq,
-                 pth->env);
-  GNUNET_free(pth);
+  {
+    GNUNET_assert (0 < cp->ppd.pending_replies--);
+  }
+  GNUNET_LOAD_update (cp->ppd.transmission_delay,
+                      GNUNET_TIME_absolute_get_duration
+                        (pth->transmission_request_start_time).rel_value_us);
+  GNUNET_MQ_send (cp->mq,
+                  pth->env);
+  GNUNET_free (pth);
   if (NULL != (pos = cp->pth_head))
-    {
-      GNUNET_assert(pos != pth);
-      schedule_transmission(pos);
-    }
+  {
+    GNUNET_assert (pos != pth);
+    schedule_transmission (pos);
+  }
 }
 
 
@@ -438,18 +444,18 @@ peer_transmit(struct GSF_ConnectedPeer *cp)
  * @param cls the `struct GSF_ConnectedPeer` to reserve from
  */
 static void
-retry_reservation(void *cls)
+retry_reservation (void *cls)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GNUNET_PeerIdentity target;
 
-  GNUNET_PEER_resolve(cp->ppd.pid, &target);
+  GNUNET_PEER_resolve (cp->ppd.pid, &target);
   cp->rc_delay_task = NULL;
   cp->rc =
-    GNUNET_ATS_reserve_bandwidth(GSF_ats,
-                                 &target,
-                                 DBLOCK_SIZE,
-                                 &ats_reserve_callback, cp);
+    GNUNET_ATS_reserve_bandwidth (GSF_ats,
+                                  &target,
+                                  DBLOCK_SIZE,
+                                  &ats_reserve_callback, cp);
 }
 
 
@@ -464,34 +470,34 @@ retry_reservation(void *cls)
  *        long should the client wait until re-trying?
  */
 static void
-ats_reserve_callback(void *cls,
-                     const struct GNUNET_PeerIdentity *peer,
-                     int32_t amount,
-                     struct GNUNET_TIME_Relative res_delay)
+ats_reserve_callback (void *cls,
+                      const struct GNUNET_PeerIdentity *peer,
+                      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 %s for reservation\n",
-             (int)amount,
-             GNUNET_STRINGS_relative_time_to_string(res_delay, GNUNET_YES));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Reserved %d bytes / need to wait %s for reservation\n",
+              (int) amount,
+              GNUNET_STRINGS_relative_time_to_string (res_delay, GNUNET_YES));
   cp->rc = NULL;
   if (0 == amount)
-    {
-      cp->rc_delay_task =
-        GNUNET_SCHEDULER_add_delayed(res_delay,
-                                     &retry_reservation,
-                                     cp);
-      return;
-    }
+  {
+    cp->rc_delay_task =
+      GNUNET_SCHEDULER_add_delayed (res_delay,
+                                    &retry_reservation,
+                                    cp);
+    return;
+  }
   cp->did_reserve = GNUNET_YES;
   pth = cp->pth_head;
   if (NULL != pth)
-    {
-      /* reservation success, try transmission now! */
-      peer_transmit(cp);
-    }
+  {
+    /* reservation success, try transmission now! */
+    peer_transmit (cp);
+  }
 }
 
 
@@ -503,22 +509,22 @@ ats_reserve_callback(void *cls,
  * @param emsg error message, or NULL if no errors
  */
 static void
-peer_respect_cb(void *cls,
-                const struct GNUNET_PEERSTORE_Record *record,
-                const char *emsg)
+peer_respect_cb (void *cls,
+                 const struct GNUNET_PEERSTORE_Record *record,
+                 const char *emsg)
 {
   struct GSF_ConnectedPeer *cp = cls;
 
-  GNUNET_assert(NULL != cp->respect_iterate_req);
+  GNUNET_assert (NULL != cp->respect_iterate_req);
   if ((NULL != record) &&
       (sizeof(cp->disk_respect) == record->value_size))
-    {
-      cp->disk_respect = *((uint32_t *)record->value);
-      cp->ppd.respect += *((uint32_t *)record->value);
-    }
-  GSF_push_start_(cp);
+  {
+    cp->disk_respect = *((uint32_t *) record->value);
+    cp->ppd.respect += *((uint32_t *) record->value);
+  }
+  GSF_push_start_ (cp);
   if (NULL != record)
-    GNUNET_PEERSTORE_iterate_cancel(cp->respect_iterate_req);
+    GNUNET_PEERSTORE_iterate_cancel (cp->respect_iterate_req);
   cp->respect_iterate_req = NULL;
 }
 
@@ -534,27 +540,27 @@ peer_respect_cb(void *cls,
  * @return #GNUNET_YES to continue to iterate
  */
 static int
-consider_peer_for_forwarding(void *cls,
-                             const struct GNUNET_HashCode *key,
-                             struct GSF_PendingRequest *pr)
+consider_peer_for_forwarding (void *cls,
+                              const struct GNUNET_HashCode *key,
+                              struct GSF_PendingRequest *pr)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GNUNET_PeerIdentity pid;
 
   if (GNUNET_YES !=
-      GSF_pending_request_test_active_(pr))
+      GSF_pending_request_test_active_ (pr))
     return GNUNET_YES; /* request is not actually active, skip! */
-  GSF_connected_peer_get_identity_(cp, &pid);
+  GSF_connected_peer_get_identity_ (cp, &pid);
   if (GNUNET_YES !=
-      GSF_pending_request_test_target_(pr, &pid))
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# Loopback routes suppressed"),
-                               1,
-                               GNUNET_NO);
-      return GNUNET_YES;
-    }
-  GSF_plan_add_(cp, pr);
+      GSF_pending_request_test_target_ (pr, &pid))
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# Loopback routes suppressed"),
+                              1,
+                              GNUNET_NO);
+    return GNUNET_YES;
+  }
+  GSF_plan_add_ (cp, pr);
   return GNUNET_YES;
 }
 
@@ -569,49 +575,50 @@ consider_peer_for_forwarding(void *cls,
  * @return our internal handle for the peer
  */
 void *
-GSF_peer_connect_handler(void *cls,
-                         const struct GNUNET_PeerIdentity *peer,
-                         struct GNUNET_MQ_Handle *mq)
+GSF_peer_connect_handler (void *cls,
+                          const struct GNUNET_PeerIdentity *peer,
+                          struct GNUNET_MQ_Handle *mq)
 {
   struct GSF_ConnectedPeer *cp;
 
   if (0 ==
-      GNUNET_memcmp(&GSF_my_id,
-                    peer))
+      GNUNET_memcmp (&GSF_my_id,
+                     peer))
     return NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Connected to peer %s\n",
-             GNUNET_i2s(peer));
-  cp = GNUNET_new(struct GSF_ConnectedPeer);
-  cp->ppd.pid = GNUNET_PEER_intern(peer);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Connected to peer %s\n",
+              GNUNET_i2s (peer));
+  cp = GNUNET_new (struct GSF_ConnectedPeer);
+  cp->ppd.pid = GNUNET_PEER_intern (peer);
   cp->ppd.peer = peer;
   cp->mq = mq;
-  cp->ppd.transmission_delay = GNUNET_LOAD_value_init(GNUNET_TIME_UNIT_ZERO);
+  cp->ppd.transmission_delay = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_ZERO);
   cp->rc =
-    GNUNET_ATS_reserve_bandwidth(GSF_ats,
-                                 peer,
-                                 DBLOCK_SIZE,
-                                 &ats_reserve_callback, cp);
-  cp->request_map = GNUNET_CONTAINER_multihashmap_create(128,
-                                                         GNUNET_YES);
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_CONTAINER_multipeermap_put(cp_map,
-                                                 GSF_connected_peer_get_identity2_(cp),
-                                                 cp,
-                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  GNUNET_STATISTICS_set(GSF_stats,
-                        gettext_noop("# peers connected"),
-                        GNUNET_CONTAINER_multipeermap_size(cp_map),
-                        GNUNET_NO);
+    GNUNET_ATS_reserve_bandwidth (GSF_ats,
+                                  peer,
+                                  DBLOCK_SIZE,
+                                  &ats_reserve_callback, cp);
+  cp->request_map = GNUNET_CONTAINER_multihashmap_create (128,
+                                                          GNUNET_YES);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONTAINER_multipeermap_put (cp_map,
+                                                   GSF_connected_peer_get_identity2_ (
+                                                     cp),
+                                                   cp,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  GNUNET_STATISTICS_set (GSF_stats,
+                         gettext_noop ("# peers connected"),
+                         GNUNET_CONTAINER_multipeermap_size (cp_map),
+                         GNUNET_NO);
   cp->respect_iterate_req
-    = GNUNET_PEERSTORE_iterate(peerstore,
-                               "fs",
-                               peer,
-                               "respect",
-                               &peer_respect_cb,
-                               cp);
-  GSF_iterate_pending_requests_(&consider_peer_for_forwarding,
+    = GNUNET_PEERSTORE_iterate (peerstore,
+                                "fs",
+                                peer,
+                                "respect",
+                                &peer_respect_cb,
                                 cp);
+  GSF_iterate_pending_requests_ (&consider_peer_for_forwarding,
+                                 cp);
   return cp;
 }
 
@@ -623,21 +630,21 @@ GSF_peer_connect_handler(void *cls,
  * @param cls the `struct GSF_ConnectedPeer`
  */
 static void
-revive_migration(void *cls)
+revive_migration (void *cls)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GNUNET_TIME_Relative bt;
 
   cp->mig_revive_task = NULL;
-  bt = GNUNET_TIME_absolute_get_remaining(cp->ppd.migration_blocked_until);
+  bt = GNUNET_TIME_absolute_get_remaining (cp->ppd.migration_blocked_until);
   if (0 != bt.rel_value_us)
-    {
-      /* still time left... */
-      cp->mig_revive_task =
-        GNUNET_SCHEDULER_add_delayed(bt, &revive_migration, cp);
-      return;
-    }
-  GSF_push_start_(cp);
+  {
+    /* still time left... */
+    cp->mig_revive_task =
+      GNUNET_SCHEDULER_add_delayed (bt, &revive_migration, cp);
+    return;
+  }
+  GSF_push_start_ (cp);
 }
 
 
@@ -648,11 +655,11 @@ revive_migration(void *cls)
  * @return NULL if the peer is not currently connected
  */
 struct GSF_ConnectedPeer *
-GSF_peer_get_(const struct GNUNET_PeerIdentity *peer)
+GSF_peer_get_ (const struct GNUNET_PeerIdentity *peer)
 {
   if (NULL == cp_map)
     return NULL;
-  return GNUNET_CONTAINER_multipeermap_get(cp_map, peer);
+  return GNUNET_CONTAINER_multipeermap_get (cp_map, peer);
 }
 
 
@@ -663,29 +670,29 @@ GSF_peer_get_(const struct GNUNET_PeerIdentity *peer)
  * @param msm the actual message
  */
 void
-handle_p2p_migration_stop(void *cls,
-                          const struct MigrationStopMessage *msm)
+handle_p2p_migration_stop (void *cls,
+                           const struct MigrationStopMessage *msm)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GNUNET_TIME_Relative bt;
 
-  GNUNET_STATISTICS_update(GSF_stats,
-                           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 %s\n"),
-             GNUNET_i2s(cp->ppd.peer),
-             GNUNET_STRINGS_relative_time_to_string(bt, GNUNET_YES));
-  cp->ppd.migration_blocked_until = GNUNET_TIME_relative_to_absolute(bt);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            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 %s\n"),
+              GNUNET_i2s (cp->ppd.peer),
+              GNUNET_STRINGS_relative_time_to_string (bt, GNUNET_YES));
+  cp->ppd.migration_blocked_until = GNUNET_TIME_relative_to_absolute (bt);
   if ((NULL == cp->mig_revive_task) &&
       (NULL == cp->respect_iterate_req))
-    {
-      GSF_push_stop_(cp);
-      cp->mig_revive_task =
-        GNUNET_SCHEDULER_add_delayed(bt,
-                                     &revive_migration, cp);
-    }
+  {
+    GSF_push_stop_ (cp);
+    cp->mig_revive_task =
+      GNUNET_SCHEDULER_add_delayed (bt,
+                                    &revive_migration, cp);
+  }
 }
 
 
@@ -695,26 +702,26 @@ handle_p2p_migration_stop(void *cls,
  * @param peerreq request to free
  */
 static void
-free_pending_request(struct PeerRequest *peerreq)
+free_pending_request (struct PeerRequest *peerreq)
 {
   struct GSF_ConnectedPeer *cp = peerreq->cp;
   struct GSF_PendingRequestData *prd;
 
-  prd = GSF_pending_request_get_data_(peerreq->pr);
+  prd = GSF_pending_request_get_data_ (peerreq->pr);
   if (NULL != peerreq->kill_task)
-    {
-      GNUNET_SCHEDULER_cancel(peerreq->kill_task);
-      peerreq->kill_task = NULL;
-    }
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# P2P searches active"),
-                           -1,
-                           GNUNET_NO);
-  GNUNET_break(GNUNET_YES ==
-               GNUNET_CONTAINER_multihashmap_remove(cp->request_map,
-                                                    &prd->query,
-                                                    peerreq));
-  GNUNET_free(peerreq);
+  {
+    GNUNET_SCHEDULER_cancel (peerreq->kill_task);
+    peerreq->kill_task = NULL;
+  }
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# P2P searches active"),
+                            -1,
+                            GNUNET_NO);
+  GNUNET_break (GNUNET_YES ==
+                GNUNET_CONTAINER_multihashmap_remove (cp->request_map,
+                                                      &prd->query,
+                                                      peerreq));
+  GNUNET_free (peerreq);
 }
 
 
@@ -727,16 +734,16 @@ free_pending_request(struct PeerRequest *peerreq)
  * @return #GNUNET_YES (continue to iterate)
  */
 static int
-cancel_pending_request(void *cls,
-                       const struct GNUNET_HashCode *query,
-                       void *value)
+cancel_pending_request (void *cls,
+                        const struct GNUNET_HashCode *query,
+                        void *value)
 {
   struct PeerRequest *peerreq = value;
   struct GSF_PendingRequest *pr = peerreq->pr;
 
-  free_pending_request(peerreq);
-  GSF_pending_request_cancel_(pr,
-                              GNUNET_NO);
+  free_pending_request (peerreq);
+  GSF_pending_request_cancel_ (pr,
+                               GNUNET_NO);
   return GNUNET_OK;
 }
 
@@ -747,17 +754,17 @@ cancel_pending_request(void *cls,
  * @param cls the request to free
  */
 static void
-peer_request_destroy(void *cls)
+peer_request_destroy (void *cls)
 {
   struct PeerRequest *peerreq = cls;
   struct GSF_PendingRequest *pr = peerreq->pr;
   struct GSF_PendingRequestData *prd;
 
   peerreq->kill_task = NULL;
-  prd = GSF_pending_request_get_data_(pr);
-  cancel_pending_request(NULL,
-                         &prd->query,
-                         peerreq);
+  prd = GSF_pending_request_get_data_ (pr);
+  cancel_pending_request (NULL,
+                          &prd->query,
+                          peerreq);
 }
 
 
@@ -767,20 +774,20 @@ peer_request_destroy(void *cls)
  * @param cls the `struct GSF_DelayedHandle` with the message
  */
 static void
-transmit_delayed_now(void *cls)
+transmit_delayed_now (void *cls)
 {
   struct GSF_DelayedHandle *dh = cls;
   struct GSF_ConnectedPeer *cp = dh->cp;
 
-  GNUNET_CONTAINER_DLL_remove(cp->delayed_head,
-                              cp->delayed_tail,
-                              dh);
+  GNUNET_CONTAINER_DLL_remove (cp->delayed_head,
+                               cp->delayed_tail,
+                               dh);
   cp->delay_queue_size--;
-  GSF_peer_transmit_(cp,
-                     GNUNET_NO,
-                     UINT32_MAX,
-                     dh->env);
-  GNUNET_free(dh);
+  GSF_peer_transmit_ (cp,
+                      GNUNET_NO,
+                      UINT32_MAX,
+                      dh->env);
+  GNUNET_free (dh);
 }
 
 
@@ -790,20 +797,20 @@ transmit_delayed_now(void *cls)
  * @return desired delay
  */
 static struct GNUNET_TIME_Relative
-get_randomized_delay()
+get_randomized_delay ()
 {
   struct GNUNET_TIME_Relative ret;
 
   ret =
-    GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MILLISECONDS,
-                                  GNUNET_CRYPTO_random_u32
-                                    (GNUNET_CRYPTO_QUALITY_WEAK,
-                                    2 * GSF_avg_latency.rel_value_us + 1));
+    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+                                   GNUNET_CRYPTO_random_u32
+                                     (GNUNET_CRYPTO_QUALITY_WEAK,
+                                     2 * GSF_avg_latency.rel_value_us + 1));
 #if INSANE_STATISTICS
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop
-                             ("# artificial delays introduced (ms)"),
-                           ret.rel_value_us / 1000LL, GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop
+                              ("# artificial delays introduced (ms)"),
+                            ret.rel_value_us / 1000LL, GNUNET_NO);
 #endif
   return ret;
 }
@@ -828,15 +835,15 @@ get_randomized_delay()
  * @param data_len number of bytes in @a data
  */
 static void
-handle_p2p_reply(void *cls,
-                 enum GNUNET_BLOCK_EvaluationResult eval,
-                 struct GSF_PendingRequest *pr,
-                 uint32_t reply_anonymity_level,
-                 struct GNUNET_TIME_Absolute expiration,
-                 struct GNUNET_TIME_Absolute last_transmission,
-                 enum GNUNET_BLOCK_Type type,
-                 const void *data,
-                 size_t data_len)
+handle_p2p_reply (void *cls,
+                  enum GNUNET_BLOCK_EvaluationResult eval,
+                  struct GSF_PendingRequest *pr,
+                  uint32_t reply_anonymity_level,
+                  struct GNUNET_TIME_Absolute expiration,
+                  struct GNUNET_TIME_Absolute last_transmission,
+                  enum GNUNET_BLOCK_Type type,
+                  const void *data,
+                  size_t data_len)
 {
   struct PeerRequest *peerreq = cls;
   struct GSF_ConnectedPeer *cp = peerreq->cp;
@@ -845,96 +852,98 @@ handle_p2p_reply(void *cls,
   struct PutMessage *pm;
   size_t msize;
 
-  GNUNET_assert(data_len + sizeof(struct PutMessage) <
-                GNUNET_MAX_MESSAGE_SIZE);
-  GNUNET_assert(peerreq->pr == pr);
-  prd = GSF_pending_request_get_data_(pr);
+  GNUNET_assert (data_len + sizeof(struct PutMessage) <
+                 GNUNET_MAX_MESSAGE_SIZE);
+  GNUNET_assert (peerreq->pr == pr);
+  prd = GSF_pending_request_get_data_ (pr);
   if (NULL == data)
-    {
-      free_pending_request(peerreq);
-      return;
-    }
-  GNUNET_break(GNUNET_BLOCK_TYPE_ANY != type);
+  {
+    free_pending_request (peerreq);
+    return;
+  }
+  GNUNET_break (GNUNET_BLOCK_TYPE_ANY != type);
   if ((prd->type != type) && (GNUNET_BLOCK_TYPE_ANY != prd->type))
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# replies dropped due to type mismatch"),
-                               1, GNUNET_NO);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Transmitting result for query `%s' to peer\n",
-             GNUNET_h2s(&prd->query));
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# replies received for other peers"),
-                           1, GNUNET_NO);
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                                ("# replies dropped due to type mismatch"),
+                              1, GNUNET_NO);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Transmitting result for query `%s' to peer\n",
+              GNUNET_h2s (&prd->query));
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# replies received for other peers"),
+                            1, GNUNET_NO);
   msize = sizeof(struct PutMessage) + data_len;
   if (msize >= GNUNET_MAX_MESSAGE_SIZE)
-    {
-      GNUNET_break(0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   if ((UINT32_MAX != reply_anonymity_level) && (reply_anonymity_level > 1))
+  {
+    if (reply_anonymity_level - 1 > GSF_cover_content_count)
     {
-      if (reply_anonymity_level - 1 > GSF_cover_content_count)
-        {
-          GNUNET_STATISTICS_update(GSF_stats,
-                                   gettext_noop
-                                     ("# replies dropped due to insufficient cover traffic"),
-                                   1, GNUNET_NO);
-          return;
-        }
-      GSF_cover_content_count -= (reply_anonymity_level - 1);
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop
+                                (
+                                  "# replies dropped due to insufficient cover traffic"),
+                                1, GNUNET_NO);
+      return;
     }
-
-  env = GNUNET_MQ_msg_extra(pm,
-                            data_len,
-                            GNUNET_MESSAGE_TYPE_FS_PUT);
-  pm->type = htonl(type);
-  pm->expiration = GNUNET_TIME_absolute_hton(expiration);
-  GNUNET_memcpy(&pm[1],
-                data,
-                data_len);
+    GSF_cover_content_count -= (reply_anonymity_level - 1);
+  }
+
+  env = GNUNET_MQ_msg_extra (pm,
+                             data_len,
+                             GNUNET_MESSAGE_TYPE_FS_PUT);
+  pm->type = htonl (type);
+  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
+  GNUNET_memcpy (&pm[1],
+                 data,
+                 data_len);
   if ((UINT32_MAX != reply_anonymity_level) &&
       (0 != reply_anonymity_level) &&
       (GNUNET_YES == GSF_enable_randomized_delays))
-    {
-      struct GSF_DelayedHandle *dh;
-
-      dh = GNUNET_new(struct GSF_DelayedHandle);
-      dh->cp = cp;
-      dh->env = env;
-      dh->msize = msize;
-      GNUNET_CONTAINER_DLL_insert(cp->delayed_head,
-                                  cp->delayed_tail,
-                                  dh);
-      cp->delay_queue_size++;
-      dh->delay_task =
-        GNUNET_SCHEDULER_add_delayed(get_randomized_delay(),
-                                     &transmit_delayed_now,
-                                     dh);
-    }
+  {
+    struct GSF_DelayedHandle *dh;
+
+    dh = GNUNET_new (struct GSF_DelayedHandle);
+    dh->cp = cp;
+    dh->env = env;
+    dh->msize = msize;
+    GNUNET_CONTAINER_DLL_insert (cp->delayed_head,
+                                 cp->delayed_tail,
+                                 dh);
+    cp->delay_queue_size++;
+    dh->delay_task =
+      GNUNET_SCHEDULER_add_delayed (get_randomized_delay (),
+                                    &transmit_delayed_now,
+                                    dh);
+  }
   else
-    {
-      GSF_peer_transmit_(cp,
-                         GNUNET_NO,
-                         UINT32_MAX,
-                         env);
-    }
+  {
+    GSF_peer_transmit_ (cp,
+                        GNUNET_NO,
+                        UINT32_MAX,
+                        env);
+  }
   if (GNUNET_BLOCK_EVALUATION_OK_LAST != eval)
     return;
   if (NULL == peerreq->kill_task)
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# P2P searches destroyed due to ultimate reply"),
-                               1,
-                               GNUNET_NO);
-      peerreq->kill_task =
-        GNUNET_SCHEDULER_add_now(&peer_request_destroy,
-                                 peerreq);
-    }
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              (
+                                "# P2P searches destroyed due to ultimate reply"),
+                              1,
+                              GNUNET_NO);
+    peerreq->kill_task =
+      GNUNET_SCHEDULER_add_now (&peer_request_destroy,
+                                peerreq);
+  }
 }
 
 
@@ -947,31 +956,31 @@ handle_p2p_reply(void *cls,
  * @returns the actual change in respect (positive or negative)
  */
 static int
-change_peer_respect(struct GSF_ConnectedPeer *cp, int value)
+change_peer_respect (struct GSF_ConnectedPeer *cp, int value)
 {
   if (0 == value)
     return 0;
-  GNUNET_assert(NULL != cp);
+  GNUNET_assert (NULL != cp);
   if (value > 0)
+  {
+    if (cp->ppd.respect + value < cp->ppd.respect)
     {
-      if (cp->ppd.respect + value < cp->ppd.respect)
-        {
-          value = UINT32_MAX - cp->ppd.respect;
-          cp->ppd.respect = UINT32_MAX;
-        }
-      else
-        cp->ppd.respect += value;
+      value = UINT32_MAX - cp->ppd.respect;
+      cp->ppd.respect = UINT32_MAX;
     }
+    else
+      cp->ppd.respect += value;
+  }
   else
+  {
+    if (cp->ppd.respect < -value)
     {
-      if (cp->ppd.respect < -value)
-        {
-          value = -cp->ppd.respect;
-          cp->ppd.respect = 0;
-        }
-      else
-        cp->ppd.respect += value;
+      value = -cp->ppd.respect;
+      cp->ppd.respect = 0;
     }
+    else
+      cp->ppd.respect += value;
+  }
   return value;
 }
 
@@ -985,58 +994,59 @@ change_peer_respect(struct GSF_ConnectedPeer *cp, int value)
  * @return effective priority
  */
 static int32_t
-bound_priority(uint32_t prio_in,
-               struct GSF_ConnectedPeer *cp)
+bound_priority (uint32_t prio_in,
+                struct GSF_ConnectedPeer *cp)
 {
-#define N ((double)128.0)
+#define N ((double) 128.0)
   uint32_t ret;
   double rret;
   int ld;
 
-  ld = GSF_test_get_load_too_high_(0);
+  ld = GSF_test_get_load_too_high_ (0);
   if (GNUNET_SYSERR == ld)
-    {
+  {
 #if INSANE_STATISTICS
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# requests done for free (low load)"), 1,
-                               GNUNET_NO);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                                ("# requests done for free (low load)"), 1,
+                              GNUNET_NO);
 #endif
-      return 0;                 /* excess resources */
-    }
+    return 0;                   /* excess resources */
+  }
   if (prio_in > INT32_MAX)
     prio_in = INT32_MAX;
-  ret = -change_peer_respect(cp, -(int)prio_in);
+  ret = -change_peer_respect (cp, -(int) prio_in);
   if (ret > 0)
-    {
-      if (ret > GSF_current_priorities + N)
-        rret = GSF_current_priorities + N;
-      else
-        rret = ret;
-      GSF_current_priorities = (GSF_current_priorities * (N - 1) + rret) / N;
-    }
+  {
+    if (ret > GSF_current_priorities + N)
+      rret = GSF_current_priorities + N;
+    else
+      rret = ret;
+    GSF_current_priorities = (GSF_current_priorities * (N - 1) + rret) / N;
+  }
   if ((GNUNET_YES == ld) && (ret > 0))
-    {
-      /* try with charging */
-      ld = GSF_test_get_load_too_high_(ret);
-    }
+  {
+    /* try with charging */
+    ld = GSF_test_get_load_too_high_ (ret);
+  }
   if (GNUNET_YES == ld)
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# request dropped, priority insufficient"), 1,
-                               GNUNET_NO);
-      /* undo charge */
-      change_peer_respect(cp, (int)ret);
-      return -1;                /* not enough resources */
-    }
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                                ("# request dropped, priority insufficient"), 1,
+                              GNUNET_NO);
+    /* undo charge */
+    change_peer_respect (cp, (int) ret);
+    return -1;                  /* not enough resources */
+  }
   else
-    {
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# requests done for a price (normal load)"), 1,
-                               GNUNET_NO);
-    }
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                                ("# requests done for a price (normal load)"),
+                              1,
+                              GNUNET_NO);
+  }
 #undef N
   return ret;
 }
@@ -1052,20 +1062,20 @@ bound_priority(uint32_t prio_in,
  *         otherwise the ttl-limit for the given @a prio
  */
 static int32_t
-bound_ttl(int32_t ttl_in,
-          uint32_t prio)
+bound_ttl (int32_t ttl_in,
+           uint32_t prio)
 {
   unsigned long long allowed;
 
   if (ttl_in <= 0)
     return ttl_in;
-  allowed = ((unsigned long long)prio) * TTL_DECREMENT / 1000;
+  allowed = ((unsigned long long) prio) * TTL_DECREMENT / 1000;
   if (ttl_in > allowed)
-    {
-      if (allowed >= (1 << 30))
-        return 1 << 30;
-      return allowed;
-    }
+  {
+    if (allowed >= (1 << 30))
+      return 1 << 30;
+    return allowed;
+  }
   return ttl_in;
 }
 
@@ -1073,7 +1083,8 @@ bound_ttl(int32_t ttl_in,
 /**
  * Closure for #test_exist_cb().
  */
-struct TestExistClosure {
+struct TestExistClosure
+{
   /**
    * Priority of the incoming request.
    */
@@ -1107,9 +1118,9 @@ struct TestExistClosure {
  *         #GNUNET_NO if we successfully merged
  */
 static int
-test_exist_cb(void *cls,
-              const struct GNUNET_HashCode *hc,
-              void *value)
+test_exist_cb (void *cls,
+               const struct GNUNET_HashCode *hc,
+               void *value)
 {
   struct TestExistClosure *tec = cls;
   struct PeerRequest *peerreq = value;
@@ -1117,28 +1128,28 @@ test_exist_cb(void *cls,
   struct GSF_PendingRequestData *prd;
 
   pr = peerreq->pr;
-  prd = GSF_pending_request_get_data_(pr);
+  prd = GSF_pending_request_get_data_ (pr);
   if (prd->type != tec->type)
     return GNUNET_YES;
   if (prd->ttl.abs_value_us >=
-      GNUNET_TIME_absolute_get().abs_value_us + tec->ttl * 1000LL)
-    {
-      /* existing request has higher TTL, drop new one! */
-      prd->priority += tec->priority;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Have existing request with higher TTL, dropping new request.\n");
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# requests dropped due to higher-TTL request"),
-                               1, GNUNET_NO);
-      tec->finished = GNUNET_YES;
-      return GNUNET_NO;
-    }
+      GNUNET_TIME_absolute_get ().abs_value_us + tec->ttl * 1000LL)
+  {
+    /* existing request has higher TTL, drop new one! */
+    prd->priority += tec->priority;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Have existing request with higher TTL, dropping new request.\n");
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                                ("# requests dropped due to higher-TTL request"),
+                              1, GNUNET_NO);
+    tec->finished = GNUNET_YES;
+    return GNUNET_NO;
+  }
   /* existing request has lower TTL, drop old one! */
   tec->priority += prd->priority;
-  free_pending_request(peerreq);
-  GSF_pending_request_cancel_(pr,
-                              GNUNET_YES);
+  free_pending_request (peerreq);
+  GSF_pending_request_cancel_ (pr,
+                               GNUNET_YES);
   return GNUNET_NO;
 }
 
@@ -1153,8 +1164,8 @@ test_exist_cb(void *cls,
  * @param gm the GET message
  */
 void
-handle_p2p_get(void *cls,
-               const struct GetMessage *gm)
+handle_p2p_get (void *cls,
+                const struct GetMessage *gm)
 {
   struct GSF_ConnectedPeer *cps = cls;
   struct PeerRequest *peerreq;
@@ -1172,167 +1183,172 @@ handle_p2p_get(void *cls,
   GNUNET_PEER_Id spid;
   const struct GSF_PendingRequestData *prd;
 
-  msize = ntohs(gm->header.size);
-  tec.type = ntohl(gm->type);
-  bm = ntohl(gm->hash_bitmap);
+  msize = ntohs (gm->header.size);
+  tec.type = ntohl (gm->type);
+  bm = ntohl (gm->hash_bitmap);
   bits = 0;
   while (bm > 0)
-    {
-      if (1 == (bm & 1))
-        bits++;
-      bm >>= 1;
-    }
-  opt = (const struct GNUNET_PeerIdentity *)&gm[1];
-  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct GNUNET_PeerIdentity);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop
-                             ("# GET requests received (from other peers)"),
-                           1,
-                           GNUNET_NO);
+  {
+    if (1 == (bm & 1))
+      bits++;
+    bm >>= 1;
+  }
+  opt = (const struct GNUNET_PeerIdentity *) &gm[1];
+  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
+                                                             GNUNET_PeerIdentity);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop
+                              ("# GET requests received (from other peers)"),
+                            1,
+                            GNUNET_NO);
   GSF_cover_query_count++;
-  bm = ntohl(gm->hash_bitmap);
+  bm = ntohl (gm->hash_bitmap);
   bits = 0;
   if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
-    cp = GSF_peer_get_(&opt[bits++]);
+    cp = GSF_peer_get_ (&opt[bits++]);
   else
     cp = cps;
   if (NULL == cp)
-    {
-      if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                   "Failed to find RETURN-TO peer `%s' in connection set. Dropping query.\n",
-                   GNUNET_i2s(&opt[bits - 1]));
-
-      else
-        GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                   "Failed to find peer `%s' in connection set. Dropping query.\n",
-                   GNUNET_i2s(cps->ppd.peer));
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# requests dropped due to missing reverse route"),
-                               1,
-                               GNUNET_NO);
-      return;
-    }
-  unsigned int queue_size = GNUNET_MQ_get_length(cp->mq);
+  {
+    if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Failed to find RETURN-TO peer `%s' in connection set. Dropping query.\n",
+                  GNUNET_i2s (&opt[bits - 1]));
+
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Failed to find peer `%s' in connection set. Dropping query.\n",
+                  GNUNET_i2s (cps->ppd.peer));
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              (
+                                "# requests dropped due to missing reverse route"),
+                              1,
+                              GNUNET_NO);
+    return;
+  }
+  unsigned int queue_size = GNUNET_MQ_get_length (cp->mq);
   queue_size += cp->ppd.pending_replies + cp->delay_queue_size;
   if (queue_size > MAX_QUEUE_PER_PEER)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Peer `%s' has too many replies queued already. Dropping query.\n",
-                 GNUNET_i2s(cps->ppd.peer));
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# requests dropped due to full reply queue"),
-                               1,
-                               GNUNET_NO);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Peer `%s' has too many replies queued already. Dropping query.\n",
+                GNUNET_i2s (cps->ppd.peer));
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# requests dropped due to full reply queue"),
+                              1,
+                              GNUNET_NO);
+    return;
+  }
   /* note that we can really only check load here since otherwise
    * peers could find out that we are overloaded by not being
    * disconnected after sending us a malformed query... */
-  tec.priority = bound_priority(ntohl(gm->priority),
-                                cps);
+  tec.priority = bound_priority (ntohl (gm->priority),
+                                 cps);
   if (tec.priority < 0)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Dropping query from `%s', this peer is too busy.\n",
-                 GNUNET_i2s(cps->ppd.peer));
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received request for `%s' of type %u from peer `%s' with flags %u\n",
-             GNUNET_h2s(&gm->query),
-             (unsigned int)tec.type,
-             GNUNET_i2s(cps->ppd.peer),
-             (unsigned int)bm);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Dropping query from `%s', this peer is too busy.\n",
+                GNUNET_i2s (cps->ppd.peer));
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received request for `%s' of type %u from peer `%s' with flags %u\n",
+              GNUNET_h2s (&gm->query),
+              (unsigned int) tec.type,
+              GNUNET_i2s (cps->ppd.peer),
+              (unsigned int) bm);
   target =
     (0 !=
      (bm & GET_MESSAGE_BIT_TRANSMIT_TO)) ? (&opt[bits++]) : NULL;
   options = GSF_PRO_DEFAULTS;
   spid = 0;
-  if ((GNUNET_LOAD_get_load(cp->ppd.transmission_delay) > 3 * (1 + tec.priority))
-      || (GNUNET_LOAD_get_average(cp->ppd.transmission_delay) >
-          GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value_us * 2 +
-          GNUNET_LOAD_get_average(GSF_rt_entry_lifetime)))
-    {
-      /* don't have BW to send to peer, or would likely take longer than we have for it,
-       * so at best indirect the query */
-      tec.priority = 0;
-      options |= GSF_PRO_FORWARD_ONLY;
-      spid = GNUNET_PEER_intern(cps->ppd.peer);
-      GNUNET_assert(0 != spid);
-    }
-  tec.ttl = bound_ttl(ntohl(gm->ttl),
-                      tec.priority);
+  if ((GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1
+                                                                + tec.priority))
+      || (GNUNET_LOAD_get_average (cp->ppd.transmission_delay) >
+          GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value_us * 2
+          + GNUNET_LOAD_get_average (GSF_rt_entry_lifetime)))
+  {
+    /* don't have BW to send to peer, or would likely take longer than we have for it,
+     * so at best indirect the query */
+    tec.priority = 0;
+    options |= GSF_PRO_FORWARD_ONLY;
+    spid = GNUNET_PEER_intern (cps->ppd.peer);
+    GNUNET_assert (0 != spid);
+  }
+  tec.ttl = bound_ttl (ntohl (gm->ttl),
+                       tec.priority);
   /* decrement ttl (always) */
   ttl_decrement =
-    2 * TTL_DECREMENT + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                                 TTL_DECREMENT);
+    2 * TTL_DECREMENT + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                  TTL_DECREMENT);
   if ((tec.ttl < 0) &&
-      (((int32_t)(tec.ttl - ttl_decrement)) > 0))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
-                 GNUNET_i2s(cps->ppd.peer),
-                 tec.ttl,
-                 ttl_decrement);
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop
-                                 ("# requests dropped due TTL underflow"), 1,
-                               GNUNET_NO);
-      /* integer underflow => drop (should be very rare)! */
-      return;
-    }
+      (((int32_t) (tec.ttl - ttl_decrement)) > 0))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
+                GNUNET_i2s (cps->ppd.peer),
+                tec.ttl,
+                ttl_decrement);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                                ("# requests dropped due TTL underflow"), 1,
+                              GNUNET_NO);
+    /* integer underflow => drop (should be very rare)! */
+    return;
+  }
   tec.ttl -= ttl_decrement;
 
   /* test if the request already exists */
   tec.finished = GNUNET_NO;
-  GNUNET_CONTAINER_multihashmap_get_multiple(cp->request_map,
-                                             &gm->query,
-                                             &test_exist_cb,
-                                             &tec);
+  GNUNET_CONTAINER_multihashmap_get_multiple (cp->request_map,
+                                              &gm->query,
+                                              &test_exist_cb,
+                                              &tec);
   if (GNUNET_YES == tec.finished)
     return; /* merged into existing request, we're done */
 
-  peerreq = GNUNET_new(struct PeerRequest);
+  peerreq = GNUNET_new (struct PeerRequest);
   peerreq->cp = cp;
-  pr = GSF_pending_request_create_(options,
-                                   tec.type,
-                                   &gm->query,
-                                   target,
-                                   (bfsize > 0)
-                                   ? (const char *)&opt[bits]
-                                   : NULL,
-                                   bfsize,
-                                   ntohl(gm->filter_mutator),
-                                   1 /* anonymity */,
-                                   (uint32_t)tec.priority,
-                                   tec.ttl,
-                                   spid,
-                                   GNUNET_PEER_intern(cps->ppd.peer),
-                                   NULL, 0,         /* replies_seen */
-                                   &handle_p2p_reply,
-                                   peerreq);
-  GNUNET_assert(NULL != pr);
-  prd = GSF_pending_request_get_data_(pr);
+  pr = GSF_pending_request_create_ (options,
+                                    tec.type,
+                                    &gm->query,
+                                    target,
+                                    (bfsize > 0)
+                                    ? (const char *) &opt[bits]
+                                    : NULL,
+                                    bfsize,
+                                    ntohl (gm->filter_mutator),
+                                    1 /* anonymity */,
+                                    (uint32_t) tec.priority,
+                                    tec.ttl,
+                                    spid,
+                                    GNUNET_PEER_intern (cps->ppd.peer),
+                                    NULL, 0,        /* replies_seen */
+                                    &handle_p2p_reply,
+                                    peerreq);
+  GNUNET_assert (NULL != pr);
+  prd = GSF_pending_request_get_data_ (pr);
   peerreq->pr = pr;
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_CONTAINER_multihashmap_put(cp->request_map,
-                                                 &prd->query,
-                                                 peerreq,
-                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# P2P query messages received and processed"),
-                           1,
-                           GNUNET_NO);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# P2P searches active"),
-                           1,
-                           GNUNET_NO);
-  GSF_pending_request_get_data_(pr)->has_started = GNUNET_YES;
-  GSF_local_lookup_(pr,
-                    &GSF_consider_forwarding,
-                    NULL);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CONTAINER_multihashmap_put (cp->request_map,
+                                                   &prd->query,
+                                                   peerreq,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop (
+                              "# P2P query messages received and processed"),
+                            1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# P2P searches active"),
+                            1,
+                            GNUNET_NO);
+  GSF_pending_request_get_data_ (pr)->has_started = GNUNET_YES;
+  GSF_local_lookup_ (pr,
+                     &GSF_consider_forwarding,
+                     NULL);
 }
 
 
@@ -1349,17 +1365,17 @@ handle_p2p_get(void *cls,
  * @param env message to send
  */
 void
-GSF_peer_transmit_(struct GSF_ConnectedPeer *cp,
-                   int is_query,
-                   uint32_t priority,
-                   struct GNUNET_MQ_Envelope *env)
+GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
+                    int is_query,
+                    uint32_t priority,
+                    struct GNUNET_MQ_Envelope *env)
 {
   struct GSF_PeerTransmitHandle *pth;
   struct GSF_PeerTransmitHandle *pos;
   struct GSF_PeerTransmitHandle *prev;
 
-  pth = GNUNET_new(struct GSF_PeerTransmitHandle);
-  pth->transmission_request_start_time = GNUNET_TIME_absolute_get();
+  pth = GNUNET_new (struct GSF_PeerTransmitHandle);
+  pth->transmission_request_start_time = GNUNET_TIME_absolute_get ();
   pth->env = env;
   pth->is_query = is_query;
   pth->priority = priority;
@@ -1368,19 +1384,19 @@ GSF_peer_transmit_(struct GSF_ConnectedPeer *cp,
   prev = NULL;
   pos = cp->pth_head;
   while ((NULL != pos) && (pos->priority > priority))
-    {
-      prev = pos;
-      pos = pos->next;
-    }
-  GNUNET_CONTAINER_DLL_insert_after(cp->pth_head,
-                                    cp->pth_tail,
-                                    prev,
-                                    pth);
+  {
+    prev = pos;
+    pos = pos->next;
+  }
+  GNUNET_CONTAINER_DLL_insert_after (cp->pth_head,
+                                     cp->pth_tail,
+                                     prev,
+                                     pth);
   if (GNUNET_YES == is_query)
     cp->ppd.pending_queries++;
   else if (GNUNET_NO == is_query)
     cp->ppd.pending_replies++;
-  schedule_transmission(pth);
+  schedule_transmission (pth);
 }
 
 
@@ -1392,19 +1408,19 @@ GSF_peer_transmit_(struct GSF_ConnectedPeer *cp,
  * @param request_priority priority of the original request
  */
 void
-GSF_peer_update_performance_(struct GSF_ConnectedPeer *cp,
-                             struct GNUNET_TIME_Absolute request_time,
-                             uint32_t request_priority)
+GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp,
+                              struct GNUNET_TIME_Absolute request_time,
+                              uint32_t request_priority)
 {
   struct GNUNET_TIME_Relative delay;
 
-  delay = GNUNET_TIME_absolute_get_duration(request_time);
+  delay = GNUNET_TIME_absolute_get_duration (request_time);
   cp->ppd.avg_reply_delay.rel_value_us =
-    (cp->ppd.avg_reply_delay.rel_value_us * (RUNAVG_DELAY_N - 1) +
-     delay.rel_value_us) / RUNAVG_DELAY_N;
+    (cp->ppd.avg_reply_delay.rel_value_us * (RUNAVG_DELAY_N - 1)
+     + delay.rel_value_us) / RUNAVG_DELAY_N;
   cp->ppd.avg_priority =
-    (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1) +
-     request_priority) / RUNAVG_DELAY_N;
+    (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1)
+     + request_priority) / RUNAVG_DELAY_N;
 }
 
 
@@ -1416,11 +1432,11 @@ GSF_peer_update_performance_(struct GSF_ConnectedPeer *cp,
  * @param initiator_client local client on responsible for query
  */
 void
-GSF_peer_update_responder_client_(struct GSF_ConnectedPeer *cp,
-                                  struct GSF_LocalClient *initiator_client)
+GSF_peer_update_responder_client_ (struct GSF_ConnectedPeer *cp,
+                                   struct GSF_LocalClient *initiator_client)
 {
-  cp->ppd.last_client_replies[cp->last_client_replies_woff++ %
-                              CS2P_SUCCESS_LIST_SIZE] = initiator_client;
+  cp->ppd.last_client_replies[cp->last_client_replies_woff++
+                              % CS2P_SUCCESS_LIST_SIZE] = initiator_client;
 }
 
 
@@ -1432,15 +1448,15 @@ GSF_peer_update_responder_client_(struct GSF_ConnectedPeer *cp,
  * @param initiator_peer other peer responsible for query
  */
 void
-GSF_peer_update_responder_peer_(struct GSF_ConnectedPeer *cp,
-                                const struct GSF_ConnectedPeer *initiator_peer)
+GSF_peer_update_responder_peer_ (struct GSF_ConnectedPeer *cp,
+                                 const struct GSF_ConnectedPeer *initiator_peer)
 {
   unsigned int woff;
 
   woff = cp->last_p2p_replies_woff % P2P_SUCCESS_LIST_SIZE;
-  GNUNET_PEER_change_rc(cp->ppd.last_p2p_replies[woff], -1);
+  GNUNET_PEER_change_rc (cp->ppd.last_p2p_replies[woff], -1);
   cp->ppd.last_p2p_replies[woff] = initiator_peer->ppd.pid;
-  GNUNET_PEER_change_rc(initiator_peer->ppd.pid, 1);
+  GNUNET_PEER_change_rc (initiator_peer->ppd.pid, 1);
   cp->last_p2p_replies_woff = (woff + 1) % P2P_SUCCESS_LIST_SIZE;
 }
 
@@ -1454,23 +1470,23 @@ GSF_peer_update_responder_peer_(struct GSF_ConnectedPeer *cp,
  * @return #GNUNET_OK to continue iteration
  */
 static int
-flush_respect(void *cls,
-              const struct GNUNET_PeerIdentity *key,
-              void *value)
+flush_respect (void *cls,
+               const struct GNUNET_PeerIdentity *key,
+               void *value)
 {
   struct GSF_ConnectedPeer *cp = value;
   struct GNUNET_PeerIdentity pid;
 
   if (cp->ppd.respect == cp->disk_respect)
     return GNUNET_OK;           /* unchanged */
-  GNUNET_assert(0 != cp->ppd.pid);
-  GNUNET_PEER_resolve(cp->ppd.pid, &pid);
-  GNUNET_PEERSTORE_store(peerstore, "fs", &pid, "respect", &cp->ppd.respect,
-                         sizeof(cp->ppd.respect),
-                         GNUNET_TIME_UNIT_FOREVER_ABS,
-                         GNUNET_PEERSTORE_STOREOPTION_REPLACE,
-                         NULL,
-                         NULL);
+  GNUNET_assert (0 != cp->ppd.pid);
+  GNUNET_PEER_resolve (cp->ppd.pid, &pid);
+  GNUNET_PEERSTORE_store (peerstore, "fs", &pid, "respect", &cp->ppd.respect,
+                          sizeof(cp->ppd.respect),
+                          GNUNET_TIME_UNIT_FOREVER_ABS,
+                          GNUNET_PEERSTORE_STOREOPTION_REPLACE,
+                          NULL,
+                          NULL);
   return GNUNET_OK;
 }
 
@@ -1484,9 +1500,9 @@ flush_respect(void *cls,
  * @param internal_cls the corresponding `struct GSF_ConnectedPeer`
  */
 void
-GSF_peer_disconnect_handler(void *cls,
-                            const struct GNUNET_PeerIdentity *peer,
-                            void *internal_cls)
+GSF_peer_disconnect_handler (void *cls,
+                             const struct GNUNET_PeerIdentity *peer,
+                             void *internal_cls)
 {
   struct GSF_ConnectedPeer *cp = internal_cls;
   struct GSF_PeerTransmitHandle *pth;
@@ -1495,82 +1511,83 @@ GSF_peer_disconnect_handler(void *cls,
   if (NULL == cp)
     return;  /* must have been disconnect from core with
               * 'peer' == my_id, ignore */
-  flush_respect(NULL,
-                peer,
-                cp);
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(cp_map,
-                                                     peer,
-                                                     cp));
-  GNUNET_STATISTICS_set(GSF_stats,
-                        gettext_noop("# peers connected"),
-                        GNUNET_CONTAINER_multipeermap_size(cp_map),
-                        GNUNET_NO);
+  flush_respect (NULL,
+                 peer,
+                 cp);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (cp_map,
+                                                       peer,
+                                                       cp));
+  GNUNET_STATISTICS_set (GSF_stats,
+                         gettext_noop ("# peers connected"),
+                         GNUNET_CONTAINER_multipeermap_size (cp_map),
+                         GNUNET_NO);
   if (NULL != cp->respect_iterate_req)
-    {
-      GNUNET_PEERSTORE_iterate_cancel(cp->respect_iterate_req);
-      cp->respect_iterate_req = NULL;
-    }
+  {
+    GNUNET_PEERSTORE_iterate_cancel (cp->respect_iterate_req);
+    cp->respect_iterate_req = NULL;
+  }
   if (NULL != cp->rc)
-    {
-      GNUNET_ATS_reserve_bandwidth_cancel(cp->rc);
-      cp->rc = NULL;
-    }
+  {
+    GNUNET_ATS_reserve_bandwidth_cancel (cp->rc);
+    cp->rc = NULL;
+  }
   if (NULL != cp->rc_delay_task)
-    {
-      GNUNET_SCHEDULER_cancel(cp->rc_delay_task);
-      cp->rc_delay_task = NULL;
-    }
-  GNUNET_CONTAINER_multihashmap_iterate(cp->request_map,
-                                        &cancel_pending_request,
-                                        cp);
-  GNUNET_CONTAINER_multihashmap_destroy(cp->request_map);
+  {
+    GNUNET_SCHEDULER_cancel (cp->rc_delay_task);
+    cp->rc_delay_task = NULL;
+  }
+  GNUNET_CONTAINER_multihashmap_iterate (cp->request_map,
+                                         &cancel_pending_request,
+                                         cp);
+  GNUNET_CONTAINER_multihashmap_destroy (cp->request_map);
   cp->request_map = NULL;
-  GSF_plan_notify_peer_disconnect_(cp);
-  GNUNET_LOAD_value_free(cp->ppd.transmission_delay);
-  GNUNET_PEER_decrement_rcs(cp->ppd.last_p2p_replies,
-                            P2P_SUCCESS_LIST_SIZE);
-  memset(cp->ppd.last_p2p_replies,
-         0,
-         sizeof(cp->ppd.last_p2p_replies));
-  GSF_push_stop_(cp);
+  GSF_plan_notify_peer_disconnect_ (cp);
+  GNUNET_LOAD_value_free (cp->ppd.transmission_delay);
+  GNUNET_PEER_decrement_rcs (cp->ppd.last_p2p_replies,
+                             P2P_SUCCESS_LIST_SIZE);
+  memset (cp->ppd.last_p2p_replies,
+          0,
+          sizeof(cp->ppd.last_p2p_replies));
+  GSF_push_stop_ (cp);
   while (NULL != (pth = cp->pth_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(cp->pth_head,
-                                  cp->pth_tail,
-                                  pth);
-      if (GNUNET_YES == pth->is_query)
-        GNUNET_assert(0 < cp->ppd.pending_queries--);
-      else if (GNUNET_NO == pth->is_query)
-        GNUNET_assert(0 < cp->ppd.pending_replies--);
-      GNUNET_free(pth);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (cp->pth_head,
+                                 cp->pth_tail,
+                                 pth);
+    if (GNUNET_YES == pth->is_query)
+      GNUNET_assert (0 < cp->ppd.pending_queries--);
+    else if (GNUNET_NO == pth->is_query)
+      GNUNET_assert (0 < cp->ppd.pending_replies--);
+    GNUNET_free (pth);
+  }
   while (NULL != (dh = cp->delayed_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(cp->delayed_head,
-                                  cp->delayed_tail,
-                                  dh);
-      GNUNET_MQ_discard(dh->env);
-      cp->delay_queue_size--;
-      GNUNET_SCHEDULER_cancel(dh->delay_task);
-      GNUNET_free(dh);
-    }
-  GNUNET_PEER_change_rc(cp->ppd.pid, -1);
+  {
+    GNUNET_CONTAINER_DLL_remove (cp->delayed_head,
+                                 cp->delayed_tail,
+                                 dh);
+    GNUNET_MQ_discard (dh->env);
+    cp->delay_queue_size--;
+    GNUNET_SCHEDULER_cancel (dh->delay_task);
+    GNUNET_free (dh);
+  }
+  GNUNET_PEER_change_rc (cp->ppd.pid, -1);
   if (NULL != cp->mig_revive_task)
-    {
-      GNUNET_SCHEDULER_cancel(cp->mig_revive_task);
-      cp->mig_revive_task = NULL;
-    }
-  GNUNET_break(0 == cp->ppd.pending_queries);
-  GNUNET_break(0 == cp->ppd.pending_replies);
-  GNUNET_free(cp);
+  {
+    GNUNET_SCHEDULER_cancel (cp->mig_revive_task);
+    cp->mig_revive_task = NULL;
+  }
+  GNUNET_break (0 == cp->ppd.pending_queries);
+  GNUNET_break (0 == cp->ppd.pending_replies);
+  GNUNET_free (cp);
 }
 
 
 /**
  * Closure for #call_iterator().
  */
-struct IterationContext {
+struct IterationContext
+{
   /**
    * Function to call on each entry.
    */
@@ -1592,16 +1609,16 @@ struct IterationContext {
  * @return #GNUNET_YES to continue iteration
  */
 static int
-call_iterator(void *cls,
-              const struct GNUNET_PeerIdentity *key,
-              void *value)
+call_iterator (void *cls,
+               const struct GNUNET_PeerIdentity *key,
+               void *value)
 {
   struct IterationContext *ic = cls;
   struct GSF_ConnectedPeer *cp = value;
 
-  ic->it(ic->it_cls,
-         key, cp,
-         &cp->ppd);
+  ic->it (ic->it_cls,
+          key, cp,
+          &cp->ppd);
   return GNUNET_YES;
 }
 
@@ -1613,16 +1630,16 @@ call_iterator(void *cls,
  * @param it_cls closure for @a it
  */
 void
-GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it,
-                             void *it_cls)
+GSF_iterate_connected_peers_ (GSF_ConnectedPeerIterator it,
+                              void *it_cls)
 {
   struct IterationContext ic;
 
   ic.it = it;
   ic.it_cls = it_cls;
-  GNUNET_CONTAINER_multipeermap_iterate(cp_map,
-                                        &call_iterator,
-                                        &ic);
+  GNUNET_CONTAINER_multipeermap_iterate (cp_map,
+                                         &call_iterator,
+                                         &ic);
 }
 
 
@@ -1633,11 +1650,11 @@ GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it,
  * @param id identity to set (written to)
  */
 void
-GSF_connected_peer_get_identity_(const struct GSF_ConnectedPeer *cp,
-                                 struct GNUNET_PeerIdentity *id)
+GSF_connected_peer_get_identity_ (const struct GSF_ConnectedPeer *cp,
+                                  struct GNUNET_PeerIdentity *id)
 {
-  GNUNET_assert(0 != cp->ppd.pid);
-  GNUNET_PEER_resolve(cp->ppd.pid, id);
+  GNUNET_assert (0 != cp->ppd.pid);
+  GNUNET_PEER_resolve (cp->ppd.pid, id);
 }
 
 
@@ -1648,10 +1665,10 @@ GSF_connected_peer_get_identity_(const struct GSF_ConnectedPeer *cp,
  * @return reference to peer identity, valid until peer disconnects (!)
  */
 const struct GNUNET_PeerIdentity *
-GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
+GSF_connected_peer_get_identity2_ (const struct GSF_ConnectedPeer *cp)
 {
-  GNUNET_assert(0 != cp->ppd.pid);
-  return GNUNET_PEER_resolve2(cp->ppd.pid);
+  GNUNET_assert (0 != cp->ppd.pid);
+  return GNUNET_PEER_resolve2 (cp->ppd.pid);
 }
 
 
@@ -1663,38 +1680,41 @@ GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp)
  * @param block_time until when to block
  */
 void
-GSF_block_peer_migration_(struct GSF_ConnectedPeer *cp,
-                          struct GNUNET_TIME_Absolute block_time)
+GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
+                           struct GNUNET_TIME_Absolute block_time)
 {
   struct GNUNET_MQ_Envelope *env;
   struct MigrationStopMessage *msm;
 
   if (cp->last_migration_block.abs_value_us > block_time.abs_value_us)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Migration already blocked for another %s\n",
-                 GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_remaining
-                                                          (cp->last_migration_block), GNUNET_YES));
-      return;                   /* already blocked */
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %s\n",
-             GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_remaining(block_time),
-                                                    GNUNET_YES));
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Migration already blocked for another %s\n",
+                GNUNET_STRINGS_relative_time_to_string (
+                  GNUNET_TIME_absolute_get_remaining
+                    (cp->
+                    last_migration_block), GNUNET_YES));
+    return;                     /* already blocked */
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Asking to stop migration for %s\n",
+              GNUNET_STRINGS_relative_time_to_string (
+                GNUNET_TIME_absolute_get_remaining (block_time),
+                GNUNET_YES));
   cp->last_migration_block = block_time;
-  env = GNUNET_MQ_msg(msm,
-                      GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP);
-  msm->reserved = htonl(0);
+  env = GNUNET_MQ_msg (msm,
+                       GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP);
+  msm->reserved = htonl (0);
   msm->duration
-    = GNUNET_TIME_relative_hton(GNUNET_TIME_absolute_get_remaining
-                                  (cp->last_migration_block));
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# migration stop messages sent"),
-                           1,
-                           GNUNET_NO);
-  GSF_peer_transmit_(cp,
-                     GNUNET_SYSERR,
-                     UINT32_MAX,
-                     env);
+    = GNUNET_TIME_relative_hton (GNUNET_TIME_absolute_get_remaining
+                                   (cp->last_migration_block));
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# migration stop messages sent"),
+                            1,
+                            GNUNET_NO);
+  GSF_peer_transmit_ (cp,
+                      GNUNET_SYSERR,
+                      UINT32_MAX,
+                      env);
 }
 
 
@@ -1708,8 +1728,8 @@ GSF_block_peer_migration_(struct GSF_ConnectedPeer *cp,
  * @param pref preference change
  */
 void
-GSF_connected_peer_change_preference_(struct GSF_ConnectedPeer *cp,
-                                      uint64_t pref)
+GSF_connected_peer_change_preference_ (struct GSF_ConnectedPeer *cp,
+                                       uint64_t pref)
 {
   cp->inc_preference += pref;
 }
@@ -1721,15 +1741,16 @@ GSF_connected_peer_change_preference_(struct GSF_ConnectedPeer *cp,
  * @param cls closure, not used
  */
 static void
-cron_flush_respect(void *cls)
+cron_flush_respect (void *cls)
 {
   fr_task = NULL;
-  GNUNET_CONTAINER_multipeermap_iterate(cp_map,
-                                        &flush_respect,
-                                        NULL);
-  fr_task = GNUNET_SCHEDULER_add_delayed_with_priority(RESPECT_FLUSH_FREQ,
-                                                       GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                                       &cron_flush_respect, NULL);
+  GNUNET_CONTAINER_multipeermap_iterate (cp_map,
+                                         &flush_respect,
+                                         NULL);
+  fr_task = GNUNET_SCHEDULER_add_delayed_with_priority (RESPECT_FLUSH_FREQ,
+                                                        GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                                        &cron_flush_respect,
+                                                        NULL);
 }
 
 
@@ -1737,12 +1758,12 @@ cron_flush_respect(void *cls)
  * Initialize peer management subsystem.
  */
 void
-GSF_connected_peer_init_()
+GSF_connected_peer_init_ ()
 {
-  cp_map = GNUNET_CONTAINER_multipeermap_create(128, GNUNET_YES);
-  peerstore = GNUNET_PEERSTORE_connect(GSF_cfg);
-  fr_task = GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                               &cron_flush_respect, NULL);
+  cp_map = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_YES);
+  peerstore = GNUNET_PEERSTORE_connect (GSF_cfg);
+  fr_task = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_HIGH,
+                                                &cron_flush_respect, NULL);
 }
 
 
@@ -1750,17 +1771,17 @@ GSF_connected_peer_init_()
  * Shutdown peer management subsystem.
  */
 void
-GSF_connected_peer_done_()
+GSF_connected_peer_done_ ()
 {
-  GNUNET_CONTAINER_multipeermap_iterate(cp_map,
-                                        &flush_respect,
-                                        NULL);
-  GNUNET_SCHEDULER_cancel(fr_task);
+  GNUNET_CONTAINER_multipeermap_iterate (cp_map,
+                                         &flush_respect,
+                                         NULL);
+  GNUNET_SCHEDULER_cancel (fr_task);
   fr_task = NULL;
-  GNUNET_CONTAINER_multipeermap_destroy(cp_map);
+  GNUNET_CONTAINER_multipeermap_destroy (cp_map);
   cp_map = NULL;
-  GNUNET_PEERSTORE_disconnect(peerstore,
-                              GNUNET_YES);
+  GNUNET_PEERSTORE_disconnect (peerstore,
+                               GNUNET_YES);
 }
 
 
@@ -1773,9 +1794,9 @@ GSF_connected_peer_done_()
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-clean_local_client(void *cls,
-                   const struct GNUNET_PeerIdentity *key,
-                   void *value)
+clean_local_client (void *cls,
+                    const struct GNUNET_PeerIdentity *key,
+                    void *value)
 {
   const struct GSF_LocalClient *lc = cls;
   struct GSF_ConnectedPeer *cp = value;
@@ -1795,13 +1816,13 @@ clean_local_client(void *cls,
  * @param lc handle to the local client (henceforth invalid)
  */
 void
-GSF_handle_local_client_disconnect_(const struct GSF_LocalClient *lc)
+GSF_handle_local_client_disconnect_ (const struct GSF_LocalClient *lc)
 {
   if (NULL == cp_map)
     return;                     /* already cleaned up */
-  GNUNET_CONTAINER_multipeermap_iterate(cp_map,
-                                        &clean_local_client,
-                                        (void *)lc);
+  GNUNET_CONTAINER_multipeermap_iterate (cp_map,
+                                         &clean_local_client,
+                                         (void *) lc);
 }
 
 
diff --git a/src/fs/gnunet-service-fs_cp.h b/src/fs/gnunet-service-fs_cp.h
index 9eab3d9de..c17b6a0a8 100644
--- a/src/fs/gnunet-service-fs_cp.h
+++ b/src/fs/gnunet-service-fs_cp.h
@@ -60,7 +60,8 @@
 /**
  * Performance data kept for a peer.
  */
-struct GSF_PeerPerformanceData {
+struct GSF_PeerPerformanceData
+{
   /**
    * List of the last clients for which this peer successfully
    * answered a query.
@@ -202,9 +203,9 @@ struct GSF_PeerTransmitHandle;
  * @return internal handle for the peer
  */
 void *
-GSF_peer_connect_handler(void *cls,
-                         const struct GNUNET_PeerIdentity *peer,
-                         struct GNUNET_MQ_Handle *mq);
+GSF_peer_connect_handler (void *cls,
+                          const struct GNUNET_PeerIdentity *peer,
+                          struct GNUNET_MQ_Handle *mq);
 
 
 /**
@@ -214,7 +215,7 @@ GSF_peer_connect_handler(void *cls,
  * @return NULL if this peer is not currently connected
  */
 struct GSF_ConnectedPeer *
-GSF_peer_get_(const struct GNUNET_PeerIdentity *peer);
+GSF_peer_get_ (const struct GNUNET_PeerIdentity *peer);
 
 
 /**
@@ -224,8 +225,8 @@ GSF_peer_get_(const struct GNUNET_PeerIdentity *peer);
  * @param latency current latency value
  */
 void
-GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id,
-                         struct GNUNET_TIME_Relative latency);
+GSF_update_peer_latency_ (const struct GNUNET_PeerIdentity *id,
+                          struct GNUNET_TIME_Relative latency);
 
 
 /**
@@ -239,10 +240,10 @@ GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id,
  * @param env envelope of message to send
  */
 void
-GSF_peer_transmit_(struct GSF_ConnectedPeer *cp,
-                   int is_query,
-                   uint32_t priority,
-                   struct GNUNET_MQ_Envelope *env);
+GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
+                    int is_query,
+                    uint32_t priority,
+                    struct GNUNET_MQ_Envelope *env);
 
 
 /**
@@ -253,9 +254,9 @@ GSF_peer_transmit_(struct GSF_ConnectedPeer *cp,
  * @param request_priority priority of the original request
  */
 void
-GSF_peer_update_performance_(struct GSF_ConnectedPeer *cp,
-                             struct GNUNET_TIME_Absolute request_time,
-                             uint32_t request_priority);
+GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp,
+                              struct GNUNET_TIME_Absolute request_time,
+                              uint32_t request_priority);
 
 
 /**
@@ -266,8 +267,8 @@ GSF_peer_update_performance_(struct GSF_ConnectedPeer *cp,
  * @param initiator_client local client on responsible for query
  */
 void
-GSF_peer_update_responder_client_(struct GSF_ConnectedPeer *cp,
-                                  struct GSF_LocalClient *initiator_client);
+GSF_peer_update_responder_client_ (struct GSF_ConnectedPeer *cp,
+                                   struct GSF_LocalClient *initiator_client);
 
 
 /**
@@ -278,9 +279,9 @@ GSF_peer_update_responder_client_(struct GSF_ConnectedPeer *cp,
  * @param initiator_peer other peer responsible for query
  */
 void
-GSF_peer_update_responder_peer_(struct GSF_ConnectedPeer *cp,
-                                const struct GSF_ConnectedPeer
-                                *initiator_peer);
+GSF_peer_update_responder_peer_ (struct GSF_ConnectedPeer *cp,
+                                 const struct GSF_ConnectedPeer
+                                 *initiator_peer);
 
 
 /**
@@ -290,8 +291,8 @@ GSF_peer_update_responder_peer_(struct GSF_ConnectedPeer *cp,
  * @param msm the actual message
  */
 void
-handle_p2p_migration_stop(void *cls,
-                          const struct MigrationStopMessage *message);
+handle_p2p_migration_stop (void *cls,
+                           const struct MigrationStopMessage *message);
 
 
 /**
@@ -301,8 +302,8 @@ handle_p2p_migration_stop(void *cls,
  * @param gm the actual message
  */
 void
-handle_p2p_get(void *cls,
-               const struct GetMessage *gm);
+handle_p2p_get (void *cls,
+                const struct GetMessage *gm);
 
 
 /**
@@ -312,7 +313,7 @@ handle_p2p_get(void *cls,
  * @return performance data record for the peer
  */
 struct GSF_PeerPerformanceData *
-GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp);
+GSF_get_peer_performance_data_ (struct GSF_ConnectedPeer *cp);
 
 
 /**
@@ -323,8 +324,8 @@ GSF_get_peer_performance_data_(struct GSF_ConnectedPeer *cp);
  * @param block_time until when to block
  */
 void
-GSF_block_peer_migration_(struct GSF_ConnectedPeer *cp,
-                          struct GNUNET_TIME_Absolute block_time);
+GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
+                           struct GNUNET_TIME_Absolute block_time);
 
 
 /**
@@ -336,9 +337,9 @@ GSF_block_peer_migration_(struct GSF_ConnectedPeer *cp,
  * @param internal_cls our `struct GSF_ConnectedPeer` for @a peer
  */
 void
-GSF_peer_disconnect_handler(void *cls,
-                            const struct GNUNET_PeerIdentity *peer,
-                            void *internal_cls);
+GSF_peer_disconnect_handler (void *cls,
+                             const struct GNUNET_PeerIdentity *peer,
+                             void *internal_cls);
 
 
 /**
@@ -348,7 +349,7 @@ GSF_peer_disconnect_handler(void *cls,
  * @param lc handle to the local client (henceforth invalid)
  */
 void
-GSF_handle_local_client_disconnect_(const struct GSF_LocalClient *lc);
+GSF_handle_local_client_disconnect_ (const struct GSF_LocalClient *lc);
 
 
 /**
@@ -361,8 +362,8 @@ GSF_handle_local_client_disconnect_(const struct GSF_LocalClient *lc);
  * @param pref preference change
  */
 void
-GSF_connected_peer_change_preference_(struct GSF_ConnectedPeer *cp,
-                                      uint64_t pref);
+GSF_connected_peer_change_preference_ (struct GSF_ConnectedPeer *cp,
+                                       uint64_t pref);
 
 
 /**
@@ -372,8 +373,8 @@ GSF_connected_peer_change_preference_(struct GSF_ConnectedPeer *cp,
  * @param id identity to set (written to)
  */
 void
-GSF_connected_peer_get_identity_(const struct GSF_ConnectedPeer *cp,
-                                 struct GNUNET_PeerIdentity *id);
+GSF_connected_peer_get_identity_ (const struct GSF_ConnectedPeer *cp,
+                                  struct GNUNET_PeerIdentity *id);
 
 
 /**
@@ -383,7 +384,7 @@ GSF_connected_peer_get_identity_(const struct GSF_ConnectedPeer *cp,
  * @return reference to peer identity, valid until peer disconnects (!)
  */
 const struct GNUNET_PeerIdentity *
-GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp);
+GSF_connected_peer_get_identity2_ (const struct GSF_ConnectedPeer *cp);
 
 
 
@@ -394,21 +395,21 @@ GSF_connected_peer_get_identity2_(const struct GSF_ConnectedPeer *cp);
  * @param it_cls closure for it
  */
 void
-GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it, void *it_cls);
+GSF_iterate_connected_peers_ (GSF_ConnectedPeerIterator it, void *it_cls);
 
 
 /**
  * Initialize peer management subsystem.
  */
 void
-GSF_connected_peer_init_(void);
+GSF_connected_peer_init_ (void);
 
 
 /**
  * Shutdown peer management subsystem.
  */
 void
-GSF_connected_peer_done_(void);
+GSF_connected_peer_done_ (void);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_indexing.c b/src/fs/gnunet-service-fs_indexing.c
index e21b2ca57..4a7172c50 100644
--- a/src/fs/gnunet-service-fs_indexing.c
+++ b/src/fs/gnunet-service-fs_indexing.c
@@ -39,7 +39,8 @@
  * In-memory information about indexed files (also available
  * on-disk).
  */
-struct IndexInfo {
+struct IndexInfo
+{
   /**
    * This is a doubly linked list.
    */
@@ -108,44 +109,44 @@ static struct GNUNET_DATASTORE_Handle *dsh;
  * Write the current index information list to disk.
  */
 static void
-write_index_list()
+write_index_list ()
 {
   struct GNUNET_BIO_WriteHandle *wh;
   char *fn;
   struct IndexInfo *pos;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename(cfg, "FS", "INDEXDB", &fn))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                                "fs",
-                                "INDEXDB");
-      return;
-    }
-  wh = GNUNET_BIO_write_open(fn);
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                               "fs",
+                               "INDEXDB");
+    return;
+  }
+  wh = GNUNET_BIO_write_open (fn);
   if (NULL == wh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                 _("Could not open `%s'.\n"),
-                 fn);
-      GNUNET_free(fn);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                _ ("Could not open `%s'.\n"),
+                fn);
+    GNUNET_free (fn);
+    return;
+  }
   for (pos = indexed_files_head; NULL != pos; pos = pos->next)
-    if ((GNUNET_OK != GNUNET_BIO_write(wh,
-                                       &pos->file_id,
-                                       sizeof(struct GNUNET_HashCode))) ||
-        (GNUNET_OK != GNUNET_BIO_write_string(wh, pos->filename)))
+    if ((GNUNET_OK != GNUNET_BIO_write (wh,
+                                        &pos->file_id,
+                                        sizeof(struct GNUNET_HashCode))) ||
+        (GNUNET_OK != GNUNET_BIO_write_string (wh, pos->filename)))
       break;
-  if (GNUNET_OK != GNUNET_BIO_write_close(wh))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                 _("Error writing `%s'.\n"),
-                 fn);
-      GNUNET_free(fn);
-      return;
-    }
-  GNUNET_free(fn);
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                _ ("Error writing `%s'.\n"),
+                fn);
+    GNUNET_free (fn);
+    return;
+  }
+  GNUNET_free (fn);
 }
 
 
@@ -153,7 +154,7 @@ write_index_list()
  * Read index information from disk.
  */
 static void
-read_index_list()
+read_index_list ()
 {
   struct GNUNET_BIO_ReadHandle *rh;
   char *fn;
@@ -164,59 +165,59 @@ read_index_list()
   char *emsg;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename(cfg, "FS", "INDEXDB", &fn))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                                "fs",
-                                "INDEXDB");
-      return;
-    }
-  if (GNUNET_NO == GNUNET_DISK_file_test(fn))
-    {
-      /* no index info yet */
-      GNUNET_free(fn);
-      return;
-    }
-  rh = GNUNET_BIO_read_open(fn);
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                               "fs",
+                               "INDEXDB");
+    return;
+  }
+  if (GNUNET_NO == GNUNET_DISK_file_test (fn))
+  {
+    /* no index info yet */
+    GNUNET_free (fn);
+    return;
+  }
+  rh = GNUNET_BIO_read_open (fn);
   if (NULL == rh)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                 _("Could not open `%s'.\n"),
-                 fn);
-      GNUNET_free(fn);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                _ ("Could not open `%s'.\n"),
+                fn);
+    GNUNET_free (fn);
+    return;
+  }
   while (
-    (GNUNET_OK == GNUNET_BIO_read(rh,
-                                  "Hash of indexed file",
-                                  &hc,
-                                  sizeof(struct GNUNET_HashCode))) &&
+    (GNUNET_OK == GNUNET_BIO_read (rh,
+                                   "Hash of indexed file",
+                                   &hc,
+                                   sizeof(struct GNUNET_HashCode))) &&
     (GNUNET_OK ==
-     GNUNET_BIO_read_string(rh, "Name of indexed file", &fname, 1024 * 16)) &&
+     GNUNET_BIO_read_string (rh, "Name of indexed file", &fname, 1024 * 16)) &&
     (fname != NULL))
+  {
+    slen = strlen (fname) + 1;
+    pos = GNUNET_malloc (sizeof(struct IndexInfo) + slen);
+    pos->file_id = hc;
+    pos->filename = (const char *) &pos[1];
+    GNUNET_memcpy (&pos[1], fname, slen);
+    if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (
+          ifm,
+          &pos->file_id,
+          pos,
+          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+    {
+      GNUNET_free (pos);
+    }
+    else
     {
-      slen = strlen(fname) + 1;
-      pos = GNUNET_malloc(sizeof(struct IndexInfo) + slen);
-      pos->file_id = hc;
-      pos->filename = (const char *)&pos[1];
-      GNUNET_memcpy(&pos[1], fname, slen);
-      if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put(
-            ifm,
-            &pos->file_id,
-            pos,
-            GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-        {
-          GNUNET_free(pos);
-        }
-      else
-        {
-          GNUNET_CONTAINER_DLL_insert(indexed_files_head, indexed_files_tail, pos);
-        }
-      GNUNET_free(fname);
+      GNUNET_CONTAINER_DLL_insert (indexed_files_head, indexed_files_tail, pos);
     }
-  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
-    GNUNET_free(emsg);
-  GNUNET_free(fn);
+    GNUNET_free (fname);
+  }
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
+    GNUNET_free (emsg);
+  GNUNET_free (fn);
 }
 
 
@@ -230,15 +231,15 @@ read_index_list()
  * @param msg error message
  */
 static void
-remove_cont(void *cls,
-            int success,
-            struct GNUNET_TIME_Absolute min_expiration,
-            const char *msg)
+remove_cont (void *cls,
+             int success,
+             struct GNUNET_TIME_Absolute min_expiration,
+             const char *msg)
 {
   if (GNUNET_OK != success)
-    GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-               _("Failed to delete bogus block: %s\n"),
-               msg);
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Failed to delete bogus block: %s\n"),
+                msg);
 }
 
 
@@ -263,17 +264,17 @@ remove_cont(void *cls,
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_handle_on_demand_block(const struct GNUNET_HashCode *key,
-                                 uint32_t size,
-                                 const void *data,
-                                 enum GNUNET_BLOCK_Type type,
-                                 uint32_t priority,
-                                 uint32_t anonymity,
-                                 uint32_t replication,
-                                 struct GNUNET_TIME_Absolute expiration,
-                                 uint64_t uid,
-                                 GNUNET_DATASTORE_DatumProcessor cont,
-                                 void *cont_cls)
+GNUNET_FS_handle_on_demand_block (const struct GNUNET_HashCode *key,
+                                  uint32_t size,
+                                  const void *data,
+                                  enum GNUNET_BLOCK_Type type,
+                                  uint32_t priority,
+                                  uint32_t anonymity,
+                                  uint32_t replication,
+                                  struct GNUNET_TIME_Absolute expiration,
+                                  uint64_t uid,
+                                  GNUNET_DATASTORE_DatumProcessor cont,
+                                  void *cont_cls)
 {
   const struct OnDemandBlock *odb;
   struct GNUNET_HashCode nkey;
@@ -289,78 +290,78 @@ GNUNET_FS_handle_on_demand_block(const struct GNUNET_HashCode *key,
   struct IndexInfo *ii;
 
   if (size != sizeof(struct OnDemandBlock))
-    {
-      GNUNET_break(0);
-      GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
-      return GNUNET_SYSERR;
-    }
-  odb = (const struct OnDemandBlock *)data;
-  off = GNUNET_ntohll(odb->offset);
-  ii = GNUNET_CONTAINER_multihashmap_get(ifm, &odb->file_id);
+  {
+    GNUNET_break (0);
+    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
+    return GNUNET_SYSERR;
+  }
+  odb = (const struct OnDemandBlock *) data;
+  off = GNUNET_ntohll (odb->offset);
+  ii = GNUNET_CONTAINER_multihashmap_get (ifm, &odb->file_id);
   if (NULL == ii)
-    {
-      GNUNET_break(0);
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Failed to find index %s\n",
-                 GNUNET_h2s(&odb->file_id));
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to find index %s\n",
+                GNUNET_h2s (&odb->file_id));
+    return GNUNET_SYSERR;
+  }
   fn = ii->filename;
-  if ((NULL == fn) || (0 != access(fn, R_OK)))
-    {
-      GNUNET_STATISTICS_update(
-        GSF_stats,
-        gettext_noop("# index blocks removed: original file inaccessible"),
-        1,
-        GNUNET_YES);
-      GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
-      return GNUNET_SYSERR;
-    }
-  if ((NULL == (fh = GNUNET_DISK_file_open(fn,
-                                           GNUNET_DISK_OPEN_READ,
-                                           GNUNET_DISK_PERM_NONE))) ||
-      (off != GNUNET_DISK_file_seek(fh, off, GNUNET_DISK_SEEK_SET)) ||
-      (-1 == (nsize = GNUNET_DISK_file_read(fh, ndata, sizeof(ndata)))))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _(
-                   "Could not access indexed file `%s' (%s) at offset %llu: %s\n"),
-                 GNUNET_h2s(&odb->file_id),
-                 fn,
-                 (unsigned long long)off,
-                 (fn == NULL) ? _("not indexed") : strerror(errno));
-      if (fh != NULL)
-        GNUNET_DISK_file_close(fh);
-      GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_DISK_file_close(fh);
-  GNUNET_CRYPTO_hash(ndata, nsize, &nkey);
-  GNUNET_CRYPTO_hash_to_aes_key(&nkey, &skey, &iv);
-  GNUNET_CRYPTO_symmetric_encrypt(ndata, nsize, &skey, &iv, edata);
-  GNUNET_CRYPTO_hash(edata, nsize, &query);
-  if (0 != memcmp(&query, key, sizeof(struct GNUNET_HashCode)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-                 _("Indexed file `%s' changed at offset %llu\n"),
-                 fn,
-                 (unsigned long long)off);
-      GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
-      return GNUNET_SYSERR;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "On-demand encoded block for query `%s'\n",
-             GNUNET_h2s(key));
-  cont(cont_cls,
-       key,
-       nsize,
-       edata,
-       GNUNET_BLOCK_TYPE_FS_DBLOCK,
-       priority,
-       anonymity,
-       replication,
-       expiration,
-       uid);
+  if ((NULL == fn) || (0 != access (fn, R_OK)))
+  {
+    GNUNET_STATISTICS_update (
+      GSF_stats,
+      gettext_noop ("# index blocks removed: original file inaccessible"),
+      1,
+      GNUNET_YES);
+    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
+    return GNUNET_SYSERR;
+  }
+  if ((NULL == (fh = GNUNET_DISK_file_open (fn,
+                                            GNUNET_DISK_OPEN_READ,
+                                            GNUNET_DISK_PERM_NONE))) ||
+      (off != GNUNET_DISK_file_seek (fh, off, GNUNET_DISK_SEEK_SET)) ||
+      (-1 == (nsize = GNUNET_DISK_file_read (fh, ndata, sizeof(ndata)))))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ (
+                  "Could not access indexed file `%s' (%s) at offset %llu: %s\n"),
+                GNUNET_h2s (&odb->file_id),
+                fn,
+                (unsigned long long) off,
+                (fn == NULL) ? _ ("not indexed") : strerror (errno));
+    if (fh != NULL)
+      GNUNET_DISK_file_close (fh);
+    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_DISK_file_close (fh);
+  GNUNET_CRYPTO_hash (ndata, nsize, &nkey);
+  GNUNET_CRYPTO_hash_to_aes_key (&nkey, &skey, &iv);
+  GNUNET_CRYPTO_symmetric_encrypt (ndata, nsize, &skey, &iv, edata);
+  GNUNET_CRYPTO_hash (edata, nsize, &query);
+  if (0 != memcmp (&query, key, sizeof(struct GNUNET_HashCode)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _ ("Indexed file `%s' changed at offset %llu\n"),
+                fn,
+                (unsigned long long) off);
+    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
+    return GNUNET_SYSERR;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "On-demand encoded block for query `%s'\n",
+              GNUNET_h2s (key));
+  cont (cont_cls,
+        key,
+        nsize,
+        edata,
+        GNUNET_BLOCK_TYPE_FS_DBLOCK,
+        priority,
+        anonymity,
+        replication,
+        expiration,
+        uid);
   return GNUNET_OK;
 }
 
@@ -371,7 +372,7 @@ GNUNET_FS_handle_on_demand_block(const struct GNUNET_HashCode *key,
  * @param mq message queue to send information to
  */
 void
-GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq)
+GNUNET_FS_indexing_send_list (struct GNUNET_MQ_Handle *mq)
 {
   struct GNUNET_MQ_Envelope *env;
   struct IndexInfoMessage *iim;
@@ -381,23 +382,23 @@ GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq)
   struct IndexInfo *pos;
 
   for (pos = indexed_files_head; NULL != pos; pos = pos->next)
+  {
+    fn = pos->filename;
+    slen = strlen (fn) + 1;
+    if (slen + sizeof(struct IndexInfoMessage) >= GNUNET_MAX_MESSAGE_SIZE)
     {
-      fn = pos->filename;
-      slen = strlen(fn) + 1;
-      if (slen + sizeof(struct IndexInfoMessage) >= GNUNET_MAX_MESSAGE_SIZE)
-        {
-          GNUNET_break(0);
-          break;
-        }
-      env =
-        GNUNET_MQ_msg_extra(iim, slen, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY);
-      iim->reserved = 0;
-      iim->file_id = pos->file_id;
-      GNUNET_memcpy(&iim[1], fn, slen);
-      GNUNET_MQ_send(mq, env);
+      GNUNET_break (0);
+      break;
     }
-  env = GNUNET_MQ_msg(iem, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END);
-  GNUNET_MQ_send(mq, env);
+    env =
+      GNUNET_MQ_msg_extra (iim, slen, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY);
+    iim->reserved = 0;
+    iim->file_id = pos->file_id;
+    GNUNET_memcpy (&iim[1], fn, slen);
+    GNUNET_MQ_send (mq, env);
+  }
+  env = GNUNET_MQ_msg (iem, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END);
+  GNUNET_MQ_send (mq, env);
 }
 
 
@@ -408,23 +409,23 @@ GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq)
  * @return #GNUNET_YES if the @a fid was found
  */
 int
-GNUNET_FS_indexing_do_unindex(const struct GNUNET_HashCode *fid)
+GNUNET_FS_indexing_do_unindex (const struct GNUNET_HashCode *fid)
 {
   struct IndexInfo *pos;
 
   for (pos = indexed_files_head; NULL != pos; pos = pos->next)
+  {
+    if (0 == memcmp (&pos->file_id, fid, sizeof(struct GNUNET_HashCode)))
     {
-      if (0 == memcmp(&pos->file_id, fid, sizeof(struct GNUNET_HashCode)))
-        {
-          GNUNET_CONTAINER_DLL_remove(indexed_files_head, indexed_files_tail, pos);
-          GNUNET_break(
-            GNUNET_OK ==
-            GNUNET_CONTAINER_multihashmap_remove(ifm, &pos->file_id, pos));
-          GNUNET_free(pos);
-          write_index_list();
-          return GNUNET_YES;
-        }
+      GNUNET_CONTAINER_DLL_remove (indexed_files_head, indexed_files_tail, pos);
+      GNUNET_break (
+        GNUNET_OK ==
+        GNUNET_CONTAINER_multihashmap_remove (ifm, &pos->file_id, pos));
+      GNUNET_free (pos);
+      write_index_list ();
+      return GNUNET_YES;
     }
+  }
   return GNUNET_NO;
 }
 
@@ -436,40 +437,40 @@ GNUNET_FS_indexing_do_unindex(const struct GNUNET_HashCode *fid)
  * @param file_id hash identifier for @a filename
  */
 void
-GNUNET_FS_add_to_index(const char *filename,
-                       const struct GNUNET_HashCode *file_id)
+GNUNET_FS_add_to_index (const char *filename,
+                        const struct GNUNET_HashCode *file_id)
 {
   struct IndexInfo *ii;
   size_t slen;
 
-  ii = GNUNET_CONTAINER_multihashmap_get(ifm, file_id);
+  ii = GNUNET_CONTAINER_multihashmap_get (ifm, file_id);
   if (NULL != ii)
-    {
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_INFO,
-        _(
-          "Index request received for file `%s' is already indexed as `%s'.  Permitting anyway.\n"),
-        filename,
-        ii->filename);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Adding file %s to index as %s\n",
-             filename,
-             GNUNET_h2s(file_id));
-  slen = strlen(filename) + 1;
-  ii = GNUNET_malloc(sizeof(struct IndexInfo) + slen);
+  {
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_INFO,
+      _ (
+        "Index request received for file `%s' is already indexed as `%s'.  Permitting anyway.\n"),
+      filename,
+      ii->filename);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Adding file %s to index as %s\n",
+              filename,
+              GNUNET_h2s (file_id));
+  slen = strlen (filename) + 1;
+  ii = GNUNET_malloc (sizeof(struct IndexInfo) + slen);
   ii->file_id = *file_id;
-  ii->filename = (const char *)&ii[1];
-  GNUNET_memcpy(&ii[1], filename, slen);
-  GNUNET_CONTAINER_DLL_insert(indexed_files_head, indexed_files_tail, ii);
-  GNUNET_assert(GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put(
-                  ifm,
-                  &ii->file_id,
-                  ii,
-                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-  write_index_list();
+  ii->filename = (const char *) &ii[1];
+  GNUNET_memcpy (&ii[1], filename, slen);
+  GNUNET_CONTAINER_DLL_insert (indexed_files_head, indexed_files_tail, ii);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONTAINER_multihashmap_put (
+                   ifm,
+                   &ii->file_id,
+                   ii,
+                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+  write_index_list ();
 }
 
 
@@ -477,21 +478,21 @@ GNUNET_FS_add_to_index(const char *filename,
  * Shutdown the module.
  */
 void
-GNUNET_FS_indexing_done()
+GNUNET_FS_indexing_done ()
 {
   struct IndexInfo *pos;
 
   while (NULL != (pos = indexed_files_head))
-    {
-      GNUNET_CONTAINER_DLL_remove(indexed_files_head, indexed_files_tail, pos);
-      if (pos->fhc != NULL)
-        GNUNET_CRYPTO_hash_file_cancel(pos->fhc);
-      GNUNET_break(
-        GNUNET_OK ==
-        GNUNET_CONTAINER_multihashmap_remove(ifm, &pos->file_id, pos));
-      GNUNET_free(pos);
-    }
-  GNUNET_CONTAINER_multihashmap_destroy(ifm);
+  {
+    GNUNET_CONTAINER_DLL_remove (indexed_files_head, indexed_files_tail, pos);
+    if (pos->fhc != NULL)
+      GNUNET_CRYPTO_hash_file_cancel (pos->fhc);
+    GNUNET_break (
+      GNUNET_OK ==
+      GNUNET_CONTAINER_multihashmap_remove (ifm, &pos->file_id, pos));
+    GNUNET_free (pos);
+  }
+  GNUNET_CONTAINER_multihashmap_destroy (ifm);
   ifm = NULL;
   cfg = NULL;
 }
@@ -504,13 +505,13 @@ GNUNET_FS_indexing_done()
  * @param d datastore to use
  */
 int
-GNUNET_FS_indexing_init(const struct GNUNET_CONFIGURATION_Handle *c,
-                        struct GNUNET_DATASTORE_Handle *d)
+GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c,
+                         struct GNUNET_DATASTORE_Handle *d)
 {
   cfg = c;
   dsh = d;
-  ifm = GNUNET_CONTAINER_multihashmap_create(128, GNUNET_YES);
-  read_index_list();
+  ifm = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_YES);
+  read_index_list ();
   return GNUNET_OK;
 }
 
diff --git a/src/fs/gnunet-service-fs_indexing.h b/src/fs/gnunet-service-fs_indexing.h
index 4c137d7a6..546dbb172 100644
--- a/src/fs/gnunet-service-fs_indexing.h
+++ b/src/fs/gnunet-service-fs_indexing.h
@@ -56,17 +56,17 @@
  * @return #GNUNET_OK on success
  */
 int
-GNUNET_FS_handle_on_demand_block(const struct GNUNET_HashCode *key,
-                                 uint32_t size,
-                                 const void *data,
-                                 enum GNUNET_BLOCK_Type type,
-                                 uint32_t priority,
-                                 uint32_t anonymity,
-                                 uint32_t replication,
-                                 struct GNUNET_TIME_Absolute expiration,
-                                 uint64_t uid,
-                                 GNUNET_DATASTORE_DatumProcessor cont,
-                                 void *cont_cls);
+GNUNET_FS_handle_on_demand_block (const struct GNUNET_HashCode *key,
+                                  uint32_t size,
+                                  const void *data,
+                                  enum GNUNET_BLOCK_Type type,
+                                  uint32_t priority,
+                                  uint32_t anonymity,
+                                  uint32_t replication,
+                                  struct GNUNET_TIME_Absolute expiration,
+                                  uint64_t uid,
+                                  GNUNET_DATASTORE_DatumProcessor cont,
+                                  void *cont_cls);
 
 
 /**
@@ -75,7 +75,7 @@ GNUNET_FS_handle_on_demand_block(const struct GNUNET_HashCode *key,
  * @param mq message queue to send information to
  */
 void
-GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq);
+GNUNET_FS_indexing_send_list (struct GNUNET_MQ_Handle *mq);
 
 
 /**
@@ -85,7 +85,7 @@ GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq);
  * @return #GNUNET_YES if the @a fid was found
  */
 int
-GNUNET_FS_indexing_do_unindex(const struct GNUNET_HashCode *fid);
+GNUNET_FS_indexing_do_unindex (const struct GNUNET_HashCode *fid);
 
 
 /**
@@ -95,8 +95,8 @@ GNUNET_FS_indexing_do_unindex(const struct GNUNET_HashCode *fid);
  * @param file_id hash identifier for @a filename
  */
 void
-GNUNET_FS_add_to_index(const char *filename,
-                       const struct GNUNET_HashCode *file_id);
+GNUNET_FS_add_to_index (const char *filename,
+                        const struct GNUNET_HashCode *file_id);
 
 
 /**
@@ -107,15 +107,15 @@ GNUNET_FS_add_to_index(const char *filename,
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_indexing_init(const struct GNUNET_CONFIGURATION_Handle *c,
-                        struct GNUNET_DATASTORE_Handle *d);
+GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c,
+                         struct GNUNET_DATASTORE_Handle *d);
 
 
 /**
  * Shutdown the module.
  */
 void
-GNUNET_FS_indexing_done(void);
+GNUNET_FS_indexing_done (void);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index 3c1112333..7933b2dee 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -63,7 +63,8 @@ struct PeerPlan;
  * to be able to lookup all plan entries corresponding
  * to a given pending request.)
  */
-struct GSF_PendingRequestPlanBijection {
+struct GSF_PendingRequestPlanBijection
+{
   /**
    * This is a doubly-linked list.
    */
@@ -104,7 +105,8 @@ struct GSF_PendingRequestPlanBijection {
  * with one entry in each heap of each `struct PeerPlan`.  Each
  * entry tracks information relevant for this request and this peer.
  */
-struct GSF_RequestPlan {
+struct GSF_RequestPlan
+{
   /**
    * This is a doubly-linked list.
    */
@@ -162,7 +164,8 @@ struct GSF_RequestPlan {
 /**
  * Transmission plan for a peer.
  */
-struct PeerPlan {
+struct PeerPlan
+{
   /**
    * Heap with pending queries (`struct GSF_RequestPlan`), higher weights mean higher priority.
    */
@@ -227,9 +230,9 @@ static unsigned long long plan_count;
  * @return the associated query
  */
 static const struct GNUNET_HashCode *
-get_rp_key(struct GSF_RequestPlan *rp)
+get_rp_key (struct GSF_RequestPlan *rp)
 {
-  return &GSF_pending_request_get_data_(rp->pe_head->pr)->query;
+  return &GSF_pending_request_get_data_ (rp->pe_head->pr)->query;
 }
 
 
@@ -240,10 +243,10 @@ get_rp_key(struct GSF_RequestPlan *rp)
  * @param rp request to plan
  */
 static void
-plan(struct PeerPlan *pp,
-     struct GSF_RequestPlan *rp)
+plan (struct PeerPlan *pp,
+      struct GSF_RequestPlan *rp)
 {
-#define N ((double)128.0)
+#define N ((double) 128.0)
   /**
    * Running average delay we currently impose.
    */
@@ -252,28 +255,28 @@ plan(struct PeerPlan *pp,
   struct GSF_PendingRequestData *prd;
   struct GNUNET_TIME_Relative delay;
 
-  GNUNET_assert(rp->pp == pp);
-  GNUNET_STATISTICS_set(GSF_stats,
-                        gettext_noop("# average retransmission delay (ms)"),
-                        total_delay * 1000LL / plan_count, GNUNET_NO);
-  prd = GSF_pending_request_get_data_(rp->pe_head->pr);
+  GNUNET_assert (rp->pp == pp);
+  GNUNET_STATISTICS_set (GSF_stats,
+                         gettext_noop ("# average retransmission delay (ms)"),
+                         total_delay * 1000LL / plan_count, GNUNET_NO);
+  prd = GSF_pending_request_get_data_ (rp->pe_head->pr);
 
   if (rp->transmission_counter < 8)
     delay =
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-                                    rp->transmission_counter);
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     rp->transmission_counter);
   else if (rp->transmission_counter < 32)
     delay =
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-                                    8 +
-                                    (1LL << (rp->transmission_counter - 8)));
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     8
+                                     + (1LL << (rp->transmission_counter - 8)));
   else
     delay =
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-                                    8 + (1LL << 24));
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     8 + (1LL << 24));
   delay.rel_value_us =
-    GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                             delay.rel_value_us + 1);
+    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                              delay.rel_value_us + 1);
   /* Add 0.01 to avg_delay to avoid division-by-zero later */
   avg_delay = (((avg_delay * (N - 1.0)) + delay.rel_value_us) / N) + 0.01;
 
@@ -299,36 +302,37 @@ plan(struct PeerPlan *pp,
    * Note: M_PI_4 = PI/4 = arctan(1)
    */
   rp->priority =
-    round((GSF_current_priorities +
-           1.0) * atan(delay.rel_value_us / avg_delay)) / M_PI_4;
+    round ((GSF_current_priorities
+            + 1.0) * atan (delay.rel_value_us / avg_delay)) / M_PI_4;
   /* Note: usage of 'round' and 'atan' requires -lm */
 
   if (rp->transmission_counter != 0)
     delay.rel_value_us += TTL_DECREMENT * 1000;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Considering (re)transmission number %u in %s\n",
-             (unsigned int)rp->transmission_counter,
-             GNUNET_STRINGS_relative_time_to_string(delay,
-                                                    GNUNET_YES));
-  rp->earliest_transmission = GNUNET_TIME_relative_to_absolute(delay);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Earliest (re)transmission for `%s' in %us\n",
-             GNUNET_h2s(&prd->query),
-             rp->transmission_counter);
-  GNUNET_assert(rp->hn == NULL);
-  if (0 == GNUNET_TIME_absolute_get_remaining(rp->earliest_transmission).rel_value_us)
-    rp->hn = GNUNET_CONTAINER_heap_insert(pp->priority_heap,
-                                          rp,
-                                          rp->priority);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Considering (re)transmission number %u in %s\n",
+              (unsigned int) rp->transmission_counter,
+              GNUNET_STRINGS_relative_time_to_string (delay,
+                                                      GNUNET_YES));
+  rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Earliest (re)transmission for `%s' in %us\n",
+              GNUNET_h2s (&prd->query),
+              rp->transmission_counter);
+  GNUNET_assert (rp->hn == NULL);
+  if (0 == GNUNET_TIME_absolute_get_remaining (
+        rp->earliest_transmission).rel_value_us)
+    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
+                                           rp,
+                                           rp->priority);
   else
     rp->hn =
-      GNUNET_CONTAINER_heap_insert(pp->delay_heap,
-                                   rp,
-                                   rp->earliest_transmission.abs_value_us);
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap_contains_value(pp->plan_map,
-                                                             get_rp_key(rp),
-                                                             rp));
+      GNUNET_CONTAINER_heap_insert (pp->delay_heap,
+                                    rp,
+                                    rp->earliest_transmission.abs_value_us);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_contains_value (pp->plan_map,
+                                                               get_rp_key (rp),
+                                                               rp));
 #undef N
 }
 
@@ -340,7 +344,7 @@ plan(struct PeerPlan *pp,
  * @return pending request with highest TTL
  */
 struct GSF_PendingRequest *
-get_latest(const struct GSF_RequestPlan *rp)
+get_latest (const struct GSF_RequestPlan *rp)
 {
   struct GSF_PendingRequest *ret;
   struct GSF_PendingRequestPlanBijection *bi;
@@ -351,18 +355,18 @@ get_latest(const struct GSF_RequestPlan *rp)
   if (NULL == bi)
     return NULL; /* should never happen */
   ret = bi->pr;
-  rprd = GSF_pending_request_get_data_(ret);
+  rprd = GSF_pending_request_get_data_ (ret);
   for (bi = bi->next_PE; NULL != bi; bi = bi->next_PE)
+  {
+    GNUNET_break (GNUNET_YES ==
+                  GSF_pending_request_test_active_ (bi->pr));
+    prd = GSF_pending_request_get_data_ (bi->pr);
+    if (prd->ttl.abs_value_us > rprd->ttl.abs_value_us)
     {
-      GNUNET_break(GNUNET_YES ==
-                   GSF_pending_request_test_active_(bi->pr));
-      prd = GSF_pending_request_get_data_(bi->pr);
-      if (prd->ttl.abs_value_us > rprd->ttl.abs_value_us)
-        {
-          ret = bi->pr;
-          rprd = prd;
-        }
+      ret = bi->pr;
+      rprd = prd;
     }
+  }
   return ret;
 }
 
@@ -373,100 +377,102 @@ get_latest(const struct GSF_RequestPlan *rp)
  * @param cls the `struct PeerPlan`
  */
 static void
-schedule_peer_transmission(void *cls)
+schedule_peer_transmission (void *cls)
 {
   struct PeerPlan *pp = cls;
   struct GSF_RequestPlan *rp;
   struct GNUNET_TIME_Relative delay;
 
   if (NULL != pp->task)
-    {
-      pp->task = NULL;
-    }
+  {
+    pp->task = NULL;
+  }
   else
-    {
-      GNUNET_assert(NULL != pp->env);
-      pp->env = NULL;
-    }
+  {
+    GNUNET_assert (NULL != pp->env);
+    pp->env = NULL;
+  }
   /* move ready requests to priority queue */
-  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek(pp->delay_heap))) &&
+  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&
          (0 == GNUNET_TIME_absolute_get_remaining
             (rp->earliest_transmission).rel_value_us))
+  {
+    GNUNET_assert (rp == GNUNET_CONTAINER_heap_remove_root (pp->delay_heap));
+    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
+                                           rp,
+                                           rp->priority);
+  }
+  if (0 == GNUNET_CONTAINER_heap_get_size (pp->priority_heap))
+  {
+    /* priority heap (still) empty, check for delay... */
+    rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap);
+    if (NULL == rp)
     {
-      GNUNET_assert(rp == GNUNET_CONTAINER_heap_remove_root(pp->delay_heap));
-      rp->hn = GNUNET_CONTAINER_heap_insert(pp->priority_heap,
-                                            rp,
-                                            rp->priority);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "No active requests for plan %p.\n",
+                  pp);
+      return;                   /* both queues empty */
     }
-  if (0 == GNUNET_CONTAINER_heap_get_size(pp->priority_heap))
-    {
-      /* priority heap (still) empty, check for delay... */
-      rp = GNUNET_CONTAINER_heap_peek(pp->delay_heap);
-      if (NULL == rp)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "No active requests for plan %p.\n",
-                     pp);
-          return;               /* both queues empty */
-        }
-      delay = GNUNET_TIME_absolute_get_remaining(rp->earliest_transmission);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Sleeping for %s before retrying requests on plan %p.\n",
-                 GNUNET_STRINGS_relative_time_to_string(delay,
+    delay = GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sleeping for %s before retrying requests on plan %p.\n",
+                GNUNET_STRINGS_relative_time_to_string (delay,
                                                         GNUNET_YES),
-                 pp);
-      GNUNET_STATISTICS_set(GSF_stats,
-                            gettext_noop("# delay heap timeout (ms)"),
-                            delay.rel_value_us / 1000LL, GNUNET_NO);
-
-      pp->task
-        = GNUNET_SCHEDULER_add_at(rp->earliest_transmission,
-                                  &schedule_peer_transmission,
-                                  pp);
-      return;
-    }
+                pp);
+    GNUNET_STATISTICS_set (GSF_stats,
+                           gettext_noop ("# delay heap timeout (ms)"),
+                           delay.rel_value_us / 1000LL, GNUNET_NO);
+
+    pp->task
+      = GNUNET_SCHEDULER_add_at (rp->earliest_transmission,
+                                 &schedule_peer_transmission,
+                                 pp);
+    return;
+  }
 #if INSANE_STATISTICS
-  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);
 #endif
   /* process from priority heap */
-  rp = GNUNET_CONTAINER_heap_remove_root(pp->priority_heap);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Executing query plan %p\n",
-             rp);
-  GNUNET_assert(NULL != rp);
+  rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Executing query plan %p\n",
+              rp);
+  GNUNET_assert (NULL != rp);
   rp->hn = NULL;
-  rp->last_transmission = GNUNET_TIME_absolute_get();
+  rp->last_transmission = GNUNET_TIME_absolute_get ();
   rp->transmission_counter++;
   total_delay++;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Executing plan %p executed %u times, planning retransmission\n",
-             rp,
-             rp->transmission_counter);
-  GNUNET_assert(NULL == pp->env);
-  pp->env = GSF_pending_request_get_message_(get_latest(rp));
-  GNUNET_MQ_notify_sent(pp->env,
-                        &schedule_peer_transmission,
-                        pp);
-  GSF_peer_transmit_(pp->cp,
-                     GNUNET_YES,
-                     rp->priority,
-                     pp->env);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# query messages sent to other peers"),
-                           1,
-                           GNUNET_NO);
-  plan(pp,
-       rp);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Executing plan %p executed %u times, planning retransmission\n",
+              rp,
+              rp->transmission_counter);
+  GNUNET_assert (NULL == pp->env);
+  pp->env = GSF_pending_request_get_message_ (get_latest (rp));
+  GNUNET_MQ_notify_sent (pp->env,
+                         &schedule_peer_transmission,
+                         pp);
+  GSF_peer_transmit_ (pp->cp,
+                      GNUNET_YES,
+                      rp->priority,
+                      pp->env);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop (
+                              "# query messages sent to other peers"),
+                            1,
+                            GNUNET_NO);
+  plan (pp,
+        rp);
 }
 
 
 /**
  * Closure for merge_pr().
  */
-struct MergeContext {
+struct MergeContext
+{
   /**
    * Request we are trying to merge.
    */
@@ -490,9 +496,9 @@ struct MergeContext {
  *         #GNUNET_NO if not (merge success)
  */
 static int
-merge_pr(void *cls,
-         const struct GNUNET_HashCode *query,
-         void *element)
+merge_pr (void *cls,
+          const struct GNUNET_HashCode *query,
+          void *element)
 {
   struct MergeContext *mpr = cls;
   struct GSF_RequestPlan *rp = element;
@@ -500,44 +506,44 @@ merge_pr(void *cls,
   struct GSF_PendingRequestPlanBijection *bi;
   struct GSF_PendingRequest *latest;
 
-  GNUNET_break(GNUNET_YES ==
-               GSF_pending_request_test_active_(mpr->pr));
+  GNUNET_break (GNUNET_YES ==
+                GSF_pending_request_test_active_ (mpr->pr));
   if (GNUNET_OK !=
-      GSF_pending_request_is_compatible_(mpr->pr,
-                                         rp->pe_head->pr))
+      GSF_pending_request_is_compatible_ (mpr->pr,
+                                          rp->pe_head->pr))
     return GNUNET_YES;
   /* merge new request with existing request plan */
-  bi = GNUNET_new(struct GSF_PendingRequestPlanBijection);
+  bi = GNUNET_new (struct GSF_PendingRequestPlanBijection);
   bi->rp = rp;
   bi->pr = mpr->pr;
-  prd = GSF_pending_request_get_data_(mpr->pr);
-  GNUNET_CONTAINER_MDLL_insert(PR,
-                               prd->pr_head,
-                               prd->pr_tail,
-                               bi);
-  GNUNET_CONTAINER_MDLL_insert(PE,
-                               rp->pe_head,
-                               rp->pe_tail,
-                               bi);
+  prd = GSF_pending_request_get_data_ (mpr->pr);
+  GNUNET_CONTAINER_MDLL_insert (PR,
+                                prd->pr_head,
+                                prd->pr_tail,
+                                bi);
+  GNUNET_CONTAINER_MDLL_insert (PE,
+                                rp->pe_head,
+                                rp->pe_tail,
+                                bi);
   mpr->merged = GNUNET_YES;
 #if INSANE_STATISTICS
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# requests merged"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# requests merged"),
+                            1,
+                            GNUNET_NO);
 #endif
-  latest = get_latest(rp);
-  if (GSF_pending_request_get_data_(latest)->ttl.abs_value_us <
+  latest = get_latest (rp);
+  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value_us <
       prd->ttl.abs_value_us)
-    {
+  {
 #if INSANE_STATISTICS
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# requests refreshed"),
-                               1,
-                               GNUNET_NO);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# requests refreshed"),
+                              1,
+                              GNUNET_NO);
 #endif
-      rp->transmission_counter = 0;     /* reset */
-    }
+    rp->transmission_counter = 0;       /* reset */
+  }
   return GNUNET_NO;
 }
 
@@ -549,8 +555,8 @@ merge_pr(void *cls,
  * @param pr request with the entry
  */
 void
-GSF_plan_add_(struct GSF_ConnectedPeer *cp,
-              struct GSF_PendingRequest *pr)
+GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
+               struct GSF_PendingRequest *pr)
 {
   const struct GNUNET_PeerIdentity *id;
   struct PeerPlan *pp;
@@ -559,66 +565,66 @@ GSF_plan_add_(struct GSF_ConnectedPeer *cp,
   struct GSF_PendingRequestPlanBijection *bi;
   struct MergeContext mpc;
 
-  GNUNET_assert(GNUNET_YES ==
-                GSF_pending_request_test_active_(pr));
-  GNUNET_assert(NULL != cp);
-  id = GSF_connected_peer_get_identity2_(cp);
-  pp = GNUNET_CONTAINER_multipeermap_get(plans, id);
+  GNUNET_assert (GNUNET_YES ==
+                 GSF_pending_request_test_active_ (pr));
+  GNUNET_assert (NULL != cp);
+  id = GSF_connected_peer_get_identity2_ (cp);
+  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
   if (NULL == pp)
-    {
-      pp = GNUNET_new(struct PeerPlan);
-      pp->plan_map = GNUNET_CONTAINER_multihashmap_create(128, GNUNET_NO);
-      pp->priority_heap =
-        GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MAX);
-      pp->delay_heap =
-        GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
-      pp->cp = cp;
-      GNUNET_assert(GNUNET_OK ==
-                    GNUNET_CONTAINER_multipeermap_put(plans,
+  {
+    pp = GNUNET_new (struct PeerPlan);
+    pp->plan_map = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_NO);
+    pp->priority_heap =
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MAX);
+    pp->delay_heap =
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+    pp->cp = cp;
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONTAINER_multipeermap_put (plans,
                                                       id,
                                                       pp,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
-      pp->task = GNUNET_SCHEDULER_add_now(&schedule_peer_transmission,
-                                          pp);
-    }
+    pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission,
+                                         pp);
+  }
   mpc.merged = GNUNET_NO;
   mpc.pr = pr;
-  prd = GSF_pending_request_get_data_(pr);
-  GNUNET_CONTAINER_multihashmap_get_multiple(pp->plan_map,
-                                             &prd->query,
-                                             &merge_pr,
-                                             &mpc);
+  prd = GSF_pending_request_get_data_ (pr);
+  GNUNET_CONTAINER_multihashmap_get_multiple (pp->plan_map,
+                                              &prd->query,
+                                              &merge_pr,
+                                              &mpc);
   if (GNUNET_NO != mpc.merged)
     return;
   plan_count++;
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# query plan entries"),
-                           1,
-                           GNUNET_NO);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Planning transmission of query `%s' to peer `%s'\n",
-             GNUNET_h2s(&prd->query),
-             GNUNET_i2s(id));
-  rp = GNUNET_new(struct GSF_RequestPlan);
-  bi = GNUNET_new(struct GSF_PendingRequestPlanBijection);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# query plan entries"),
+                            1,
+                            GNUNET_NO);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Planning transmission of query `%s' to peer `%s'\n",
+              GNUNET_h2s (&prd->query),
+              GNUNET_i2s (id));
+  rp = GNUNET_new (struct GSF_RequestPlan);
+  bi = GNUNET_new (struct GSF_PendingRequestPlanBijection);
   bi->rp = rp;
   bi->pr = pr;
-  GNUNET_CONTAINER_MDLL_insert(PR,
-                               prd->pr_head,
-                               prd->pr_tail,
-                               bi);
-  GNUNET_CONTAINER_MDLL_insert(PE,
-                               rp->pe_head,
-                               rp->pe_tail,
-                               bi);
+  GNUNET_CONTAINER_MDLL_insert (PR,
+                                prd->pr_head,
+                                prd->pr_tail,
+                                bi);
+  GNUNET_CONTAINER_MDLL_insert (PE,
+                                rp->pe_head,
+                                rp->pe_tail,
+                                bi);
   rp->pp = pp;
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap_put(pp->plan_map,
-                                                  get_rp_key(rp),
-                                                  rp,
-                                                  GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  plan(pp,
-       rp);
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multihashmap_put (pp->plan_map,
+                                                    get_rp_key (rp),
+                                                    rp,
+                                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
+  plan (pp,
+        rp);
 }
 
 
@@ -629,7 +635,7 @@ GSF_plan_add_(struct GSF_ConnectedPeer *cp,
  * @param cp connected peer
  */
 void
-GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp)
+GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
 {
   const struct GNUNET_PeerIdentity *id;
   struct PeerPlan *pp;
@@ -637,70 +643,70 @@ GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp)
   struct GSF_PendingRequestData *prd;
   struct GSF_PendingRequestPlanBijection *bi;
 
-  id = GSF_connected_peer_get_identity2_(cp);
-  pp = GNUNET_CONTAINER_multipeermap_get(plans, id);
+  id = GSF_connected_peer_get_identity2_ (cp);
+  pp = GNUNET_CONTAINER_multipeermap_get (plans, id);
   if (NULL == pp)
     return;                     /* nothing was ever planned for this peer */
-  GNUNET_assert(GNUNET_YES ==
-                GNUNET_CONTAINER_multipeermap_remove(plans, id,
-                                                     pp));
+  GNUNET_assert (GNUNET_YES ==
+                 GNUNET_CONTAINER_multipeermap_remove (plans, id,
+                                                       pp));
   if (NULL != pp->task)
+  {
+    GNUNET_SCHEDULER_cancel (pp->task);
+    pp->task = NULL;
+  }
+  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));
+    while (NULL != (bi = rp->pe_head))
     {
-      GNUNET_SCHEDULER_cancel(pp->task);
-      pp->task = NULL;
+      GNUNET_CONTAINER_MDLL_remove (PE,
+                                    rp->pe_head,
+                                    rp->pe_tail,
+                                    bi);
+      prd = GSF_pending_request_get_data_ (bi->pr);
+      GNUNET_CONTAINER_MDLL_remove (PR,
+                                    prd->pr_head,
+                                    prd->pr_tail,
+                                    bi);
+      GNUNET_free (bi);
     }
-  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),
+    plan_count--;
+    GNUNET_free (rp);
+  }
+  GNUNET_CONTAINER_heap_destroy (pp->priority_heap);
+  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));
-      while (NULL != (bi = rp->pe_head))
-        {
-          GNUNET_CONTAINER_MDLL_remove(PE,
-                                       rp->pe_head,
-                                       rp->pe_tail,
-                                       bi);
-          prd = GSF_pending_request_get_data_(bi->pr);
-          GNUNET_CONTAINER_MDLL_remove(PR,
-                                       prd->pr_head,
-                                       prd->pr_tail,
-                                       bi);
-          GNUNET_free(bi);
-        }
-      plan_count--;
-      GNUNET_free(rp);
-    }
-  GNUNET_CONTAINER_heap_destroy(pp->priority_heap);
-  while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root(pp->delay_heap)))
+    while (NULL != (bi = rp->pe_head))
     {
-      GNUNET_break(GNUNET_YES ==
-                   GNUNET_CONTAINER_multihashmap_remove(pp->plan_map,
-                                                        get_rp_key(rp),
-                                                        rp));
-      while (NULL != (bi = rp->pe_head))
-        {
-          prd = GSF_pending_request_get_data_(bi->pr);
-          GNUNET_CONTAINER_MDLL_remove(PE,
-                                       rp->pe_head,
-                                       rp->pe_tail,
-                                       bi);
-          GNUNET_CONTAINER_MDLL_remove(PR,
-                                       prd->pr_head,
-                                       prd->pr_tail,
-                                       bi);
-          GNUNET_free(bi);
-        }
-      plan_count--;
-      GNUNET_free(rp);
+      prd = GSF_pending_request_get_data_ (bi->pr);
+      GNUNET_CONTAINER_MDLL_remove (PE,
+                                    rp->pe_head,
+                                    rp->pe_tail,
+                                    bi);
+      GNUNET_CONTAINER_MDLL_remove (PR,
+                                    prd->pr_head,
+                                    prd->pr_tail,
+                                    bi);
+      GNUNET_free (bi);
     }
-  GNUNET_STATISTICS_set(GSF_stats,
-                        gettext_noop("# query plan entries"),
-                        plan_count,
-                        GNUNET_NO);
-  GNUNET_CONTAINER_heap_destroy(pp->delay_heap);
-  GNUNET_CONTAINER_multihashmap_destroy(pp->plan_map);
-  GNUNET_free(pp);
+    plan_count--;
+    GNUNET_free (rp);
+  }
+  GNUNET_STATISTICS_set (GSF_stats,
+                         gettext_noop ("# query plan entries"),
+                         plan_count,
+                         GNUNET_NO);
+  GNUNET_CONTAINER_heap_destroy (pp->delay_heap);
+  GNUNET_CONTAINER_multihashmap_destroy (pp->plan_map);
+  GNUNET_free (pp);
 }
 
 
@@ -714,23 +720,27 @@ GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp)
  * @return #GNUNET_YES if @a result was changed, #GNUNET_NO otherwise.
  */
 int
-GSF_request_plan_reference_get_last_transmission_(struct GSF_PendingRequestPlanBijection *pr_head,
-                                                  struct GSF_ConnectedPeer *sender,
-                                                  struct GNUNET_TIME_Absolute *result)
+GSF_request_plan_reference_get_last_transmission_ (struct
+                                                   GSF_PendingRequestPlanBijection
+                                                   *pr_head,
+                                                   struct GSF_ConnectedPeer *
+                                                   sender,
+                                                   struct GNUNET_TIME_Absolute *
+                                                   result)
 {
   struct GSF_PendingRequestPlanBijection *bi;
 
   for (bi = pr_head; NULL != bi; bi = bi->next_PR)
+  {
+    if (bi->rp->pp->cp == sender)
     {
-      if (bi->rp->pp->cp == sender)
-        {
-          if (0 == bi->rp->last_transmission.abs_value_us)
-            *result = GNUNET_TIME_UNIT_FOREVER_ABS;
-          else
-            *result = bi->rp->last_transmission;
-          return GNUNET_YES;
-        }
+      if (0 == bi->rp->last_transmission.abs_value_us)
+        *result = GNUNET_TIME_UNIT_FOREVER_ABS;
+      else
+        *result = bi->rp->last_transmission;
+      return GNUNET_YES;
     }
+  }
   return GNUNET_NO;
 }
 
@@ -742,41 +752,41 @@ GSF_request_plan_reference_get_last_transmission_(struct GSF_PendingRequestPlanB
  * @param pr request that is done
  */
 void
-GSF_plan_notify_request_done_(struct GSF_PendingRequest *pr)
+GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
 {
   struct GSF_RequestPlan *rp;
   struct GSF_PendingRequestData *prd;
   struct GSF_PendingRequestPlanBijection *bi;
 
-  prd = GSF_pending_request_get_data_(pr);
+  prd = GSF_pending_request_get_data_ (pr);
   while (NULL != (bi = prd->pr_head))
+  {
+    rp = bi->rp;
+    GNUNET_CONTAINER_MDLL_remove (PR,
+                                  prd->pr_head,
+                                  prd->pr_tail,
+                                  bi);
+    GNUNET_CONTAINER_MDLL_remove (PE,
+                                  rp->pe_head,
+                                  rp->pe_tail,
+                                  bi);
+    GNUNET_assert (bi->pr == pr);
+    if (NULL == rp->pe_head)
     {
-      rp = bi->rp;
-      GNUNET_CONTAINER_MDLL_remove(PR,
-                                   prd->pr_head,
-                                   prd->pr_tail,
-                                   bi);
-      GNUNET_CONTAINER_MDLL_remove(PE,
-                                   rp->pe_head,
-                                   rp->pe_tail,
-                                   bi);
-      GNUNET_assert(bi->pr == pr);
-      if (NULL == rp->pe_head)
-        {
-          GNUNET_CONTAINER_heap_remove_node(rp->hn);
-          plan_count--;
-          GNUNET_break(GNUNET_YES ==
-                       GNUNET_CONTAINER_multihashmap_remove(rp->pp->plan_map,
-                                                            &prd->query,
-                                                            rp));
-          GNUNET_free(rp);
-        }
-      GNUNET_free(bi);
+      GNUNET_CONTAINER_heap_remove_node (rp->hn);
+      plan_count--;
+      GNUNET_break (GNUNET_YES ==
+                    GNUNET_CONTAINER_multihashmap_remove (rp->pp->plan_map,
+                                                          &prd->query,
+                                                          rp));
+      GNUNET_free (rp);
     }
-  GNUNET_STATISTICS_set(GSF_stats,
-                        gettext_noop("# query plan entries"),
-                        plan_count,
-                        GNUNET_NO);
+    GNUNET_free (bi);
+  }
+  GNUNET_STATISTICS_set (GSF_stats,
+                         gettext_noop ("# query plan entries"),
+                         plan_count,
+                         GNUNET_NO);
 }
 
 
@@ -784,10 +794,10 @@ GSF_plan_notify_request_done_(struct GSF_PendingRequest *pr)
  * Initialize plan subsystem.
  */
 void
-GSF_plan_init()
+GSF_plan_init ()
 {
-  plans = GNUNET_CONTAINER_multipeermap_create(256,
-                                               GNUNET_YES);
+  plans = GNUNET_CONTAINER_multipeermap_create (256,
+                                                GNUNET_YES);
 }
 
 
@@ -795,10 +805,10 @@ GSF_plan_init()
  * Shutdown plan subsystem.
  */
 void
-GSF_plan_done()
+GSF_plan_done ()
 {
-  GNUNET_assert(0 == GNUNET_CONTAINER_multipeermap_size(plans));
-  GNUNET_CONTAINER_multipeermap_destroy(plans);
+  GNUNET_assert (0 == GNUNET_CONTAINER_multipeermap_size (plans));
+  GNUNET_CONTAINER_multipeermap_destroy (plans);
 }
 
 
diff --git a/src/fs/gnunet-service-fs_pe.h b/src/fs/gnunet-service-fs_pe.h
index dfad71be9..d532b6b71 100644
--- a/src/fs/gnunet-service-fs_pe.h
+++ b/src/fs/gnunet-service-fs_pe.h
@@ -36,8 +36,8 @@
  * @param pr request with the entry
  */
 void
-GSF_plan_add_(struct GSF_ConnectedPeer *cp,
-              struct GSF_PendingRequest *pr);
+GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
+               struct GSF_PendingRequest *pr);
 
 
 /**
@@ -47,7 +47,7 @@ GSF_plan_add_(struct GSF_ConnectedPeer *cp,
  * @param cp connected peer
  */
 void
-GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp);
+GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp);
 
 
 /**
@@ -57,7 +57,7 @@ GSF_plan_notify_peer_disconnect_(const struct GSF_ConnectedPeer *cp);
  * @param pr request that is done
  */
 void
-GSF_plan_notify_request_done_(struct GSF_PendingRequest *pr);
+GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr);
 
 /**
  * Get the last transmission attempt time for the request plan list
@@ -69,22 +69,26 @@ GSF_plan_notify_request_done_(struct GSF_PendingRequest *pr);
  * @return GNUNET_YES if 'result' was changed, GNUNET_NO otherwise.
  */
 int
-GSF_request_plan_reference_get_last_transmission_(struct GSF_PendingRequestPlanBijection *pr_head,
-                                                  struct GSF_ConnectedPeer *sender,
-                                                  struct GNUNET_TIME_Absolute *result);
+GSF_request_plan_reference_get_last_transmission_ (struct
+                                                   GSF_PendingRequestPlanBijection
+                                                   *pr_head,
+                                                   struct GSF_ConnectedPeer *
+                                                   sender,
+                                                   struct GNUNET_TIME_Absolute *
+                                                   result);
 
 /**
  * Initialize plan subsystem.
  */
 void
-GSF_plan_init(void);
+GSF_plan_init (void);
 
 
 /**
  * Shutdown plan subsystem.
  */
 void
-GSF_plan_done(void);
+GSF_plan_done (void);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_pr.c b/src/fs/gnunet-service-fs_pr.c
index 90587cfa0..9c558674b 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -74,7 +74,8 @@
 /**
  * An active request.
  */
-struct GSF_PendingRequest {
+struct GSF_PendingRequest
+{
   /**
    * Public data for the request.
    */
@@ -246,31 +247,32 @@ static unsigned long long max_pending_requests = (32 * 1024);
  * @param pr request for which the BF is to be recomputed
  */
 static void
-refresh_bloomfilter(enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr)
+refresh_bloomfilter (enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr)
 {
   if (NULL != pr->bg)
-    {
-      GNUNET_BLOCK_group_destroy(pr->bg);
-      pr->bg = NULL;
-    }
+  {
+    GNUNET_BLOCK_group_destroy (pr->bg);
+    pr->bg = NULL;
+  }
   if (GNUNET_BLOCK_TYPE_FS_UBLOCK != type)
     return; /* no need */
   pr->bg =
-    GNUNET_BLOCK_group_create(GSF_block_ctx,
-                              type,
-                              GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                                       UINT32_MAX),
-                              NULL,
-                              0,
-                              "seen-set-size",
-                              pr->replies_seen_count,
-                              NULL);
+    GNUNET_BLOCK_group_create (GSF_block_ctx,
+                               type,
+                               GNUNET_CRYPTO_random_u32 (
+                                 GNUNET_CRYPTO_QUALITY_WEAK,
+                                 UINT32_MAX),
+                               NULL,
+                               0,
+                               "seen-set-size",
+                               pr->replies_seen_count,
+                               NULL);
   if (NULL == pr->bg)
     return;
-  GNUNET_break(GNUNET_OK ==
-               GNUNET_BLOCK_group_set_seen(pr->bg,
-                                           pr->replies_seen,
-                                           pr->replies_seen_count));
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_BLOCK_group_set_seen (pr->bg,
+                                             pr->replies_seen,
+                                             pr->replies_seen_count));
 }
 
 
@@ -296,129 +298,129 @@ refresh_bloomfilter(enum GNUNET_BLOCK_Type type, struct GSF_PendingRequest *pr)
  * @return handle for the new pending request
  */
 struct GSF_PendingRequest *
-GSF_pending_request_create_(enum GSF_PendingRequestOptions options,
-                            enum GNUNET_BLOCK_Type type,
-                            const struct GNUNET_HashCode *query,
-                            const struct GNUNET_PeerIdentity *target,
-                            const char *bf_data,
-                            size_t bf_size,
-                            uint32_t mingle,
-                            uint32_t anonymity_level,
-                            uint32_t priority,
-                            int32_t ttl,
-                            GNUNET_PEER_Id sender_pid,
-                            GNUNET_PEER_Id origin_pid,
-                            const struct GNUNET_HashCode *replies_seen,
-                            unsigned int replies_seen_count,
-                            GSF_PendingRequestReplyHandler rh,
-                            void *rh_cls)
+GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
+                             enum GNUNET_BLOCK_Type type,
+                             const struct GNUNET_HashCode *query,
+                             const struct GNUNET_PeerIdentity *target,
+                             const char *bf_data,
+                             size_t bf_size,
+                             uint32_t mingle,
+                             uint32_t anonymity_level,
+                             uint32_t priority,
+                             int32_t ttl,
+                             GNUNET_PEER_Id sender_pid,
+                             GNUNET_PEER_Id origin_pid,
+                             const struct GNUNET_HashCode *replies_seen,
+                             unsigned int replies_seen_count,
+                             GSF_PendingRequestReplyHandler rh,
+                             void *rh_cls)
 {
   struct GSF_PendingRequest *pr;
   struct GSF_PendingRequest *dpr;
   size_t extra;
   struct GNUNET_HashCode *eptr;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Creating request handle for `%s' of type %d\n",
-             GNUNET_h2s(query),
-             type);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Creating request handle for `%s' of type %d\n",
+              GNUNET_h2s (query),
+              type);
 #if INSANE_STATISTICS
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Pending requests created"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Pending requests created"),
+                            1,
+                            GNUNET_NO);
 #endif
   extra = 0;
   if (NULL != target)
     extra += sizeof(struct GNUNET_PeerIdentity);
-  pr = GNUNET_malloc(sizeof(struct GSF_PendingRequest) + extra);
+  pr = GNUNET_malloc (sizeof(struct GSF_PendingRequest) + extra);
   pr->public_data.query = *query;
-  eptr = (struct GNUNET_HashCode *)&pr[1];
+  eptr = (struct GNUNET_HashCode *) &pr[1];
   if (NULL != target)
-    {
-      pr->public_data.target = (struct GNUNET_PeerIdentity *)eptr;
-      GNUNET_memcpy(eptr, target, sizeof(struct GNUNET_PeerIdentity));
-    }
+  {
+    pr->public_data.target = (struct GNUNET_PeerIdentity *) eptr;
+    GNUNET_memcpy (eptr, target, sizeof(struct GNUNET_PeerIdentity));
+  }
   pr->public_data.anonymity_level = anonymity_level;
   pr->public_data.priority = priority;
   pr->public_data.original_priority = priority;
   pr->public_data.options = options;
   pr->public_data.type = type;
-  pr->public_data.start_time = GNUNET_TIME_absolute_get();
+  pr->public_data.start_time = GNUNET_TIME_absolute_get ();
   pr->sender_pid = sender_pid;
   pr->origin_pid = origin_pid;
   pr->rh = rh;
   pr->rh_cls = rh_cls;
-  GNUNET_assert((sender_pid != 0) || (0 == (options & GSF_PRO_FORWARD_ONLY)));
+  GNUNET_assert ((sender_pid != 0) || (0 == (options & GSF_PRO_FORWARD_ONLY)));
   if (ttl >= 0)
-    pr->public_data.ttl = GNUNET_TIME_relative_to_absolute(
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, (uint32_t)ttl));
+    pr->public_data.ttl = GNUNET_TIME_relative_to_absolute (
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, (uint32_t) ttl));
   else
-    pr->public_data.ttl = GNUNET_TIME_absolute_subtract(
+    pr->public_data.ttl = GNUNET_TIME_absolute_subtract (
       pr->public_data.start_time,
-      GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-                                    (uint32_t)(-ttl)));
+      GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                     (uint32_t) (-ttl)));
   if (replies_seen_count > 0)
-    {
-      pr->replies_seen_size = replies_seen_count;
-      pr->replies_seen =
-        GNUNET_new_array(pr->replies_seen_size, struct GNUNET_HashCode);
-      GNUNET_memcpy(pr->replies_seen,
-                    replies_seen,
-                    replies_seen_count * sizeof(struct GNUNET_HashCode));
-      pr->replies_seen_count = replies_seen_count;
-    }
+  {
+    pr->replies_seen_size = replies_seen_count;
+    pr->replies_seen =
+      GNUNET_new_array (pr->replies_seen_size, struct GNUNET_HashCode);
+    GNUNET_memcpy (pr->replies_seen,
+                   replies_seen,
+                   replies_seen_count * sizeof(struct GNUNET_HashCode));
+    pr->replies_seen_count = replies_seen_count;
+  }
   if ((NULL != bf_data) &&
       (GNUNET_BLOCK_TYPE_FS_UBLOCK == pr->public_data.type))
-    {
-      pr->bg = GNUNET_BLOCK_group_create(GSF_block_ctx,
-                                         pr->public_data.type,
-                                         mingle,
-                                         bf_data,
-                                         bf_size,
-                                         "seen-set-size",
-                                         0,
-                                         NULL);
-    }
+  {
+    pr->bg = GNUNET_BLOCK_group_create (GSF_block_ctx,
+                                        pr->public_data.type,
+                                        mingle,
+                                        bf_data,
+                                        bf_size,
+                                        "seen-set-size",
+                                        0,
+                                        NULL);
+  }
   else if ((replies_seen_count > 0) &&
            (0 != (options & GSF_PRO_BLOOMFILTER_FULL_REFRESH)))
-    {
-      refresh_bloomfilter(pr->public_data.type, pr);
-    }
-  GNUNET_CONTAINER_multihashmap_put(pr_map,
-                                    &pr->public_data.query,
-                                    pr,
-                                    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  {
+    refresh_bloomfilter (pr->public_data.type, pr);
+  }
+  GNUNET_CONTAINER_multihashmap_put (pr_map,
+                                     &pr->public_data.query,
+                                     pr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   if (0 == (options & GSF_PRO_REQUEST_NEVER_EXPIRES))
+  {
+    pr->hnode = GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap,
+                                              pr,
+                                              pr->public_data.ttl.abs_value_us);
+    /* make sure we don't track too many requests */
+    while (GNUNET_CONTAINER_heap_get_size (requests_by_expiration_heap) >
+           max_pending_requests)
     {
-      pr->hnode = GNUNET_CONTAINER_heap_insert(requests_by_expiration_heap,
-                                               pr,
-                                               pr->public_data.ttl.abs_value_us);
-      /* make sure we don't track too many requests */
-      while (GNUNET_CONTAINER_heap_get_size(requests_by_expiration_heap) >
-             max_pending_requests)
-        {
-          dpr = GNUNET_CONTAINER_heap_peek(requests_by_expiration_heap);
-          GNUNET_assert(NULL != dpr);
-          if (pr == dpr)
-            break; /* let the request live briefly... */
-          if (NULL != dpr->rh)
-            dpr->rh(dpr->rh_cls,
-                    GNUNET_BLOCK_EVALUATION_REQUEST_VALID,
-                    dpr,
-                    UINT32_MAX,
-                    GNUNET_TIME_UNIT_FOREVER_ABS,
-                    GNUNET_TIME_UNIT_FOREVER_ABS,
-                    GNUNET_BLOCK_TYPE_ANY,
-                    NULL,
-                    0);
-          GSF_pending_request_cancel_(dpr, GNUNET_YES);
-        }
+      dpr = GNUNET_CONTAINER_heap_peek (requests_by_expiration_heap);
+      GNUNET_assert (NULL != dpr);
+      if (pr == dpr)
+        break;     /* let the request live briefly... */
+      if (NULL != dpr->rh)
+        dpr->rh (dpr->rh_cls,
+                 GNUNET_BLOCK_EVALUATION_REQUEST_VALID,
+                 dpr,
+                 UINT32_MAX,
+                 GNUNET_TIME_UNIT_FOREVER_ABS,
+                 GNUNET_TIME_UNIT_FOREVER_ABS,
+                 GNUNET_BLOCK_TYPE_ANY,
+                 NULL,
+                 0);
+      GSF_pending_request_cancel_ (dpr, GNUNET_YES);
     }
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Pending requests active"),
-                           1,
-                           GNUNET_NO);
+  }
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Pending requests active"),
+                            1,
+                            GNUNET_NO);
   return pr;
 }
 
@@ -429,7 +431,7 @@ GSF_pending_request_create_(enum GSF_PendingRequestOptions options,
  * @return associated public data
  */
 struct GSF_PendingRequestData *
-GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
+GSF_pending_request_get_data_ (struct GSF_PendingRequest *pr)
 {
   return &pr->public_data;
 }
@@ -445,13 +447,13 @@ GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
  * @return #GNUNET_OK if the requests are compatible
  */
 int
-GSF_pending_request_is_compatible_(struct GSF_PendingRequest *pra,
-                                   struct GSF_PendingRequest *prb)
+GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
+                                    struct GSF_PendingRequest *prb)
 {
   if ((pra->public_data.type != prb->public_data.type) ||
-      (0 != memcmp(&pra->public_data.query,
-                   &prb->public_data.query,
-                   sizeof(struct GNUNET_HashCode))))
+      (0 != memcmp (&pra->public_data.query,
+                    &prb->public_data.query,
+                    sizeof(struct GNUNET_HashCode))))
     return GNUNET_NO;
   return GNUNET_OK;
 }
@@ -466,45 +468,45 @@ GSF_pending_request_is_compatible_(struct GSF_PendingRequest *pra,
  * @param replies_seen_count size of the replies_seen array
  */
 void
-GSF_pending_request_update_(struct GSF_PendingRequest *pr,
-                            const struct GNUNET_HashCode *replies_seen,
-                            unsigned int replies_seen_count)
+GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
+                             const struct GNUNET_HashCode *replies_seen,
+                             unsigned int replies_seen_count)
 {
   if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count)
     return; /* integer overflow */
   if (0 != (pr->public_data.options & GSF_PRO_BLOOMFILTER_FULL_REFRESH))
+  {
+    /* we're responsible for the BF, full refresh */
+    if (replies_seen_count + pr->replies_seen_count > pr->replies_seen_size)
+      GNUNET_array_grow (pr->replies_seen,
+                         pr->replies_seen_size,
+                         replies_seen_count + pr->replies_seen_count);
+    GNUNET_memcpy (&pr->replies_seen[pr->replies_seen_count],
+                   replies_seen,
+                   sizeof(struct GNUNET_HashCode) * replies_seen_count);
+    pr->replies_seen_count += replies_seen_count;
+    refresh_bloomfilter (pr->public_data.type, pr);
+  }
+  else
+  {
+    if (NULL == pr->bg)
     {
-      /* we're responsible for the BF, full refresh */
-      if (replies_seen_count + pr->replies_seen_count > pr->replies_seen_size)
-        GNUNET_array_grow(pr->replies_seen,
-                          pr->replies_seen_size,
-                          replies_seen_count + pr->replies_seen_count);
-      GNUNET_memcpy(&pr->replies_seen[pr->replies_seen_count],
-                    replies_seen,
-                    sizeof(struct GNUNET_HashCode) * replies_seen_count);
-      pr->replies_seen_count += replies_seen_count;
-      refresh_bloomfilter(pr->public_data.type, pr);
+      /* we're not the initiator, but the initiator did not give us
+       * any bloom-filter, so we need to create one on-the-fly */
+      refresh_bloomfilter (pr->public_data.type, pr);
     }
-  else
+    else
     {
-      if (NULL == pr->bg)
-        {
-          /* we're not the initiator, but the initiator did not give us
-           * any bloom-filter, so we need to create one on-the-fly */
-          refresh_bloomfilter(pr->public_data.type, pr);
-        }
-      else
-        {
-          GNUNET_break(GNUNET_OK ==
-                       GNUNET_BLOCK_group_set_seen(pr->bg,
-                                                   replies_seen,
-                                                   pr->replies_seen_count));
-        }
+      GNUNET_break (GNUNET_OK ==
+                    GNUNET_BLOCK_group_set_seen (pr->bg,
+                                                 replies_seen,
+                                                 pr->replies_seen_count));
     }
+  }
   if (NULL != pr->gh)
-    GNUNET_DHT_get_filter_known_results(pr->gh,
-                                        replies_seen_count,
-                                        replies_seen);
+    GNUNET_DHT_get_filter_known_results (pr->gh,
+                                         replies_seen_count,
+                                         replies_seen);
 }
 
 
@@ -516,7 +518,7 @@ GSF_pending_request_update_(struct GSF_PendingRequest *pr,
  * @return envelope with the request message
  */
 struct GNUNET_MQ_Envelope *
-GSF_pending_request_get_message_(struct GSF_PendingRequest *pr)
+GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr)
 {
   struct GNUNET_MQ_Envelope *env;
   struct GetMessage *gm;
@@ -531,61 +533,61 @@ GSF_pending_request_get_message_(struct GSF_PendingRequest *pr)
   void *bf_data;
   uint32_t bf_nonce;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Building request message for `%s' of type %d\n",
-             GNUNET_h2s(&pr->public_data.query),
-             pr->public_data.type);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Building request message for `%s' of type %d\n",
+              GNUNET_h2s (&pr->public_data.query),
+              pr->public_data.type);
   k = 0;
   bm = 0;
   do_route = (0 == (pr->public_data.options & GSF_PRO_FORWARD_ONLY));
-  if ((!do_route) && (pr->sender_pid == 0))
-    {
-      GNUNET_break(0);
-      do_route = GNUNET_YES;
-    }
-  if (!do_route)
-    {
-      bm |= GET_MESSAGE_BIT_RETURN_TO;
-      k++;
-    }
+  if ((! do_route) && (pr->sender_pid == 0))
+  {
+    GNUNET_break (0);
+    do_route = GNUNET_YES;
+  }
+  if (! do_route)
+  {
+    bm |= GET_MESSAGE_BIT_RETURN_TO;
+    k++;
+  }
   if (NULL != pr->public_data.target)
-    {
-      bm |= GET_MESSAGE_BIT_TRANSMIT_TO;
-      k++;
-    }
+  {
+    bm |= GET_MESSAGE_BIT_TRANSMIT_TO;
+    k++;
+  }
   if (GNUNET_OK !=
-      GNUNET_BLOCK_group_serialize(pr->bg, &bf_nonce, &bf_data, &bf_size))
-    {
-      bf_size = 0;
-      bf_data = NULL;
-    }
-  env = GNUNET_MQ_msg_extra(gm,
-                            bf_size + k * sizeof(struct GNUNET_PeerIdentity),
-                            GNUNET_MESSAGE_TYPE_FS_GET);
-  gm->type = htonl(pr->public_data.type);
+      GNUNET_BLOCK_group_serialize (pr->bg, &bf_nonce, &bf_data, &bf_size))
+  {
+    bf_size = 0;
+    bf_data = NULL;
+  }
+  env = GNUNET_MQ_msg_extra (gm,
+                             bf_size + k * sizeof(struct GNUNET_PeerIdentity),
+                             GNUNET_MESSAGE_TYPE_FS_GET);
+  gm->type = htonl (pr->public_data.type);
   if (do_route)
-    prio = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                    pr->public_data.priority + 1);
+    prio = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                     pr->public_data.priority + 1);
   else
     prio = 0;
   pr->public_data.priority -= prio;
   pr->public_data.num_transmissions++;
   pr->public_data.respect_offered += prio;
-  gm->priority = htonl(prio);
-  now = GNUNET_TIME_absolute_get();
-  ttl = (int64_t)(pr->public_data.ttl.abs_value_us - now.abs_value_us);
-  gm->ttl = htonl(ttl / 1000LL / 1000LL);
-  gm->filter_mutator = htonl(bf_nonce);
-  gm->hash_bitmap = htonl(bm);
+  gm->priority = htonl (prio);
+  now = GNUNET_TIME_absolute_get ();
+  ttl = (int64_t) (pr->public_data.ttl.abs_value_us - now.abs_value_us);
+  gm->ttl = htonl (ttl / 1000LL / 1000LL);
+  gm->filter_mutator = htonl (bf_nonce);
+  gm->hash_bitmap = htonl (bm);
   gm->query = pr->public_data.query;
-  ext = (struct GNUNET_PeerIdentity *)&gm[1];
+  ext = (struct GNUNET_PeerIdentity *) &gm[1];
   k = 0;
-  if (!do_route)
-    GNUNET_PEER_resolve(pr->sender_pid, &ext[k++]);
+  if (! do_route)
+    GNUNET_PEER_resolve (pr->sender_pid, &ext[k++]);
   if (NULL != pr->public_data.target)
     ext[k++] = *pr->public_data.target;
-  GNUNET_memcpy(&ext[k], bf_data, bf_size);
-  GNUNET_free_non_null(bf_data);
+  GNUNET_memcpy (&ext[k], bf_data, bf_size);
+  GNUNET_free_non_null (bf_data);
   return env;
 }
 
@@ -599,61 +601,61 @@ GSF_pending_request_get_message_(struct GSF_PendingRequest *pr)
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-clean_request(void *cls, const struct GNUNET_HashCode *key, void *value)
+clean_request (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct GSF_PendingRequest *pr = value;
   GSF_LocalLookupContinuation cont;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Cleaning up pending request for `%s'.\n",
-             GNUNET_h2s(key));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Cleaning up pending request for `%s'.\n",
+              GNUNET_h2s (key));
   if (NULL != pr->cadet_request)
-    {
-      pr->cadet_retry_count = CADET_RETRY_MAX;
-      GSF_cadet_query_cancel(pr->cadet_request);
-      pr->cadet_request = NULL;
-    }
+  {
+    pr->cadet_retry_count = CADET_RETRY_MAX;
+    GSF_cadet_query_cancel (pr->cadet_request);
+    pr->cadet_request = NULL;
+  }
   if (NULL != (cont = pr->llc_cont))
-    {
-      pr->llc_cont = NULL;
-      cont(pr->llc_cont_cls, pr, pr->local_result);
-    }
-  GSF_plan_notify_request_done_(pr);
-  GNUNET_free_non_null(pr->replies_seen);
-  GNUNET_BLOCK_group_destroy(pr->bg);
+  {
+    pr->llc_cont = NULL;
+    cont (pr->llc_cont_cls, pr, pr->local_result);
+  }
+  GSF_plan_notify_request_done_ (pr);
+  GNUNET_free_non_null (pr->replies_seen);
+  GNUNET_BLOCK_group_destroy (pr->bg);
   pr->bg = NULL;
-  GNUNET_PEER_change_rc(pr->sender_pid, -1);
+  GNUNET_PEER_change_rc (pr->sender_pid, -1);
   pr->sender_pid = 0;
-  GNUNET_PEER_change_rc(pr->origin_pid, -1);
+  GNUNET_PEER_change_rc (pr->origin_pid, -1);
   pr->origin_pid = 0;
   if (NULL != pr->hnode)
-    {
-      GNUNET_CONTAINER_heap_remove_node(pr->hnode);
-      pr->hnode = NULL;
-    }
+  {
+    GNUNET_CONTAINER_heap_remove_node (pr->hnode);
+    pr->hnode = NULL;
+  }
   if (NULL != pr->qe)
-    {
-      GNUNET_DATASTORE_cancel(pr->qe);
-      pr->qe = NULL;
-    }
+  {
+    GNUNET_DATASTORE_cancel (pr->qe);
+    pr->qe = NULL;
+  }
   if (NULL != pr->gh)
-    {
-      GNUNET_DHT_get_stop(pr->gh);
-      pr->gh = NULL;
-    }
+  {
+    GNUNET_DHT_get_stop (pr->gh);
+    pr->gh = NULL;
+  }
   if (NULL != pr->warn_task)
-    {
-      GNUNET_SCHEDULER_cancel(pr->warn_task);
-      pr->warn_task = NULL;
-    }
-  GNUNET_assert(
+  {
+    GNUNET_SCHEDULER_cancel (pr->warn_task);
+    pr->warn_task = NULL;
+  }
+  GNUNET_assert (
     GNUNET_OK ==
-    GNUNET_CONTAINER_multihashmap_remove(pr_map, &pr->public_data.query, pr));
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Pending requests active"),
-                           -1,
-                           GNUNET_NO);
-  GNUNET_free(pr);
+    GNUNET_CONTAINER_multihashmap_remove (pr_map, &pr->public_data.query, pr));
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Pending requests active"),
+                            -1,
+                            GNUNET_NO);
+  GNUNET_free (pr);
   return GNUNET_YES;
 }
 
@@ -665,49 +667,49 @@ clean_request(void *cls, const struct GNUNET_HashCode *key, void *value)
  * @param full_cleanup fully purge the request
  */
 void
-GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
+GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr, int full_cleanup)
 {
   GSF_LocalLookupContinuation cont;
 
   if (NULL == pr_map)
     return; /* already cleaned up! */
   if (GNUNET_NO == full_cleanup)
+  {
+    /* make request inactive (we're no longer interested in more results),
+     * but do NOT remove from our data-structures, we still need it there
+     * to prevent the request from looping */
+    pr->rh = NULL;
+    if (NULL != pr->cadet_request)
+    {
+      pr->cadet_retry_count = CADET_RETRY_MAX;
+      GSF_cadet_query_cancel (pr->cadet_request);
+      pr->cadet_request = NULL;
+    }
+    if (NULL != (cont = pr->llc_cont))
+    {
+      pr->llc_cont = NULL;
+      cont (pr->llc_cont_cls, pr, pr->local_result);
+    }
+    GSF_plan_notify_request_done_ (pr);
+    if (NULL != pr->qe)
+    {
+      GNUNET_DATASTORE_cancel (pr->qe);
+      pr->qe = NULL;
+    }
+    if (NULL != pr->gh)
     {
-      /* make request inactive (we're no longer interested in more results),
-       * but do NOT remove from our data-structures, we still need it there
-       * to prevent the request from looping */
-      pr->rh = NULL;
-      if (NULL != pr->cadet_request)
-        {
-          pr->cadet_retry_count = CADET_RETRY_MAX;
-          GSF_cadet_query_cancel(pr->cadet_request);
-          pr->cadet_request = NULL;
-        }
-      if (NULL != (cont = pr->llc_cont))
-        {
-          pr->llc_cont = NULL;
-          cont(pr->llc_cont_cls, pr, pr->local_result);
-        }
-      GSF_plan_notify_request_done_(pr);
-      if (NULL != pr->qe)
-        {
-          GNUNET_DATASTORE_cancel(pr->qe);
-          pr->qe = NULL;
-        }
-      if (NULL != pr->gh)
-        {
-          GNUNET_DHT_get_stop(pr->gh);
-          pr->gh = NULL;
-        }
-      if (NULL != pr->warn_task)
-        {
-          GNUNET_SCHEDULER_cancel(pr->warn_task);
-          pr->warn_task = NULL;
-        }
-      return;
+      GNUNET_DHT_get_stop (pr->gh);
+      pr->gh = NULL;
+    }
+    if (NULL != pr->warn_task)
+    {
+      GNUNET_SCHEDULER_cancel (pr->warn_task);
+      pr->warn_task = NULL;
     }
-  GNUNET_assert(GNUNET_YES ==
-                clean_request(NULL, &pr->public_data.query, pr));
+    return;
+  }
+  GNUNET_assert (GNUNET_YES ==
+                 clean_request (NULL, &pr->public_data.query, pr));
 }
 
 
@@ -718,11 +720,11 @@ GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
  * @param cls closure for @a it
  */
 void
-GSF_iterate_pending_requests_(GSF_PendingRequestIterator it, void *cls)
+GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls)
 {
-  GNUNET_CONTAINER_multihashmap_iterate(
+  GNUNET_CONTAINER_multihashmap_iterate (
     pr_map,
-    (GNUNET_CONTAINER_MulitHashMapIteratorCallback)it,
+    (GNUNET_CONTAINER_MulitHashMapIteratorCallback) it,
     cls);
 }
 
@@ -730,7 +732,8 @@ GSF_iterate_pending_requests_(GSF_PendingRequestIterator it, void *cls)
 /**
  * Closure for process_reply() function.
  */
-struct ProcessReplyClosure {
+struct ProcessReplyClosure
+{
   /**
    * The data for the reply.
    */
@@ -791,14 +794,14 @@ struct ProcessReplyClosure {
  * @param pr request that was satisfied
  */
 static void
-update_request_performance_data(struct ProcessReplyClosure *prq,
-                                struct GSF_PendingRequest *pr)
+update_request_performance_data (struct ProcessReplyClosure *prq,
+                                 struct GSF_PendingRequest *pr)
 {
   if (prq->sender == NULL)
     return;
-  GSF_peer_update_performance_(prq->sender,
-                               pr->public_data.start_time,
-                               prq->priority);
+  GSF_peer_update_performance_ (prq->sender,
+                                pr->public_data.start_time,
+                                prq->priority);
 }
 
 
@@ -811,7 +814,7 @@ update_request_performance_data(struct ProcessReplyClosure *prq,
  * @return #GNUNET_YES (we should continue to iterate)
  */
 static int
-process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
+process_reply (void *cls, const struct GNUNET_HashCode *key, void *value)
 {
   struct ProcessReplyClosure *prq = cls;
   struct GSF_PendingRequest *pr = value;
@@ -820,128 +823,128 @@ process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
 
   if (NULL == pr->rh)
     return GNUNET_YES;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Matched result (type %u) for query `%s' with pending request\n",
-             (unsigned int)prq->type,
-             GNUNET_h2s(key));
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# replies received and matched"),
-                           1,
-                           GNUNET_NO);
-  prq->eval = GNUNET_BLOCK_evaluate(GSF_block_ctx,
-                                    prq->type,
-                                    pr->bg,
-                                    prq->eo,
-                                    key,
-                                    NULL,
-                                    0,
-                                    prq->data,
-                                    prq->size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Matched result (type %u) for query `%s' with pending request\n",
+              (unsigned int) prq->type,
+              GNUNET_h2s (key));
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# replies received and matched"),
+                            1,
+                            GNUNET_NO);
+  prq->eval = GNUNET_BLOCK_evaluate (GSF_block_ctx,
+                                     prq->type,
+                                     pr->bg,
+                                     prq->eo,
+                                     key,
+                                     NULL,
+                                     0,
+                                     prq->data,
+                                     prq->size);
   switch (prq->eval)
-    {
-    case GNUNET_BLOCK_EVALUATION_OK_MORE:
-      update_request_performance_data(prq, pr);
-      break;
-
-    case GNUNET_BLOCK_EVALUATION_OK_LAST:
-      /* short cut: stop processing early, no BF-update, etc. */
-      update_request_performance_data(prq, pr);
-      GNUNET_LOAD_update(GSF_rt_entry_lifetime,
-                         GNUNET_TIME_absolute_get_duration(
-                           pr->public_data.start_time)
-                         .rel_value_us);
-      if (GNUNET_YES !=
-          GSF_request_plan_reference_get_last_transmission_(pr->public_data
-                                                            .pr_head,
-                                                            prq->sender,
-                                                            &last_transmission))
-        last_transmission.abs_value_us =
-          GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
-      /* pass on to other peers / local clients */
-      pr->rh(pr->rh_cls,
-             prq->eval,
-             pr,
-             prq->anonymity_level,
-             prq->expiration,
-             last_transmission,
-             prq->type,
-             prq->data,
-             prq->size);
-      return GNUNET_YES;
-
-    case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
+  {
+  case GNUNET_BLOCK_EVALUATION_OK_MORE:
+    update_request_performance_data (prq, pr);
+    break;
+
+  case GNUNET_BLOCK_EVALUATION_OK_LAST:
+    /* short cut: stop processing early, no BF-update, etc. */
+    update_request_performance_data (prq, pr);
+    GNUNET_LOAD_update (GSF_rt_entry_lifetime,
+                        GNUNET_TIME_absolute_get_duration (
+                          pr->public_data.start_time)
+                        .rel_value_us);
+    if (GNUNET_YES !=
+        GSF_request_plan_reference_get_last_transmission_ (pr->public_data
+                                                           .pr_head,
+                                                           prq->sender,
+                                                           &last_transmission))
+      last_transmission.abs_value_us =
+        GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
+    /* pass on to other peers / local clients */
+    pr->rh (pr->rh_cls,
+            prq->eval,
+            pr,
+            prq->anonymity_level,
+            prq->expiration,
+            last_transmission,
+            prq->type,
+            prq->data,
+            prq->size);
+    return GNUNET_YES;
+
+  case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
 #if INSANE_STATISTICS
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop(
-                                 "# duplicate replies discarded (bloomfilter)"),
-                               1,
-                               GNUNET_NO);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# duplicate replies discarded (bloomfilter)"),
+                              1,
+                              GNUNET_NO);
 #endif
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Duplicate response, discarding.\n");
-      return GNUNET_YES; /* duplicate */
-
-    case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# irrelevant replies discarded"),
-                               1,
-                               GNUNET_NO);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Irrelevant response, ignoring.\n");
-      return GNUNET_YES;
-
-    case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
-      return GNUNET_YES; /* wrong namespace */
-
-    case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
-      GNUNET_break(0);
-      return GNUNET_YES;
-
-    case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
-      GNUNET_break(0);
-      return GNUNET_YES;
-
-    case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 _("Unsupported block type %u\n"),
-                 prq->type);
-      return GNUNET_NO;
-    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Duplicate response, discarding.\n");
+    return GNUNET_YES;   /* duplicate */
+
+  case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# irrelevant replies discarded"),
+                              1,
+                              GNUNET_NO);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Irrelevant response, ignoring.\n");
+    return GNUNET_YES;
+
+  case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
+    return GNUNET_YES;   /* wrong namespace */
+
+  case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
+    GNUNET_break (0);
+    return GNUNET_YES;
+
+  case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
+    GNUNET_break (0);
+    return GNUNET_YES;
+
+  case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _ ("Unsupported block type %u\n"),
+                prq->type);
+    return GNUNET_NO;
+  }
   /* update bloomfilter */
-  GNUNET_CRYPTO_hash(prq->data, prq->size, &chash);
-  GSF_pending_request_update_(pr, &chash, 1);
+  GNUNET_CRYPTO_hash (prq->data, prq->size, &chash);
+  GSF_pending_request_update_ (pr, &chash, 1);
   if (NULL == prq->sender)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Found result for query `%s' in local datastore\n",
-                 GNUNET_h2s(key));
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# results found locally"),
-                               1,
-                               GNUNET_NO);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found result for query `%s' in local datastore\n",
+                GNUNET_h2s (key));
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# results found locally"),
+                              1,
+                              GNUNET_NO);
+  }
   else
-    {
-      GSF_dht_lookup_(pr);
-    }
+  {
+    GSF_dht_lookup_ (pr);
+  }
   prq->priority += pr->public_data.original_priority;
   pr->public_data.priority = 0;
   pr->public_data.original_priority = 0;
   pr->public_data.results_found++;
   prq->request_found = GNUNET_YES;
   /* finally, pass on to other peer / local client */
-  if (!GSF_request_plan_reference_get_last_transmission_(pr->public_data
-                                                         .pr_head,
-                                                         prq->sender,
-                                                         &last_transmission))
+  if (! GSF_request_plan_reference_get_last_transmission_ (pr->public_data
+                                                           .pr_head,
+                                                           prq->sender,
+                                                           &last_transmission))
     last_transmission.abs_value_us = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
-  pr->rh(pr->rh_cls,
-         prq->eval,
-         pr,
-         prq->anonymity_level,
-         prq->expiration,
-         last_transmission,
-         prq->type,
-         prq->data,
-         prq->size);
+  pr->rh (pr->rh_cls,
+          prq->eval,
+          pr,
+          prq->anonymity_level,
+          prq->expiration,
+          last_transmission,
+          prq->type,
+          prq->data,
+          prq->size);
   return GNUNET_YES;
 }
 
@@ -949,7 +952,8 @@ process_reply(void *cls, const struct GNUNET_HashCode *key, void *value)
 /**
  * Context for put_migration_continuation().
  */
-struct PutMigrationContext {
+struct PutMigrationContext
+{
   /**
    * Start time for the operation.
    */
@@ -978,10 +982,10 @@ struct PutMigrationContext {
  * @param msg NULL on success, otherwise an error message
  */
 static void
-put_migration_continuation(void *cls,
-                           int success,
-                           struct GNUNET_TIME_Absolute min_expiration,
-                           const char *msg)
+put_migration_continuation (void *cls,
+                            int success,
+                            struct GNUNET_TIME_Absolute min_expiration,
+                            const char *msg)
 {
   struct PutMigrationContext *pmc = cls;
   struct GSF_ConnectedPeer *cp;
@@ -989,67 +993,67 @@ put_migration_continuation(void *cls,
   struct GSF_PeerPerformanceData *ppd;
 
   if (NULL != datastore_put_load)
+  {
+    if (GNUNET_SYSERR != success)
+    {
+      GNUNET_LOAD_update (datastore_put_load,
+                          GNUNET_TIME_absolute_get_duration (pmc->start)
+                          .rel_value_us);
+    }
+    else
     {
-      if (GNUNET_SYSERR != success)
-        {
-          GNUNET_LOAD_update(datastore_put_load,
-                             GNUNET_TIME_absolute_get_duration(pmc->start)
-                             .rel_value_us);
-        }
-      else
-        {
-          /* on queue failure / timeout, increase the put load dramatically */
-          GNUNET_LOAD_update(datastore_put_load,
-                             GNUNET_TIME_UNIT_MINUTES.rel_value_us);
-        }
+      /* on queue failure / timeout, increase the put load dramatically */
+      GNUNET_LOAD_update (datastore_put_load,
+                          GNUNET_TIME_UNIT_MINUTES.rel_value_us);
     }
-  cp = GSF_peer_get_(&pmc->origin);
+  }
+  cp = GSF_peer_get_ (&pmc->origin);
   if (GNUNET_OK == success)
+  {
+    if (NULL != cp)
     {
-      if (NULL != cp)
-        {
-          ppd = GSF_get_peer_performance_data_(cp);
-          ppd->migration_delay.rel_value_us /= 2;
-        }
-      GNUNET_free(pmc);
-      return;
+      ppd = GSF_get_peer_performance_data_ (cp);
+      ppd->migration_delay.rel_value_us /= 2;
     }
+    GNUNET_free (pmc);
+    return;
+  }
   if ((GNUNET_NO == success) && (GNUNET_NO == pmc->requested) && (NULL != cp))
+  {
+    ppd = GSF_get_peer_performance_data_ (cp);
+    if (min_expiration.abs_value_us > 0)
     {
-      ppd = GSF_get_peer_performance_data_(cp);
-      if (min_expiration.abs_value_us > 0)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "Asking to stop migration for %s because datastore is full\n",
-                     GNUNET_STRINGS_relative_time_to_string(
-                       GNUNET_TIME_absolute_get_remaining(min_expiration),
-                       GNUNET_YES));
-          GSF_block_peer_migration_(cp, min_expiration);
-        }
-      else
-        {
-          ppd->migration_delay = GNUNET_TIME_relative_max(GNUNET_TIME_UNIT_SECONDS,
-                                                          ppd->migration_delay);
-          ppd->migration_delay =
-            GNUNET_TIME_relative_min(GNUNET_TIME_UNIT_HOURS, ppd->migration_delay);
-          mig_pause.rel_value_us =
-            GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK,
-                                     ppd->migration_delay.rel_value_us);
-          ppd->migration_delay =
-            GNUNET_TIME_relative_saturating_multiply(ppd->migration_delay, 2);
-          GNUNET_log(
-            GNUNET_ERROR_TYPE_DEBUG,
-            "Replicated content already exists locally, asking to stop migration for %s\n",
-            GNUNET_STRINGS_relative_time_to_string(mig_pause, GNUNET_YES));
-          GSF_block_peer_migration_(cp,
-                                    GNUNET_TIME_relative_to_absolute(mig_pause));
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Asking to stop migration for %s because datastore is full\n",
+                  GNUNET_STRINGS_relative_time_to_string (
+                    GNUNET_TIME_absolute_get_remaining (min_expiration),
+                    GNUNET_YES));
+      GSF_block_peer_migration_ (cp, min_expiration);
     }
-  GNUNET_free(pmc);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Datastore `PUT' failures"),
-                           1,
-                           GNUNET_NO);
+    else
+    {
+      ppd->migration_delay = GNUNET_TIME_relative_max (GNUNET_TIME_UNIT_SECONDS,
+                                                       ppd->migration_delay);
+      ppd->migration_delay =
+        GNUNET_TIME_relative_min (GNUNET_TIME_UNIT_HOURS, ppd->migration_delay);
+      mig_pause.rel_value_us =
+        GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                  ppd->migration_delay.rel_value_us);
+      ppd->migration_delay =
+        GNUNET_TIME_relative_saturating_multiply (ppd->migration_delay, 2);
+      GNUNET_log (
+        GNUNET_ERROR_TYPE_DEBUG,
+        "Replicated content already exists locally, asking to stop migration for %s\n",
+        GNUNET_STRINGS_relative_time_to_string (mig_pause, GNUNET_YES));
+      GSF_block_peer_migration_ (cp,
+                                 GNUNET_TIME_relative_to_absolute (mig_pause));
+    }
+  }
+  GNUNET_free (pmc);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Datastore `PUT' failures"),
+                            1,
+                            GNUNET_NO);
 }
 
 
@@ -1063,22 +1067,22 @@ put_migration_continuation(void *cls,
  *         #GNUNET_NO to process normally (load normal or low)
  */
 static int
-test_put_load_too_high(uint32_t priority)
+test_put_load_too_high (uint32_t priority)
 {
   double ld;
 
   if (NULL == datastore_put_load)
     return GNUNET_NO;
-  if (GNUNET_LOAD_get_average(datastore_put_load) < 50)
+  if (GNUNET_LOAD_get_average (datastore_put_load) < 50)
     return GNUNET_NO; /* very fast */
-  ld = GNUNET_LOAD_get_load(datastore_put_load);
+  ld = GNUNET_LOAD_get_load (datastore_put_load);
   if (ld < 2.0 * (1 + priority))
     return GNUNET_NO;
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop(
-                             "# storage requests dropped due to high load"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop (
+                              "# storage requests dropped due to high load"),
+                            1,
+                            GNUNET_NO);
   return GNUNET_YES;
 }
 
@@ -1099,67 +1103,67 @@ test_put_load_too_high(uint32_t priority)
  * @param data pointer to the result data
  */
 static void
-handle_dht_reply(void *cls,
-                 struct GNUNET_TIME_Absolute exp,
-                 const struct GNUNET_HashCode *key,
-                 const struct GNUNET_PeerIdentity *get_path,
-                 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)
+handle_dht_reply (void *cls,
+                  struct GNUNET_TIME_Absolute exp,
+                  const struct GNUNET_HashCode *key,
+                  const struct GNUNET_PeerIdentity *get_path,
+                  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)
 {
   struct GSF_PendingRequest *pr = cls;
   struct ProcessReplyClosure prq;
   struct PutMigrationContext *pmc;
 
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Replies received from DHT"),
-                           1,
-                           GNUNET_NO);
-  memset(&prq, 0, sizeof(prq));
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Replies received from DHT"),
+                            1,
+                            GNUNET_NO);
+  memset (&prq, 0, sizeof(prq));
   prq.data = data;
   prq.expiration = exp;
   /* do not allow migrated content to live longer than 1 year */
-  prq.expiration = GNUNET_TIME_absolute_min(GNUNET_TIME_relative_to_absolute(
-                                              GNUNET_TIME_UNIT_YEARS),
-                                            prq.expiration);
+  prq.expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (
+                                               GNUNET_TIME_UNIT_YEARS),
+                                             prq.expiration);
   prq.size = size;
   prq.type = type;
   prq.eo = GNUNET_BLOCK_EO_NONE;
-  process_reply(&prq, key, pr);
+  process_reply (&prq, key, pr);
   if ((GNUNET_YES == active_to_migration) &&
-      (GNUNET_NO == test_put_load_too_high(prq.priority)))
+      (GNUNET_NO == test_put_load_too_high (prq.priority)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Replicating result for query `%s' with priority %u\n",
+                GNUNET_h2s (key),
+                prq.priority);
+    pmc = GNUNET_new (struct PutMigrationContext);
+    pmc->start = GNUNET_TIME_absolute_get ();
+    pmc->requested = GNUNET_YES;
+    if (NULL == GNUNET_DATASTORE_put (GSF_dsh,
+                                      0,
+                                      key,
+                                      size,
+                                      data,
+                                      type,
+                                      prq.priority,
+                                      1 /* anonymity */,
+                                      0 /* replication */,
+                                      exp,
+                                      1 + prq.priority,
+                                      MAX_DATASTORE_QUEUE,
+                                      &put_migration_continuation,
+                                      pmc))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Replicating result for query `%s' with priority %u\n",
-                 GNUNET_h2s(key),
-                 prq.priority);
-      pmc = GNUNET_new(struct PutMigrationContext);
-      pmc->start = GNUNET_TIME_absolute_get();
-      pmc->requested = GNUNET_YES;
-      if (NULL == GNUNET_DATASTORE_put(GSF_dsh,
-                                       0,
-                                       key,
-                                       size,
-                                       data,
-                                       type,
-                                       prq.priority,
-                                       1 /* anonymity */,
-                                       0 /* replication */,
-                                       exp,
-                                       1 + prq.priority,
-                                       MAX_DATASTORE_QUEUE,
-                                       &put_migration_continuation,
-                                       pmc))
-        {
-          put_migration_continuation(pmc,
-                                     GNUNET_SYSERR,
-                                     GNUNET_TIME_UNIT_ZERO_ABS,
-                                     NULL);
-        }
+      put_migration_continuation (pmc,
+                                  GNUNET_SYSERR,
+                                  GNUNET_TIME_UNIT_ZERO_ABS,
+                                  NULL);
     }
+  }
 }
 
 
@@ -1169,7 +1173,7 @@ handle_dht_reply(void *cls,
  * @param pr the pending request to process
  */
 void
-GSF_dht_lookup_(struct GSF_PendingRequest *pr)
+GSF_dht_lookup_ (struct GSF_PendingRequest *pr)
 {
   const void *xquery;
   size_t xquery_size;
@@ -1179,32 +1183,32 @@ GSF_dht_lookup_(struct GSF_PendingRequest *pr)
   if (0 != pr->public_data.anonymity_level)
     return;
   if (NULL != pr->gh)
-    {
-      GNUNET_DHT_get_stop(pr->gh);
-      pr->gh = NULL;
-    }
+  {
+    GNUNET_DHT_get_stop (pr->gh);
+    pr->gh = NULL;
+  }
   xquery = NULL;
   xquery_size = 0;
   if (0 != (pr->public_data.options & GSF_PRO_FORWARD_ONLY))
-    {
-      GNUNET_assert(0 != pr->sender_pid);
-      GNUNET_PEER_resolve(pr->sender_pid, &pi);
-      GNUNET_memcpy(&buf[xquery_size], &pi, sizeof(struct GNUNET_PeerIdentity));
-      xquery_size += sizeof(struct GNUNET_PeerIdentity);
-    }
-  pr->gh = GNUNET_DHT_get_start(GSF_dht,
-                                pr->public_data.type,
-                                &pr->public_data.query,
-                                DHT_GET_REPLICATION,
-                                GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                                xquery,
-                                xquery_size,
-                                &handle_dht_reply,
-                                pr);
+  {
+    GNUNET_assert (0 != pr->sender_pid);
+    GNUNET_PEER_resolve (pr->sender_pid, &pi);
+    GNUNET_memcpy (&buf[xquery_size], &pi, sizeof(struct GNUNET_PeerIdentity));
+    xquery_size += sizeof(struct GNUNET_PeerIdentity);
+  }
+  pr->gh = GNUNET_DHT_get_start (GSF_dht,
+                                 pr->public_data.type,
+                                 &pr->public_data.query,
+                                 DHT_GET_REPLICATION,
+                                 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                                 xquery,
+                                 xquery_size,
+                                 &handle_dht_reply,
+                                 pr);
   if ((NULL != pr->gh) && (0 != pr->replies_seen_count))
-    GNUNET_DHT_get_filter_known_results(pr->gh,
-                                        pr->replies_seen_count,
-                                        pr->replies_seen);
+    GNUNET_DHT_get_filter_known_results (pr->gh,
+                                         pr->replies_seen_count,
+                                         pr->replies_seen);
 }
 
 
@@ -1218,11 +1222,11 @@ GSF_dht_lookup_(struct GSF_PendingRequest *pr)
  * @param data reply block data, NULL on error
  */
 static void
-cadet_reply_proc(void *cls,
-                 enum GNUNET_BLOCK_Type type,
-                 struct GNUNET_TIME_Absolute expiration,
-                 size_t data_size,
-                 const void *data)
+cadet_reply_proc (void *cls,
+                  enum GNUNET_BLOCK_Type type,
+                  struct GNUNET_TIME_Absolute expiration,
+                  size_t data_size,
+                  const void *data)
 {
   struct GSF_PendingRequest *pr = cls;
   struct ProcessReplyClosure prq;
@@ -1230,46 +1234,46 @@ cadet_reply_proc(void *cls,
 
   pr->cadet_request = NULL;
   if (GNUNET_BLOCK_TYPE_ANY == type)
-    {
-      GNUNET_break(NULL == data);
-      GNUNET_break(0 == data_size);
-      pr->cadet_retry_count++;
-      if (pr->cadet_retry_count >= CADET_RETRY_MAX)
-        return; /* give up on cadet */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Error retrieiving block via cadet\n");
-      /* retry -- without delay, as this is non-anonymous
-         and cadet/cadet connect will take some time anyway */
-      pr->cadet_request = GSF_cadet_query(pr->public_data.target,
-                                          &pr->public_data.query,
-                                          pr->public_data.type,
-                                          &cadet_reply_proc,
-                                          pr);
-      return;
-    }
+  {
+    GNUNET_break (NULL == data);
+    GNUNET_break (0 == data_size);
+    pr->cadet_retry_count++;
+    if (pr->cadet_retry_count >= CADET_RETRY_MAX)
+      return;   /* give up on cadet */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error retrieiving block via cadet\n");
+    /* retry -- without delay, as this is non-anonymous
+       and cadet/cadet connect will take some time anyway */
+    pr->cadet_request = GSF_cadet_query (pr->public_data.target,
+                                         &pr->public_data.query,
+                                         pr->public_data.type,
+                                         &cadet_reply_proc,
+                                         pr);
+    return;
+  }
   if (GNUNET_YES !=
-      GNUNET_BLOCK_get_key(GSF_block_ctx, type, data, data_size, &query))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Failed to derive key for block of type %d\n",
-                 (int)type);
-      GNUNET_break_op(0);
-      return;
-    }
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Replies received from CADET"),
-                           1,
-                           GNUNET_NO);
-  memset(&prq, 0, sizeof(prq));
+      GNUNET_BLOCK_get_key (GSF_block_ctx, type, data, data_size, &query))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to derive key for block of type %d\n",
+                (int) type);
+    GNUNET_break_op (0);
+    return;
+  }
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Replies received from CADET"),
+                            1,
+                            GNUNET_NO);
+  memset (&prq, 0, sizeof(prq));
   prq.data = data;
   prq.expiration = expiration;
   /* do not allow migrated content to live longer than 1 year */
-  prq.expiration = GNUNET_TIME_absolute_min(GNUNET_TIME_relative_to_absolute(
-                                              GNUNET_TIME_UNIT_YEARS),
-                                            prq.expiration);
+  prq.expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (
+                                               GNUNET_TIME_UNIT_YEARS),
+                                             prq.expiration);
   prq.size = data_size;
   prq.type = type;
   prq.eo = GNUNET_BLOCK_EO_NONE;
-  process_reply(&prq, &query, pr);
+  process_reply (&prq, &query, pr);
 }
 
 
@@ -1279,23 +1283,23 @@ cadet_reply_proc(void *cls,
  * @param pr the pending request to process
  */
 void
-GSF_cadet_lookup_(struct GSF_PendingRequest *pr)
+GSF_cadet_lookup_ (struct GSF_PendingRequest *pr)
 {
   if (0 != pr->public_data.anonymity_level)
     return;
   if (0 == pr->public_data.target)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Cannot do cadet-based download, target peer not known\n");
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Cannot do cadet-based download, target peer not known\n");
+    return;
+  }
   if (NULL != pr->cadet_request)
     return;
-  pr->cadet_request = GSF_cadet_query(pr->public_data.target,
-                                      &pr->public_data.query,
-                                      pr->public_data.type,
-                                      &cadet_reply_proc,
-                                      pr);
+  pr->cadet_request = GSF_cadet_query (pr->public_data.target,
+                                       &pr->public_data.query,
+                                       pr->public_data.type,
+                                       &cadet_reply_proc,
+                                       pr);
 }
 
 
@@ -1305,18 +1309,18 @@ GSF_cadet_lookup_(struct GSF_PendingRequest *pr)
  * @param cls the `struct GSF_PendingRequest`
  */
 static void
-warn_delay_task(void *cls)
+warn_delay_task (void *cls)
 {
   struct GSF_PendingRequest *pr = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
-             _("Datastore lookup already took %s!\n"),
-             GNUNET_STRINGS_relative_time_to_string(
-               GNUNET_TIME_absolute_get_duration(pr->qe_start),
-               GNUNET_YES));
-  pr->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
-                                               &warn_delay_task,
-                                               pr);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING | GNUNET_ERROR_TYPE_BULK,
+              _ ("Datastore lookup already took %s!\n"),
+              GNUNET_STRINGS_relative_time_to_string (
+                GNUNET_TIME_absolute_get_duration (pr->qe_start),
+                GNUNET_YES));
+  pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                                &warn_delay_task,
+                                                pr);
 }
 
 
@@ -1326,140 +1330,140 @@ warn_delay_task(void *cls)
  * @param cls the `struct GSF_PendingRequest`
  */
 static void
-odc_warn_delay_task(void *cls)
+odc_warn_delay_task (void *cls)
 {
   struct GSF_PendingRequest *pr = cls;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
-             _("On-demand lookup already took %s!\n"),
-             GNUNET_STRINGS_relative_time_to_string(
-               GNUNET_TIME_absolute_get_duration(pr->qe_start),
-               GNUNET_YES));
-  pr->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
-                                               &odc_warn_delay_task,
-                                               pr);
+  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+              _ ("On-demand lookup already took %s!\n"),
+              GNUNET_STRINGS_relative_time_to_string (
+                GNUNET_TIME_absolute_get_duration (pr->qe_start),
+                GNUNET_YES));
+  pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                                &odc_warn_delay_task,
+                                                pr);
 }
 
 
 /* Call our continuation (if we have any) */
 static void
-call_continuation(struct GSF_PendingRequest *pr)
+call_continuation (struct GSF_PendingRequest *pr)
 {
   GSF_LocalLookupContinuation cont = pr->llc_cont;
 
-  GNUNET_assert(NULL == pr->qe);
+  GNUNET_assert (NULL == pr->qe);
   if (NULL != pr->warn_task)
-    {
-      GNUNET_SCHEDULER_cancel(pr->warn_task);
-      pr->warn_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pr->warn_task);
+    pr->warn_task = NULL;
+  }
   if (NULL == cont)
     return; /* no continuation */
   pr->llc_cont = NULL;
   if (0 != (GSF_PRO_LOCAL_ONLY & pr->public_data.options))
+  {
+    if (GNUNET_BLOCK_EVALUATION_OK_LAST != pr->local_result)
     {
-      if (GNUNET_BLOCK_EVALUATION_OK_LAST != pr->local_result)
-        {
-          /* Signal that we are done and that there won't be any
-             additional results to allow client to clean up state. */
-          pr->rh(pr->rh_cls,
-                 GNUNET_BLOCK_EVALUATION_OK_LAST,
-                 pr,
-                 UINT32_MAX,
-                 GNUNET_TIME_UNIT_ZERO_ABS,
-                 GNUNET_TIME_UNIT_FOREVER_ABS,
-                 GNUNET_BLOCK_TYPE_ANY,
-                 NULL,
-                 0);
-        }
-      /* Finally, call our continuation to signal that we are
-         done with local processing of this request; i.e. to
-         start reading again from the client. */
-      cont(pr->llc_cont_cls, NULL, GNUNET_BLOCK_EVALUATION_OK_LAST);
-      return;
+      /* Signal that we are done and that there won't be any
+         additional results to allow client to clean up state. */
+      pr->rh (pr->rh_cls,
+              GNUNET_BLOCK_EVALUATION_OK_LAST,
+              pr,
+              UINT32_MAX,
+              GNUNET_TIME_UNIT_ZERO_ABS,
+              GNUNET_TIME_UNIT_FOREVER_ABS,
+              GNUNET_BLOCK_TYPE_ANY,
+              NULL,
+              0);
     }
+    /* Finally, call our continuation to signal that we are
+       done with local processing of this request; i.e. to
+       start reading again from the client. */
+    cont (pr->llc_cont_cls, NULL, GNUNET_BLOCK_EVALUATION_OK_LAST);
+    return;
+  }
 
-  cont(pr->llc_cont_cls, pr, pr->local_result);
+  cont (pr->llc_cont_cls, pr, pr->local_result);
 }
 
 
 /* Update stats and call continuation */
 static void
-no_more_local_results(struct GSF_PendingRequest *pr)
+no_more_local_results (struct GSF_PendingRequest *pr)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
-             "No further local responses available.\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
+              "No further local responses available.\n");
 #if INSANE_STATISTICS
   if ((GNUNET_BLOCK_TYPE_FS_DBLOCK == pr->public_data.type) ||
       (GNUNET_BLOCK_TYPE_FS_IBLOCK == pr->public_data.type))
-    GNUNET_STATISTICS_update(GSF_stats,
-                             gettext_noop(
-                               "# requested DBLOCK or IBLOCK not found"),
-                             1,
-                             GNUNET_NO);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# requested DBLOCK or IBLOCK not found"),
+                              1,
+                              GNUNET_NO);
 #endif
-  call_continuation(pr);
+  call_continuation (pr);
 }
 
 
 /* forward declaration */
 static void
-process_local_reply(void *cls,
-                    const struct GNUNET_HashCode *key,
-                    size_t size,
-                    const void *data,
-                    enum GNUNET_BLOCK_Type type,
-                    uint32_t priority,
-                    uint32_t anonymity,
-                    uint32_t replication,
-                    struct GNUNET_TIME_Absolute expiration,
-                    uint64_t uid);
+process_local_reply (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     size_t size,
+                     const void *data,
+                     enum GNUNET_BLOCK_Type type,
+                     uint32_t priority,
+                     uint32_t anonymity,
+                     uint32_t replication,
+                     struct GNUNET_TIME_Absolute expiration,
+                     uint64_t uid);
 
 
 /* Start a local query */
 static void
-start_local_query(struct GSF_PendingRequest *pr,
-                  uint64_t next_uid,
-                  bool random)
+start_local_query (struct GSF_PendingRequest *pr,
+                   uint64_t next_uid,
+                   bool random)
 {
-  pr->qe_start = GNUNET_TIME_absolute_get();
-  pr->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
-                                               &warn_delay_task,
-                                               pr);
-  pr->qe = GNUNET_DATASTORE_get_key(GSF_dsh,
-                                    next_uid,
-                                    random,
-                                    &pr->public_data.query,
-                                    pr->public_data.type ==
-                                    GNUNET_BLOCK_TYPE_FS_DBLOCK
-                                    ? GNUNET_BLOCK_TYPE_ANY
-                                    : pr->public_data.type,
-                                    (0 != (GSF_PRO_PRIORITY_UNLIMITED &
-                                           pr->public_data.options))
-                                    ? UINT_MAX
-                                    : 1
-                                    /* queue priority */,
-                                    (0 != (GSF_PRO_PRIORITY_UNLIMITED &
-                                           pr->public_data.options))
-                                    ? UINT_MAX
-                                    : GSF_datastore_queue_size
-                                    /* max queue size */,
-                                    &process_local_reply,
-                                    pr);
+  pr->qe_start = GNUNET_TIME_absolute_get ();
+  pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                                &warn_delay_task,
+                                                pr);
+  pr->qe = GNUNET_DATASTORE_get_key (GSF_dsh,
+                                     next_uid,
+                                     random,
+                                     &pr->public_data.query,
+                                     pr->public_data.type ==
+                                     GNUNET_BLOCK_TYPE_FS_DBLOCK
+                                     ? GNUNET_BLOCK_TYPE_ANY
+                                     : pr->public_data.type,
+                                     (0 != (GSF_PRO_PRIORITY_UNLIMITED
+                                            & pr->public_data.options))
+                                     ? UINT_MAX
+                                     : 1
+                                     /* queue priority */,
+                                     (0 != (GSF_PRO_PRIORITY_UNLIMITED
+                                            & pr->public_data.options))
+                                     ? UINT_MAX
+                                     : GSF_datastore_queue_size
+                                     /* max queue size */,
+                                     &process_local_reply,
+                                     pr);
   if (NULL != pr->qe)
     return;
-  GNUNET_log(
+  GNUNET_log (
     GNUNET_ERROR_TYPE_DEBUG,
     "ERROR Requesting `%s' of type %d with next_uid %llu from datastore.\n",
-    GNUNET_h2s(&pr->public_data.query),
+    GNUNET_h2s (&pr->public_data.query),
     pr->public_data.type,
-    (unsigned long long)next_uid);
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop(
-                             "# Datastore lookups concluded (error queueing)"),
-                           1,
-                           GNUNET_NO);
-  call_continuation(pr);
+    (unsigned long long) next_uid);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop (
+                              "# Datastore lookups concluded (error queueing)"),
+                            1,
+                            GNUNET_NO);
+  call_continuation (pr);
 }
 
 
@@ -1482,178 +1486,178 @@ start_local_query(struct GSF_PendingRequest *pr,
  *        maybe 0 if no unique identifier is available
  */
 static void
-process_local_reply(void *cls,
-                    const struct GNUNET_HashCode *key,
-                    size_t size,
-                    const void *data,
-                    enum GNUNET_BLOCK_Type type,
-                    uint32_t priority,
-                    uint32_t anonymity,
-                    uint32_t replication,
-                    struct GNUNET_TIME_Absolute expiration,
-                    uint64_t uid)
+process_local_reply (void *cls,
+                     const struct GNUNET_HashCode *key,
+                     size_t size,
+                     const void *data,
+                     enum GNUNET_BLOCK_Type type,
+                     uint32_t priority,
+                     uint32_t anonymity,
+                     uint32_t replication,
+                     struct GNUNET_TIME_Absolute expiration,
+                     uint64_t uid)
 {
   struct GSF_PendingRequest *pr = cls;
   struct ProcessReplyClosure prq;
   struct GNUNET_HashCode query;
   unsigned int old_rf;
 
-  GNUNET_SCHEDULER_cancel(pr->warn_task);
+  GNUNET_SCHEDULER_cancel (pr->warn_task);
   pr->warn_task = NULL;
   if (NULL == pr->qe)
     goto called_from_on_demand;
   pr->qe = NULL;
   if (
     (NULL == key) && pr->seen_null &&
-    !pr->have_first_uid)  /* We have hit the end for the 2nd time with no results */
-    {
-      /* No results */
+    ! pr->have_first_uid)  /* We have hit the end for the 2nd time with no results */
+  {
+    /* No results */
 #if INSANE_STATISTICS
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop(
-                                 "# Datastore lookups concluded (no results)"),
-                               1,
-                               GNUNET_NO);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# Datastore lookups concluded (no results)"),
+                              1,
+                              GNUNET_NO);
 #endif
-      no_more_local_results(pr);
-      return;
-    }
+    no_more_local_results (pr);
+    return;
+  }
   if (((NULL == key) &&
        pr->seen_null) || /* We have hit the end for the 2nd time OR */
       (pr->seen_null && pr->have_first_uid &&
        (uid >= pr->first_uid))) /* We have hit the end and past first UID */
-    {
-      /* Seen all results */
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop(
-                                 "# Datastore lookups concluded (seen all)"),
-                               1,
-                               GNUNET_NO);
-      no_more_local_results(pr);
-      return;
-    }
+  {
+    /* Seen all results */
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# Datastore lookups concluded (seen all)"),
+                              1,
+                              GNUNET_NO);
+    no_more_local_results (pr);
+    return;
+  }
   if (NULL == key)
-    {
-      GNUNET_assert(!pr->seen_null);
-      pr->seen_null = true;
-      start_local_query(pr, 0 /* next_uid */, false /* random */);
-      return;
-    }
-  if (!pr->have_first_uid)
-    {
-      pr->first_uid = uid;
-      pr->have_first_uid = true;
-    }
+  {
+    GNUNET_assert (! pr->seen_null);
+    pr->seen_null = true;
+    start_local_query (pr, 0 /* next_uid */, false /* random */);
+    return;
+  }
+  if (! pr->have_first_uid)
+  {
+    pr->first_uid = uid;
+    pr->have_first_uid = true;
+  }
   pr->result_count++;
   if (pr->result_count > MAX_RESULTS)
-    {
-      GNUNET_STATISTICS_update(
-        GSF_stats,
-        gettext_noop("# Datastore lookups aborted (more than MAX_RESULTS)"),
-        1,
-        GNUNET_NO);
-      no_more_local_results(pr);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received reply for `%s' of type %d with UID %llu from datastore.\n",
-             GNUNET_h2s(key),
-             type,
-             (unsigned long long)uid);
+  {
+    GNUNET_STATISTICS_update (
+      GSF_stats,
+      gettext_noop ("# Datastore lookups aborted (more than MAX_RESULTS)"),
+      1,
+      GNUNET_NO);
+    no_more_local_results (pr);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received reply for `%s' of type %d with UID %llu from datastore.\n",
+              GNUNET_h2s (key),
+              type,
+              (unsigned long long) uid);
   if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found ONDEMAND block, performing on-demand encoding\n");
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# on-demand blocks matched requests"),
+                              1,
+                              GNUNET_NO);
+    pr->qe_start = GNUNET_TIME_absolute_get ();
+    pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                                  &odc_warn_delay_task,
+                                                  pr);
+    if (GNUNET_OK == GNUNET_FS_handle_on_demand_block (key,
+                                                       size,
+                                                       data,
+                                                       type,
+                                                       priority,
+                                                       anonymity,
+                                                       replication,
+                                                       expiration,
+                                                       uid,
+                                                       &process_local_reply,
+                                                       pr))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Found ONDEMAND block, performing on-demand encoding\n");
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop(
-                                 "# on-demand blocks matched requests"),
-                               1,
-                               GNUNET_NO);
-      pr->qe_start = GNUNET_TIME_absolute_get();
-      pr->warn_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES,
-                                                   &odc_warn_delay_task,
-                                                   pr);
-      if (GNUNET_OK == GNUNET_FS_handle_on_demand_block(key,
-                                                        size,
-                                                        data,
-                                                        type,
-                                                        priority,
-                                                        anonymity,
-                                                        replication,
-                                                        expiration,
-                                                        uid,
-                                                        &process_local_reply,
-                                                        pr))
-        {
-          GNUNET_STATISTICS_update(GSF_stats,
-                                   gettext_noop(
-                                     "# on-demand lookups performed successfully"),
-                                   1,
-                                   GNUNET_NO);
-          return; /* we're done */
-        }
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop("# on-demand lookups failed"),
-                               1,
-                               GNUNET_NO);
-      GNUNET_SCHEDULER_cancel(pr->warn_task);
-      start_local_query(pr, uid + 1 /* next_uid */, false /* random */);
-      return;
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop (
+                                  "# on-demand lookups performed successfully"),
+                                1,
+                                GNUNET_NO);
+      return;     /* we're done */
     }
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# on-demand lookups failed"),
+                              1,
+                              GNUNET_NO);
+    GNUNET_SCHEDULER_cancel (pr->warn_task);
+    start_local_query (pr, uid + 1 /* next_uid */, false /* random */);
+    return;
+  }
 called_from_on_demand:
   old_rf = pr->public_data.results_found;
-  memset(&prq, 0, sizeof(prq));
+  memset (&prq, 0, sizeof(prq));
   prq.data = data;
   prq.expiration = expiration;
   prq.size = size;
   if (GNUNET_OK !=
-      GNUNET_BLOCK_get_key(GSF_block_ctx, type, data, size, &query))
-    {
-      GNUNET_break(0);
-      GNUNET_DATASTORE_remove(GSF_dsh,
-                              key,
-                              size,
-                              data,
-                              UINT_MAX,
-                              UINT_MAX,
-                              NULL,
-                              NULL);
-      start_local_query(pr, uid + 1 /* next_uid */, false /* random */);
-      return;
-    }
+      GNUNET_BLOCK_get_key (GSF_block_ctx, type, data, size, &query))
+  {
+    GNUNET_break (0);
+    GNUNET_DATASTORE_remove (GSF_dsh,
+                             key,
+                             size,
+                             data,
+                             UINT_MAX,
+                             UINT_MAX,
+                             NULL,
+                             NULL);
+    start_local_query (pr, uid + 1 /* next_uid */, false /* random */);
+    return;
+  }
   prq.type = type;
   prq.priority = priority;
   prq.request_found = GNUNET_NO;
   prq.anonymity_level = anonymity;
   if ((0 == old_rf) && (0 == pr->public_data.results_found))
-    GSF_update_datastore_delay_(pr->public_data.start_time);
+    GSF_update_datastore_delay_ (pr->public_data.start_time);
   prq.eo = GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO;
-  process_reply(&prq, key, pr);
+  process_reply (&prq, key, pr);
   pr->local_result = prq.eval;
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == prq.eval)
-    {
-      GNUNET_STATISTICS_update(
-        GSF_stats,
-        gettext_noop("# Datastore lookups concluded (found last result)"),
-        1,
-        GNUNET_NO);
-      call_continuation(pr);
-      return;
-    }
+  {
+    GNUNET_STATISTICS_update (
+      GSF_stats,
+      gettext_noop ("# Datastore lookups concluded (found last result)"),
+      1,
+      GNUNET_NO);
+    call_continuation (pr);
+    return;
+  }
   if ((0 == (GSF_PRO_PRIORITY_UNLIMITED & pr->public_data.options)) &&
-      ((GNUNET_YES == GSF_test_get_load_too_high_(0)) ||
+      ((GNUNET_YES == GSF_test_get_load_too_high_ (0)) ||
        (pr->public_data.results_found > 5 + 2 * pr->public_data.priority)))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Load too high, done with request\n");
-      GNUNET_STATISTICS_update(GSF_stats,
-                               gettext_noop(
-                                 "# Datastore lookups concluded (load too high)"),
-                               1,
-                               GNUNET_NO);
-      call_continuation(pr);
-      return;
-    }
-  start_local_query(pr, uid + 1 /* next_uid */, false /* random */);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load too high, done with request\n");
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop (
+                                "# Datastore lookups concluded (load too high)"),
+                              1,
+                              GNUNET_NO);
+    call_continuation (pr);
+    return;
+  }
+  start_local_query (pr, uid + 1 /* next_uid */, false /* random */);
 }
 
 
@@ -1665,15 +1669,15 @@ called_from_on_demand:
  * @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)
+GSF_pending_request_test_target_ (struct GSF_PendingRequest *pr,
+                                  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_PEER_resolve (pr->origin_pid, &pi);
+  return (0 == memcmp (&pi, target, sizeof(struct GNUNET_PeerIdentity)))
          ? GNUNET_NO
          : GNUNET_YES;
 }
@@ -1687,22 +1691,22 @@ GSF_pending_request_test_target_(struct GSF_PendingRequest *pr,
  * @param cont_cls closure for @a cont
  */
 void
-GSF_local_lookup_(struct GSF_PendingRequest *pr,
-                  GSF_LocalLookupContinuation cont,
-                  void *cont_cls)
+GSF_local_lookup_ (struct GSF_PendingRequest *pr,
+                   GSF_LocalLookupContinuation cont,
+                   void *cont_cls)
 {
-  GNUNET_assert(NULL == pr->gh);
-  GNUNET_assert(NULL == pr->cadet_request);
-  GNUNET_assert(NULL == pr->llc_cont);
+  GNUNET_assert (NULL == pr->gh);
+  GNUNET_assert (NULL == pr->cadet_request);
+  GNUNET_assert (NULL == pr->llc_cont);
   pr->llc_cont = cont;
   pr->llc_cont_cls = cont_cls;
 #if INSANE_STATISTICS
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# Datastore lookups initiated"),
-                           1,
-                           GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# Datastore lookups initiated"),
+                            1,
+                            GNUNET_NO);
 #endif
-  start_local_query(pr, 0 /* next_uid */, true /* random */);
+  start_local_query (pr, 0 /* next_uid */, true /* random */);
 }
 
 
@@ -1716,7 +1720,7 @@ GSF_local_lookup_(struct GSF_PendingRequest *pr,
  * @param put the actual message
  */
 void
-handle_p2p_put(void *cls, const struct PutMessage *put)
+handle_p2p_put (void *cls, const struct PutMessage *put)
 {
   struct GSF_ConnectedPeer *cp = cls;
   uint16_t msize;
@@ -1729,30 +1733,30 @@ handle_p2p_put(void *cls, const struct PutMessage *put)
   double putl;
   struct PutMigrationContext *pmc;
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Received P2P PUT from %s\n",
-             GNUNET_i2s(GSF_get_peer_performance_data_(cp)->peer));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Received P2P PUT from %s\n",
+              GNUNET_i2s (GSF_get_peer_performance_data_ (cp)->peer));
   GSF_cover_content_count++;
-  msize = ntohs(put->header.size);
+  msize = ntohs (put->header.size);
   dsize = msize - sizeof(struct PutMessage);
-  type = ntohl(put->type);
-  expiration = GNUNET_TIME_absolute_ntoh(put->expiration);
+  type = ntohl (put->type);
+  expiration = GNUNET_TIME_absolute_ntoh (put->expiration);
   /* do not allow migrated content to live longer than 1 year */
-  expiration = GNUNET_TIME_absolute_min(GNUNET_TIME_relative_to_absolute(
-                                          GNUNET_TIME_UNIT_YEARS),
-                                        expiration);
+  expiration = GNUNET_TIME_absolute_min (GNUNET_TIME_relative_to_absolute (
+                                           GNUNET_TIME_UNIT_YEARS),
+                                         expiration);
   if (GNUNET_OK !=
-      GNUNET_BLOCK_get_key(GSF_block_ctx, type, &put[1], dsize, &query))
-    {
-      GNUNET_break_op(0);
-      return;
-    }
-  GNUNET_STATISTICS_update(GSF_stats,
-                           gettext_noop("# GAP PUT messages received"),
-                           1,
-                           GNUNET_NO);
+      GNUNET_BLOCK_get_key (GSF_block_ctx, type, &put[1], dsize, &query))
+  {
+    GNUNET_break_op (0);
+    return;
+  }
+  GNUNET_STATISTICS_update (GSF_stats,
+                            gettext_noop ("# GAP PUT messages received"),
+                            1,
+                            GNUNET_NO);
   /* now, lookup 'query' */
-  prq.data = (const void *)&put[1];
+  prq.data = (const void *) &put[1];
   prq.sender = cp;
   prq.size = dsize;
   prq.type = type;
@@ -1761,80 +1765,80 @@ handle_p2p_put(void *cls, const struct PutMessage *put)
   prq.anonymity_level = UINT32_MAX;
   prq.request_found = GNUNET_NO;
   prq.eo = GNUNET_BLOCK_EO_NONE;
-  GNUNET_CONTAINER_multihashmap_get_multiple(pr_map,
-                                             &query,
-                                             &process_reply,
-                                             &prq);
+  GNUNET_CONTAINER_multihashmap_get_multiple (pr_map,
+                                              &query,
+                                              &process_reply,
+                                              &prq);
   if (NULL != cp)
-    {
-      GSF_connected_peer_change_preference_(cp,
-                                            CONTENT_BANDWIDTH_VALUE +
-                                            1000 * prq.priority);
-      GSF_get_peer_performance_data_(cp)->respect += prq.priority;
-    }
+  {
+    GSF_connected_peer_change_preference_ (cp,
+                                           CONTENT_BANDWIDTH_VALUE
+                                           + 1000 * prq.priority);
+    GSF_get_peer_performance_data_ (cp)->respect += prq.priority;
+  }
   if ((GNUNET_YES == active_to_migration) && (NULL != cp) &&
-      (GNUNET_NO == test_put_load_too_high(prq.priority)))
+      (GNUNET_NO == test_put_load_too_high (prq.priority)))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Replicating result for query `%s' with priority %u\n",
+                GNUNET_h2s (&query),
+                prq.priority);
+    pmc = GNUNET_new (struct PutMigrationContext);
+    pmc->start = GNUNET_TIME_absolute_get ();
+    pmc->requested = prq.request_found;
+    GNUNET_assert (0 != GSF_get_peer_performance_data_ (cp)->pid);
+    GNUNET_PEER_resolve (GSF_get_peer_performance_data_ (cp)->pid,
+                         &pmc->origin);
+    if (NULL == GNUNET_DATASTORE_put (GSF_dsh,
+                                      0,
+                                      &query,
+                                      dsize,
+                                      &put[1],
+                                      type,
+                                      prq.priority,
+                                      1 /* anonymity */,
+                                      0 /* replication */,
+                                      expiration,
+                                      1 + prq.priority,
+                                      MAX_DATASTORE_QUEUE,
+                                      &put_migration_continuation,
+                                      pmc))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Replicating result for query `%s' with priority %u\n",
-                 GNUNET_h2s(&query),
-                 prq.priority);
-      pmc = GNUNET_new(struct PutMigrationContext);
-      pmc->start = GNUNET_TIME_absolute_get();
-      pmc->requested = prq.request_found;
-      GNUNET_assert(0 != GSF_get_peer_performance_data_(cp)->pid);
-      GNUNET_PEER_resolve(GSF_get_peer_performance_data_(cp)->pid,
-                          &pmc->origin);
-      if (NULL == GNUNET_DATASTORE_put(GSF_dsh,
-                                       0,
-                                       &query,
-                                       dsize,
-                                       &put[1],
-                                       type,
-                                       prq.priority,
-                                       1 /* anonymity */,
-                                       0 /* replication */,
-                                       expiration,
-                                       1 + prq.priority,
-                                       MAX_DATASTORE_QUEUE,
-                                       &put_migration_continuation,
-                                       pmc))
-        {
-          put_migration_continuation(pmc,
-                                     GNUNET_SYSERR,
-                                     GNUNET_TIME_UNIT_ZERO_ABS,
-                                     NULL);
-        }
+      put_migration_continuation (pmc,
+                                  GNUNET_SYSERR,
+                                  GNUNET_TIME_UNIT_ZERO_ABS,
+                                  NULL);
     }
+  }
   else if (NULL != cp)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Choosing not to keep content `%s' (%d/%d)\n",
-                 GNUNET_h2s(&query),
-                 active_to_migration,
-                 test_put_load_too_high(prq.priority));
-    }
-  putl = GNUNET_LOAD_get_load(datastore_put_load);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Choosing not to keep content `%s' (%d/%d)\n",
+                GNUNET_h2s (&query),
+                active_to_migration,
+                test_put_load_too_high (prq.priority));
+  }
+  putl = GNUNET_LOAD_get_load (datastore_put_load);
   if ((NULL != cp) && (GNUNET_NO == prq.request_found) &&
       ((GNUNET_YES != active_to_migration) ||
        (putl > 2.5 * (1 + prq.priority))))
-    {
-      if (GNUNET_YES != active_to_migration)
-        putl = 1.0 + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 5);
-      block_time = GNUNET_TIME_relative_multiply(
-        GNUNET_TIME_UNIT_MILLISECONDS,
-        5000 + GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
-                                        (unsigned int)(60000 * putl * putl)));
-      GNUNET_log(
-        GNUNET_ERROR_TYPE_DEBUG,
-        "Asking to stop migration for %s because of load %f and events %d/%d\n",
-        GNUNET_STRINGS_relative_time_to_string(block_time, GNUNET_YES),
-        putl,
-        active_to_migration,
-        (GNUNET_NO == prq.request_found));
-      GSF_block_peer_migration_(cp,
-                                GNUNET_TIME_relative_to_absolute(block_time));
-    }
+  {
+    if (GNUNET_YES != active_to_migration)
+      putl = 1.0 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 5);
+    block_time = GNUNET_TIME_relative_multiply (
+      GNUNET_TIME_UNIT_MILLISECONDS,
+      5000 + GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                       (unsigned int) (60000 * putl * putl)));
+    GNUNET_log (
+      GNUNET_ERROR_TYPE_DEBUG,
+      "Asking to stop migration for %s because of load %f and events %d/%d\n",
+      GNUNET_STRINGS_relative_time_to_string (block_time, GNUNET_YES),
+      putl,
+      active_to_migration,
+      (GNUNET_NO == prq.request_found));
+    GSF_block_peer_migration_ (cp,
+                               GNUNET_TIME_relative_to_absolute (block_time));
+  }
 }
 
 
@@ -1845,7 +1849,7 @@ handle_p2p_put(void *cls, const struct PutMessage *put)
  * @return #GNUNET_YES if the request is still active
  */
 int
-GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
+GSF_pending_request_test_active_ (struct GSF_PendingRequest *pr)
 {
   return (NULL != pr->rh) ? GNUNET_YES : GNUNET_NO;
 }
@@ -1855,24 +1859,24 @@ GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
  * Setup the subsystem.
  */
 void
-GSF_pending_request_init_()
+GSF_pending_request_init_ ()
 {
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_number(GSF_cfg,
-                                            "fs",
-                                            "MAX_PENDING_REQUESTS",
-                                            &max_pending_requests))
-    {
-      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_INFO,
-                                "fs",
-                                "MAX_PENDING_REQUESTS");
-    }
+      GNUNET_CONFIGURATION_get_value_number (GSF_cfg,
+                                             "fs",
+                                             "MAX_PENDING_REQUESTS",
+                                             &max_pending_requests))
+  {
+    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
+                               "fs",
+                               "MAX_PENDING_REQUESTS");
+  }
   active_to_migration =
-    GNUNET_CONFIGURATION_get_value_yesno(GSF_cfg, "FS", "CONTENT_CACHING");
-  datastore_put_load = GNUNET_LOAD_value_init(DATASTORE_LOAD_AUTODECLINE);
-  pr_map = GNUNET_CONTAINER_multihashmap_create(32 * 1024, GNUNET_YES);
+    GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg, "FS", "CONTENT_CACHING");
+  datastore_put_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
+  pr_map = GNUNET_CONTAINER_multihashmap_create (32 * 1024, GNUNET_YES);
   requests_by_expiration_heap =
-    GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
 }
 
 
@@ -1880,14 +1884,14 @@ GSF_pending_request_init_()
  * Shutdown the subsystem.
  */
 void
-GSF_pending_request_done_()
+GSF_pending_request_done_ ()
 {
-  GNUNET_CONTAINER_multihashmap_iterate(pr_map, &clean_request, NULL);
-  GNUNET_CONTAINER_multihashmap_destroy(pr_map);
+  GNUNET_CONTAINER_multihashmap_iterate (pr_map, &clean_request, NULL);
+  GNUNET_CONTAINER_multihashmap_destroy (pr_map);
   pr_map = NULL;
-  GNUNET_CONTAINER_heap_destroy(requests_by_expiration_heap);
+  GNUNET_CONTAINER_heap_destroy (requests_by_expiration_heap);
   requests_by_expiration_heap = NULL;
-  GNUNET_LOAD_value_free(datastore_put_load);
+  GNUNET_LOAD_value_free (datastore_put_load);
   datastore_put_load = NULL;
 }
 
diff --git a/src/fs/gnunet-service-fs_pr.h b/src/fs/gnunet-service-fs_pr.h
index 39e471c4d..f22f85ee0 100644
--- a/src/fs/gnunet-service-fs_pr.h
+++ b/src/fs/gnunet-service-fs_pr.h
@@ -32,7 +32,8 @@
 /**
  * Options for pending requests (bits to be ORed).
  */
-enum GSF_PendingRequestOptions {
+enum GSF_PendingRequestOptions
+{
   /**
    * No special options (P2P-default).
    */
@@ -67,7 +68,8 @@ enum GSF_PendingRequestOptions {
    * Option mask for typical local requests.
    */
   GSF_PRO_LOCAL_REQUEST =
-    (GSF_PRO_BLOOMFILTER_FULL_REFRESH | GSF_PRO_PRIORITY_UNLIMITED | GSF_PRO_REQUEST_NEVER_EXPIRES)
+    (GSF_PRO_BLOOMFILTER_FULL_REFRESH | GSF_PRO_PRIORITY_UNLIMITED
+     | GSF_PRO_REQUEST_NEVER_EXPIRES)
 };
 
 
@@ -76,7 +78,8 @@ enum GSF_PendingRequestOptions {
  * 'gnunet-service-fs_pr', not in the sense of network-wide
  * known) associated with each pending request.
  */
-struct GSF_PendingRequestData {
+struct GSF_PendingRequestData
+{
   /**
    * Primary query hash for this request.
    */
@@ -186,7 +189,8 @@ typedef void
                                    struct GSF_PendingRequest *pr,
                                    uint32_t reply_anonymity_level,
                                    struct GNUNET_TIME_Absolute expiration,
-                                   struct GNUNET_TIME_Absolute last_transmission,
+                                   struct GNUNET_TIME_Absolute
+                                   last_transmission,
                                    enum GNUNET_BLOCK_Type type,
                                    const void *data,
                                    size_t data_len);
@@ -215,22 +219,22 @@ typedef void
  * @return handle for the new pending request
  */
 struct GSF_PendingRequest *
-GSF_pending_request_create_(enum GSF_PendingRequestOptions options,
-                            enum GNUNET_BLOCK_Type type,
-                            const struct GNUNET_HashCode *query,
-                            const struct GNUNET_PeerIdentity *target,
-                            const char *bf_data,
-                            size_t bf_size,
-                            uint32_t mingle,
-                            uint32_t anonymity_level,
-                            uint32_t priority,
-                            int32_t ttl,
-                            GNUNET_PEER_Id sender_pid,
-                            GNUNET_PEER_Id origin_pid,
-                            const struct GNUNET_HashCode *replies_seen,
-                            unsigned int replies_seen_count,
-                            GSF_PendingRequestReplyHandler rh,
-                            void *rh_cls);
+GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
+                             enum GNUNET_BLOCK_Type type,
+                             const struct GNUNET_HashCode *query,
+                             const struct GNUNET_PeerIdentity *target,
+                             const char *bf_data,
+                             size_t bf_size,
+                             uint32_t mingle,
+                             uint32_t anonymity_level,
+                             uint32_t priority,
+                             int32_t ttl,
+                             GNUNET_PEER_Id sender_pid,
+                             GNUNET_PEER_Id origin_pid,
+                             const struct GNUNET_HashCode *replies_seen,
+                             unsigned int replies_seen_count,
+                             GSF_PendingRequestReplyHandler rh,
+                             void *rh_cls);
 
 
 /**
@@ -242,9 +246,9 @@ GSF_pending_request_create_(enum GSF_PendingRequestOptions options,
  * @param replies_seen_count size of the @a replies_seen array
  */
 void
-GSF_pending_request_update_(struct GSF_PendingRequest *pr,
-                            const struct GNUNET_HashCode *replies_seen,
-                            unsigned int replies_seen_count);
+GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
+                             const struct GNUNET_HashCode *replies_seen,
+                             unsigned int replies_seen_count);
 
 
 /**
@@ -254,7 +258,7 @@ GSF_pending_request_update_(struct GSF_PendingRequest *pr,
  * @return associated public data
  */
 struct GSF_PendingRequestData *
-GSF_pending_request_get_data_(struct GSF_PendingRequest *pr);
+GSF_pending_request_get_data_ (struct GSF_PendingRequest *pr);
 
 
 /**
@@ -264,7 +268,7 @@ GSF_pending_request_get_data_(struct GSF_PendingRequest *pr);
  * @return #GNUNET_YES if the request is still active
  */
 int
-GSF_pending_request_test_active_(struct GSF_PendingRequest *pr);
+GSF_pending_request_test_active_ (struct GSF_PendingRequest *pr);
 
 
 /**
@@ -277,8 +281,8 @@ GSF_pending_request_test_active_(struct GSF_PendingRequest *pr);
  * @return #GNUNET_OK if the requests are compatible
  */
 int
-GSF_pending_request_is_compatible_(struct GSF_PendingRequest *pra,
-                                   struct GSF_PendingRequest *prb);
+GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
+                                    struct GSF_PendingRequest *prb);
 
 
 /**
@@ -289,7 +293,7 @@ GSF_pending_request_is_compatible_(struct GSF_PendingRequest *pra,
  * @return envelope with the request message
  */
 struct GNUNET_MQ_Envelope *
-GSF_pending_request_get_message_(struct GSF_PendingRequest *pr);
+GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr);
 
 
 /**
@@ -299,8 +303,8 @@ GSF_pending_request_get_message_(struct GSF_PendingRequest *pr);
  * @param full_cleanup fully purge the request
  */
 void
-GSF_pending_request_cancel_(struct GSF_PendingRequest *pr,
-                            int full_cleanup);
+GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr,
+                             int full_cleanup);
 
 
 /**
@@ -325,8 +329,8 @@ typedef int
  * @param cls closure for it
  */
 void
-GSF_iterate_pending_requests_(GSF_PendingRequestIterator it,
-                              void *cls);
+GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it,
+                               void *cls);
 
 
 /**
@@ -339,8 +343,8 @@ GSF_iterate_pending_requests_(GSF_PendingRequestIterator it,
  * @param put the actual message
  */
 void
-handle_p2p_put(void *cls,
-               const struct PutMessage *put);
+handle_p2p_put (void *cls,
+                const struct PutMessage *put);
 
 
 /**
@@ -349,7 +353,7 @@ handle_p2p_put(void *cls,
  * @param pr the pending request to process
  */
 void
-GSF_dht_lookup_(struct GSF_PendingRequest *pr);
+GSF_dht_lookup_ (struct GSF_PendingRequest *pr);
 
 
 /**
@@ -358,7 +362,7 @@ GSF_dht_lookup_(struct GSF_PendingRequest *pr);
  * @param pr the pending request to process
  */
 void
-GSF_cadet_lookup_(struct GSF_PendingRequest *pr);
+GSF_cadet_lookup_ (struct GSF_PendingRequest *pr);
 
 
 /**
@@ -383,9 +387,9 @@ typedef void
  * @param cont_cls closure for @a cont
  */
 void
-GSF_local_lookup_(struct GSF_PendingRequest *pr,
-                  GSF_LocalLookupContinuation cont,
-                  void *cont_cls);
+GSF_local_lookup_ (struct GSF_PendingRequest *pr,
+                   GSF_LocalLookupContinuation cont,
+                   void *cont_cls);
 
 
 /**
@@ -396,8 +400,8 @@ GSF_local_lookup_(struct GSF_PendingRequest *pr,
  * @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);
+GSF_pending_request_test_target_ (struct GSF_PendingRequest *pr,
+                                  const struct GNUNET_PeerIdentity *target);
 
 
 
@@ -405,14 +409,14 @@ GSF_pending_request_test_target_(struct GSF_PendingRequest *pr,
  * Setup the subsystem.
  */
 void
-GSF_pending_request_init_(void);
+GSF_pending_request_init_ (void);
 
 
 /**
  * Shutdown the subsystem.
  */
 void
-GSF_pending_request_done_(void);
+GSF_pending_request_done_ (void);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_push.c b/src/fs/gnunet-service-fs_push.c
index 162dcc0b5..02990a637 100644
--- a/src/fs/gnunet-service-fs_push.c
+++ b/src/fs/gnunet-service-fs_push.c
@@ -49,13 +49,15 @@
  * that if this value is increased, the migration testcase may need to be
  * adjusted as well (especially the CONTENT_LIFETIME in fs_test_lib.c).
  */
-#define MIN_MIGRATION_CONTENT_LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
+#define MIN_MIGRATION_CONTENT_LIFETIME GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_MINUTES, 30)
 
 
 /**
  * Block that is ready for migration to other peers.  Actual data is at the end of the block.
  */
-struct MigrationReadyBlock {
+struct MigrationReadyBlock
+{
   /**
    * This is a doubly-linked list.
    */
@@ -102,7 +104,8 @@ struct MigrationReadyBlock {
 /**
  * Information about a peer waiting for migratable data.
  */
-struct MigrationReadyPeer {
+struct MigrationReadyPeer
+{
   /**
    * This is a doubly-linked list.
    */
@@ -183,15 +186,15 @@ static int value_found;
  * @param mb block to delete
  */
 static void
-delete_migration_block(struct MigrationReadyBlock *mb)
+delete_migration_block (struct MigrationReadyBlock *mb)
 {
-  GNUNET_CONTAINER_DLL_remove(mig_head,
-                              mig_tail,
-                              mb);
-  GNUNET_PEER_decrement_rcs(mb->target_list,
-                            MIGRATION_LIST_SIZE);
+  GNUNET_CONTAINER_DLL_remove (mig_head,
+                               mig_tail,
+                               mb);
+  GNUNET_PEER_decrement_rcs (mb->target_list,
+                             MIGRATION_LIST_SIZE);
   mig_size--;
-  GNUNET_free(mb);
+  GNUNET_free (mb);
 }
 
 
@@ -201,7 +204,7 @@ delete_migration_block(struct MigrationReadyBlock *mb)
  * @param cls a `struct MigrationReadyPeer *`
  */
 static void
-find_content(void *cls);
+find_content (void *cls);
 
 
 /**
@@ -212,50 +215,50 @@ find_content(void *cls);
  * @return #GNUNET_YES if the block was deleted (!)
  */
 static int
-transmit_content(struct MigrationReadyPeer *mrp,
-                 struct MigrationReadyBlock *block)
+transmit_content (struct MigrationReadyPeer *mrp,
+                  struct MigrationReadyBlock *block)
 {
   struct PutMessage *msg;
   unsigned int i;
   struct GSF_PeerPerformanceData *ppd;
   int ret;
 
-  ppd = GSF_get_peer_performance_data_(mrp->peer);
-  GNUNET_assert(NULL == mrp->env);
-  mrp->env = GNUNET_MQ_msg_extra(msg,
-                                 block->size,
-                                 GNUNET_MESSAGE_TYPE_FS_PUT);
-  msg->type = htonl(block->type);
-  msg->expiration = GNUNET_TIME_absolute_hton(block->expiration);
-  GNUNET_memcpy(&msg[1],
-                &block[1],
-                block->size);
+  ppd = GSF_get_peer_performance_data_ (mrp->peer);
+  GNUNET_assert (NULL == mrp->env);
+  mrp->env = GNUNET_MQ_msg_extra (msg,
+                                  block->size,
+                                  GNUNET_MESSAGE_TYPE_FS_PUT);
+  msg->type = htonl (block->type);
+  msg->expiration = GNUNET_TIME_absolute_hton (block->expiration);
+  GNUNET_memcpy (&msg[1],
+                 &block[1],
+                 block->size);
   for (i = 0; i < MIGRATION_LIST_SIZE; i++)
+  {
+    if (block->target_list[i] == 0)
     {
-      if (block->target_list[i] == 0)
-        {
-          block->target_list[i] = ppd->pid;
-          GNUNET_PEER_change_rc(block->target_list[i],
-                                1);
-          break;
-        }
+      block->target_list[i] = ppd->pid;
+      GNUNET_PEER_change_rc (block->target_list[i],
+                             1);
+      break;
     }
+  }
   if (MIGRATION_LIST_SIZE == i)
-    {
-      delete_migration_block(block);
-      ret = GNUNET_YES;
-    }
+  {
+    delete_migration_block (block);
+    ret = GNUNET_YES;
+  }
   else
-    {
-      ret = GNUNET_NO;
-    }
-  GNUNET_MQ_notify_sent(mrp->env,
-                        &find_content,
-                        mrp);
-  GSF_peer_transmit_(mrp->peer,
-                     GNUNET_NO,
-                     0 /* priority */,
-                     mrp->env);
+  {
+    ret = GNUNET_NO;
+  }
+  GNUNET_MQ_notify_sent (mrp->env,
+                         &find_content,
+                         mrp);
+  GSF_peer_transmit_ (mrp->peer,
+                      GNUNET_NO,
+                      0 /* priority */,
+                      mrp->env);
   return ret;
 }
 
@@ -268,7 +271,7 @@ transmit_content(struct MigrationReadyPeer *mrp,
  * @return number of times block was forwarded
  */
 static unsigned int
-count_targets(struct MigrationReadyBlock *block)
+count_targets (struct MigrationReadyBlock *block)
 {
   unsigned int i;
 
@@ -288,8 +291,8 @@ count_targets(struct MigrationReadyBlock *block)
  * @return score (>= 0: feasible, negative: infeasible)
  */
 static long
-score_content(struct MigrationReadyPeer *mrp,
-              struct MigrationReadyBlock *block)
+score_content (struct MigrationReadyPeer *mrp,
+               struct MigrationReadyBlock *block)
 {
   unsigned int i;
   struct GSF_PeerPerformanceData *ppd;
@@ -297,18 +300,18 @@ score_content(struct MigrationReadyPeer *mrp,
   struct GNUNET_HashCode hc;
   uint32_t dist;
 
-  ppd = GSF_get_peer_performance_data_(mrp->peer);
+  ppd = GSF_get_peer_performance_data_ (mrp->peer);
   for (i = 0; i < MIGRATION_LIST_SIZE; i++)
     if (block->target_list[i] == ppd->pid)
       return -1;
-  GNUNET_assert(0 != ppd->pid);
-  GNUNET_PEER_resolve(ppd->pid,
-                      &id);
-  GNUNET_CRYPTO_hash(&id,
-                     sizeof(struct GNUNET_PeerIdentity),
-                     &hc);
-  dist = GNUNET_CRYPTO_hash_distance_u32(&block->query,
-                                         &hc);
+  GNUNET_assert (0 != ppd->pid);
+  GNUNET_PEER_resolve (ppd->pid,
+                       &id);
+  GNUNET_CRYPTO_hash (&id,
+                      sizeof(struct GNUNET_PeerIdentity),
+                      &hc);
+  dist = GNUNET_CRYPTO_hash_distance_u32 (&block->query,
+                                          &hc);
   /* closer distance, higher score: */
   return UINT32_MAX - dist;
 }
@@ -319,7 +322,7 @@ score_content(struct MigrationReadyPeer *mrp,
  * (re)scheduling it with the appropriate delay.
  */
 static void
-consider_gathering(void);
+consider_gathering (void);
 
 
 /**
@@ -328,7 +331,7 @@ consider_gathering(void);
  * @param cls peer to find content for
  */
 static void
-find_content(void *cls)
+find_content (void *cls)
 {
   struct MigrationReadyPeer *mrp = cls;
   struct MigrationReadyBlock *pos;
@@ -341,48 +344,48 @@ find_content(void *cls)
   best_score = -1;
   pos = mig_head;
   while (NULL != pos)
+  {
+    score = score_content (mrp, pos);
+    if (score > best_score)
     {
-      score = score_content(mrp, pos);
-      if (score > best_score)
-        {
-          best_score = score;
-          best = pos;
-        }
-      pos = pos->next;
+      best_score = score;
+      best = pos;
     }
+    pos = pos->next;
+  }
   if (NULL == best)
+  {
+    if (mig_size < MAX_MIGRATION_QUEUE)
     {
-      if (mig_size < MAX_MIGRATION_QUEUE)
-        {
-          GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                     "No content found for pushing, waiting for queue to fill\n");
-          return;               /* will fill up eventually... */
-        }
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "No suitable content found, purging content from full queue\n");
-      /* failed to find migration target AND
-       * queue is full, purge most-forwarded
-       * block from queue to make room for more */
-      pos = mig_head;
-      while (NULL != pos)
-        {
-          score = count_targets(pos);
-          if (score >= best_score)
-            {
-              best_score = score;
-              best = pos;
-            }
-          pos = pos->next;
-        }
-      GNUNET_assert(NULL != best);
-      delete_migration_block(best);
-      consider_gathering();
-      return;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "No content found for pushing, waiting for queue to fill\n");
+      return;                   /* will fill up eventually... */
     }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Preparing to push best content to peer\n");
-  transmit_content(mrp,
-                   best);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No suitable content found, purging content from full queue\n");
+    /* failed to find migration target AND
+     * queue is full, purge most-forwarded
+     * block from queue to make room for more */
+    pos = mig_head;
+    while (NULL != pos)
+    {
+      score = count_targets (pos);
+      if (score >= best_score)
+      {
+        best_score = score;
+        best = pos;
+      }
+      pos = pos->next;
+    }
+    GNUNET_assert (NULL != best);
+    delete_migration_block (best);
+    consider_gathering ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Preparing to push best content to peer\n");
+  transmit_content (mrp,
+                    best);
 }
 
 
@@ -393,7 +396,7 @@ find_content(void *cls)
  * @param cls unused
  */
 static void
-gather_migration_blocks(void *cls);
+gather_migration_blocks (void *cls);
 
 
 /**
@@ -401,7 +404,7 @@ gather_migration_blocks(void *cls);
  * (re)scheduling it with the appropriate delay.
  */
 static void
-consider_gathering()
+consider_gathering ()
 {
   struct GNUNET_TIME_Relative delay;
 
@@ -413,25 +416,26 @@ consider_gathering()
     return;
   if (mig_size >= MAX_MIGRATION_QUEUE)
     return;
-  delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-                                        mig_size);
-  delay = GNUNET_TIME_relative_divide(delay,
-                                      MAX_MIGRATION_QUEUE);
-  delay = GNUNET_TIME_relative_max(delay,
-                                   min_migration_delay);
+  delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                         mig_size);
+  delay = GNUNET_TIME_relative_divide (delay,
+                                       MAX_MIGRATION_QUEUE);
+  delay = GNUNET_TIME_relative_max (delay,
+                                    min_migration_delay);
   if (GNUNET_NO == value_found)
-    {
-      /* wait at least 5s if the datastore is empty */
-      delay = GNUNET_TIME_relative_max(delay,
-                                       GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
-                                                                     5));
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Scheduling gathering task (queue size: %u)\n",
-             mig_size);
-  mig_task = GNUNET_SCHEDULER_add_delayed(delay,
-                                          &gather_migration_blocks,
-                                          NULL);
+  {
+    /* wait at least 5s if the datastore is empty */
+    delay = GNUNET_TIME_relative_max (delay,
+                                      GNUNET_TIME_relative_multiply (
+                                        GNUNET_TIME_UNIT_SECONDS,
+                                        5));
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Scheduling gathering task (queue size: %u)\n",
+              mig_size);
+  mig_task = GNUNET_SCHEDULER_add_delayed (delay,
+                                           &gather_migration_blocks,
+                                           NULL);
 }
 
 
@@ -451,82 +455,82 @@ consider_gathering()
  *        maybe 0 if no unique identifier is available
  */
 static void
-process_migration_content(void *cls,
-                          const struct GNUNET_HashCode *key,
-                          size_t size,
-                          const void *data,
-                          enum GNUNET_BLOCK_Type type,
-                          uint32_t priority,
-                          uint32_t anonymity,
-                          uint32_t replication,
-                          struct GNUNET_TIME_Absolute expiration,
-                          uint64_t uid)
+process_migration_content (void *cls,
+                           const struct GNUNET_HashCode *key,
+                           size_t size,
+                           const void *data,
+                           enum GNUNET_BLOCK_Type type,
+                           uint32_t priority,
+                           uint32_t anonymity,
+                           uint32_t replication,
+                           struct GNUNET_TIME_Absolute expiration,
+                           uint64_t uid)
 {
   struct MigrationReadyBlock *mb;
   struct MigrationReadyPeer *pos;
 
   mig_qe = NULL;
   if (NULL == key)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "No content found for migration...\n");
-      consider_gathering();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No content found for migration...\n");
+    consider_gathering ();
+    return;
+  }
   value_found = GNUNET_YES;
-  if (GNUNET_TIME_absolute_get_remaining(expiration).rel_value_us <
+  if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value_us <
       MIN_MIGRATION_CONTENT_LIFETIME.rel_value_us)
-    {
-      /* content will expire soon, don't bother */
-      consider_gathering();
-      return;
-    }
+  {
+    /* content will expire soon, don't bother */
+    consider_gathering ();
+    return;
+  }
   if (type == GNUNET_BLOCK_TYPE_FS_ONDEMAND)
-    {
-      if (GNUNET_OK !=
-          GNUNET_FS_handle_on_demand_block(key,
-                                           size,
-                                           data,
-                                           type,
-                                           priority,
-                                           anonymity,
-                                           replication,
-                                           expiration,
-                                           uid,
-                                           &process_migration_content,
-                                           NULL))
-        consider_gathering();
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Retrieved block `%s' of type %u for migration (queue size: %u/%u)\n",
-             GNUNET_h2s(key),
-             type, mig_size + 1,
-             MAX_MIGRATION_QUEUE);
-  mb = GNUNET_malloc(sizeof(struct MigrationReadyBlock) + size);
+  {
+    if (GNUNET_OK !=
+        GNUNET_FS_handle_on_demand_block (key,
+                                          size,
+                                          data,
+                                          type,
+                                          priority,
+                                          anonymity,
+                                          replication,
+                                          expiration,
+                                          uid,
+                                          &process_migration_content,
+                                          NULL))
+      consider_gathering ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Retrieved block `%s' of type %u for migration (queue size: %u/%u)\n",
+              GNUNET_h2s (key),
+              type, mig_size + 1,
+              MAX_MIGRATION_QUEUE);
+  mb = GNUNET_malloc (sizeof(struct MigrationReadyBlock) + size);
   mb->query = *key;
   mb->expiration = expiration;
   mb->size = size;
   mb->type = type;
-  GNUNET_memcpy(&mb[1], data, size);
-  GNUNET_CONTAINER_DLL_insert_after(mig_head,
-                                    mig_tail,
-                                    mig_tail,
-                                    mb);
+  GNUNET_memcpy (&mb[1], data, size);
+  GNUNET_CONTAINER_DLL_insert_after (mig_head,
+                                     mig_tail,
+                                     mig_tail,
+                                     mb);
   mig_size++;
   for (pos = peer_head; NULL != pos; pos = pos->next)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Preparing to push best content to peer %s\n",
+                GNUNET_i2s (GSF_connected_peer_get_identity2_ (pos->peer)));
+    if ((NULL == pos->env) &&
+        (GNUNET_YES == transmit_content (pos,
+                                         mb)))
     {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Preparing to push best content to peer %s\n",
-                 GNUNET_i2s(GSF_connected_peer_get_identity2_(pos->peer)));
-      if ((NULL == pos->env) &&
-          (GNUNET_YES == transmit_content(pos,
-                                          mb)))
-        {
-          break;              /* 'mb' was freed! */
-        }
+      break;                  /* 'mb' was freed! */
     }
-  consider_gathering();
+  }
+  consider_gathering ();
 }
 
 
@@ -537,24 +541,24 @@ process_migration_content(void *cls,
  * @param cls unused
  */
 static void
-gather_migration_blocks(void *cls)
+gather_migration_blocks (void *cls)
 {
   mig_task = NULL;
   if (mig_size >= MAX_MIGRATION_QUEUE)
     return;
   if (NULL == GSF_dsh)
     return;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Asking datastore for content for replication (queue size: %u)\n",
-             mig_size);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Asking datastore for content for replication (queue size: %u)\n",
+              mig_size);
   value_found = GNUNET_NO;
-  mig_qe = GNUNET_DATASTORE_get_for_replication(GSF_dsh,
-                                                0,
-                                                UINT_MAX,
-                                                &process_migration_content,
-                                                NULL);
+  mig_qe = GNUNET_DATASTORE_get_for_replication (GSF_dsh,
+                                                 0,
+                                                 UINT_MAX,
+                                                 &process_migration_content,
+                                                 NULL);
   if (NULL == mig_qe)
-    consider_gathering();
+    consider_gathering ();
 }
 
 
@@ -565,7 +569,7 @@ gather_migration_blocks(void *cls)
  * @param peer handle for the peer that connected
  */
 void
-GSF_push_start_(struct GSF_ConnectedPeer *peer)
+GSF_push_start_ (struct GSF_ConnectedPeer *peer)
 {
   struct MigrationReadyPeer *mrp;
 
@@ -575,22 +579,22 @@ GSF_push_start_(struct GSF_ConnectedPeer *peer)
     if (mrp->peer == peer)
       break;
   if (NULL != mrp)
-    {
-      /* same peer added twice, must not happen */
-      GNUNET_break(0);
-      return;
-    }
+  {
+    /* same peer added twice, must not happen */
+    GNUNET_break (0);
+    return;
+  }
 
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Adding peer %s to list for pushing\n",
-             GNUNET_i2s(GSF_connected_peer_get_identity2_(peer)));
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Adding peer %s to list for pushing\n",
+              GNUNET_i2s (GSF_connected_peer_get_identity2_ (peer)));
 
-  mrp = GNUNET_new(struct MigrationReadyPeer);
+  mrp = GNUNET_new (struct MigrationReadyPeer);
   mrp->peer = peer;
-  find_content(mrp);
-  GNUNET_CONTAINER_DLL_insert(peer_head,
-                              peer_tail,
-                              mrp);
+  find_content (mrp);
+  GNUNET_CONTAINER_DLL_insert (peer_head,
+                               peer_tail,
+                               mrp);
 }
 
 
@@ -601,7 +605,7 @@ GSF_push_start_(struct GSF_ConnectedPeer *peer)
  * @param peer handle for the peer that disconnected
  */
 void
-GSF_push_stop_(struct GSF_ConnectedPeer *peer)
+GSF_push_stop_ (struct GSF_ConnectedPeer *peer)
 {
   struct MigrationReadyPeer *pos;
 
@@ -611,11 +615,11 @@ GSF_push_stop_(struct GSF_ConnectedPeer *peer)
   if (NULL == pos)
     return;
   if (NULL != pos->env)
-    GNUNET_MQ_send_cancel(pos->env);
-  GNUNET_CONTAINER_DLL_remove(peer_head,
-                              peer_tail,
-                              pos);
-  GNUNET_free(pos);
+    GNUNET_MQ_send_cancel (pos->env);
+  GNUNET_CONTAINER_DLL_remove (peer_head,
+                               peer_tail,
+                               pos);
+  GNUNET_free (pos);
 }
 
 
@@ -623,28 +627,28 @@ GSF_push_stop_(struct GSF_ConnectedPeer *peer)
  * Setup the module.
  */
 void
-GSF_push_init_()
+GSF_push_init_ ()
 {
   enabled =
-    GNUNET_CONFIGURATION_get_value_yesno(GSF_cfg,
-                                         "FS",
-                                         "CONTENT_PUSHING");
+    GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg,
+                                          "FS",
+                                          "CONTENT_PUSHING");
   if (GNUNET_YES != enabled)
     return;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_time(GSF_cfg,
-                                          "fs",
-                                          "MIN_MIGRATION_DELAY",
-                                          &min_migration_delay))
-    {
-      GNUNET_log_config_invalid(GNUNET_ERROR_TYPE_WARNING,
-                                "fs",
-                                "MIN_MIGRATION_DELAY",
-                                _("time required, content pushing disabled"));
-      return;
-    }
-  consider_gathering();
+      GNUNET_CONFIGURATION_get_value_time (GSF_cfg,
+                                           "fs",
+                                           "MIN_MIGRATION_DELAY",
+                                           &min_migration_delay))
+  {
+    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
+                               "fs",
+                               "MIN_MIGRATION_DELAY",
+                               _ ("time required, content pushing disabled"));
+    return;
+  }
+  consider_gathering ();
 }
 
 
@@ -652,21 +656,21 @@ GSF_push_init_()
  * Shutdown the module.
  */
 void
-GSF_push_done_()
+GSF_push_done_ ()
 {
   if (NULL != mig_task)
-    {
-      GNUNET_SCHEDULER_cancel(mig_task);
-      mig_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (mig_task);
+    mig_task = NULL;
+  }
   if (NULL != mig_qe)
-    {
-      GNUNET_DATASTORE_cancel(mig_qe);
-      mig_qe = NULL;
-    }
+  {
+    GNUNET_DATASTORE_cancel (mig_qe);
+    mig_qe = NULL;
+  }
   while (NULL != mig_head)
-    delete_migration_block(mig_head);
-  GNUNET_assert(0 == mig_size);
+    delete_migration_block (mig_head);
+  GNUNET_assert (0 == mig_size);
 }
 
 /* end of gnunet-service-fs_push.c */
diff --git a/src/fs/gnunet-service-fs_push.h b/src/fs/gnunet-service-fs_push.h
index 0917364e2..2cd621bbb 100644
--- a/src/fs/gnunet-service-fs_push.h
+++ b/src/fs/gnunet-service-fs_push.h
@@ -33,14 +33,14 @@
  * Setup the module.
  */
 void
-GSF_push_init_(void);
+GSF_push_init_ (void);
 
 
 /**
  * Shutdown the module.
  */
 void
-GSF_push_done_(void);
+GSF_push_done_ (void);
 
 
 /**
@@ -50,7 +50,7 @@ GSF_push_done_(void);
  * @param peer handle for the peer that connected
  */
 void
-GSF_push_start_(struct GSF_ConnectedPeer *peer);
+GSF_push_start_ (struct GSF_ConnectedPeer *peer);
 
 
 /**
@@ -60,7 +60,7 @@ GSF_push_start_(struct GSF_ConnectedPeer *peer);
  * @param peer handle for the peer that disconnected
  */
 void
-GSF_push_stop_(struct GSF_ConnectedPeer *peer);
+GSF_push_stop_ (struct GSF_ConnectedPeer *peer);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_put.c b/src/fs/gnunet-service-fs_put.c
index deba91a0c..335496119 100644
--- a/src/fs/gnunet-service-fs_put.c
+++ b/src/fs/gnunet-service-fs_put.c
@@ -31,7 +31,8 @@
 /**
  * How often do we at most PUT content into the DHT?
  */
-#define MAX_DHT_PUT_FREQ GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
+#define MAX_DHT_PUT_FREQ GNUNET_TIME_relative_multiply ( \
+    GNUNET_TIME_UNIT_SECONDS, 5)
 
 /**
  * How many replicas do we try to create per PUT?
@@ -42,7 +43,8 @@
 /**
  * Context for each zero-anonymity iterator.
  */
-struct PutOperator {
+struct PutOperator
+{
   /**
    * Request to datastore for DHT PUTs (or NULL).
    */
@@ -61,7 +63,7 @@ struct PutOperator {
   /**
    * ID of task that collects blocks for DHT PUTs.
    */
-  struct GNUNET_SCHEDULER_Task * dht_task;
+  struct GNUNET_SCHEDULER_Task *dht_task;
 
   /**
    * How many entires with zero anonymity of our type do we currently
@@ -98,7 +100,7 @@ static struct PutOperator operators[] = {
  * @param tc scheduler context (unused)
  */
 static void
-gather_dht_put_blocks(void *cls);
+gather_dht_put_blocks (void *cls);
 
 
 /**
@@ -107,25 +109,25 @@ gather_dht_put_blocks(void *cls);
  * @param po put operator to schedule
  */
 static void
-schedule_next_put(struct PutOperator *po)
+schedule_next_put (struct PutOperator *po)
 {
   struct GNUNET_TIME_Relative delay;
 
   if (po->zero_anonymity_count_estimate > 0)
-    {
-      delay =
-        GNUNET_TIME_relative_divide(GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY,
-                                    po->zero_anonymity_count_estimate);
-      delay = GNUNET_TIME_relative_min(delay, MAX_DHT_PUT_FREQ);
-    }
+  {
+    delay =
+      GNUNET_TIME_relative_divide (GNUNET_DHT_DEFAULT_REPUBLISH_FREQUENCY,
+                                   po->zero_anonymity_count_estimate);
+    delay = GNUNET_TIME_relative_min (delay, MAX_DHT_PUT_FREQ);
+  }
   else
-    {
-      /* if we have NO zero-anonymity content yet, wait 5 minutes for some to
-       * (hopefully) appear */
-      delay = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5);
-    }
+  {
+    /* if we have NO zero-anonymity content yet, wait 5 minutes for some to
+     * (hopefully) appear */
+    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5);
+  }
   po->dht_task =
-    GNUNET_SCHEDULER_add_delayed(delay, &gather_dht_put_blocks, po);
+    GNUNET_SCHEDULER_add_delayed (delay, &gather_dht_put_blocks, po);
 }
 
 
@@ -135,12 +137,12 @@ schedule_next_put(struct PutOperator *po)
  * @param cls type of blocks to gather
  */
 static void
-delay_dht_put_blocks(void *cls)
+delay_dht_put_blocks (void *cls)
 {
   struct PutOperator *po = cls;
 
   po->dht_put = NULL;
-  schedule_next_put(po);
+  schedule_next_put (po);
 }
 
 
@@ -150,12 +152,12 @@ delay_dht_put_blocks(void *cls)
  * @param cls type of blocks to gather
  */
 static void
-delay_dht_put_task(void *cls)
+delay_dht_put_task (void *cls)
 {
   struct PutOperator *po = cls;
 
   po->dht_task = NULL;
-  schedule_next_put(po);
+  schedule_next_put (po);
 }
 
 
@@ -175,45 +177,45 @@ delay_dht_put_task(void *cls)
  *        maybe 0 if no unique identifier is available
  */
 static void
-process_dht_put_content(void *cls,
-                        const struct GNUNET_HashCode * key,
-                        size_t size,
-                        const void *data,
-                        enum GNUNET_BLOCK_Type type,
-                        uint32_t priority,
-                        uint32_t anonymity,
-                        uint32_t replication,
-                        struct GNUNET_TIME_Absolute expiration,
-                        uint64_t uid)
+process_dht_put_content (void *cls,
+                         const struct GNUNET_HashCode *key,
+                         size_t size,
+                         const void *data,
+                         enum GNUNET_BLOCK_Type type,
+                         uint32_t priority,
+                         uint32_t anonymity,
+                         uint32_t replication,
+                         struct GNUNET_TIME_Absolute expiration,
+                         uint64_t uid)
 {
   struct PutOperator *po = cls;
 
   po->dht_qe = NULL;
   if (key == NULL)
-    {
-      po->zero_anonymity_count_estimate = po->result_count;
-      po->result_count = 0;
-      po->next_uid = 0;
-      po->dht_task = GNUNET_SCHEDULER_add_now(&delay_dht_put_task, po);
-      return;
-    }
+  {
+    po->zero_anonymity_count_estimate = po->result_count;
+    po->result_count = 0;
+    po->next_uid = 0;
+    po->dht_task = GNUNET_SCHEDULER_add_now (&delay_dht_put_task, po);
+    return;
+  }
   po->result_count++;
   po->next_uid = uid + 1;
   po->zero_anonymity_count_estimate =
-    GNUNET_MAX(po->result_count, po->zero_anonymity_count_estimate);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Retrieved block `%s' of type %u for DHT PUT\n", GNUNET_h2s(key),
-             type);
-  po->dht_put = GNUNET_DHT_put(GSF_dht,
-                               key,
-                               DEFAULT_PUT_REPLICATION,
-                               GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                               type,
-                               size,
-                               data,
-                               expiration,
-                               &delay_dht_put_blocks,
-                               po);
+    GNUNET_MAX (po->result_count, po->zero_anonymity_count_estimate);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Retrieved block `%s' of type %u for DHT PUT\n", GNUNET_h2s (key),
+              type);
+  po->dht_put = GNUNET_DHT_put (GSF_dht,
+                                key,
+                                DEFAULT_PUT_REPLICATION,
+                                GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                                type,
+                                size,
+                                data,
+                                expiration,
+                                &delay_dht_put_blocks,
+                                po);
 }
 
 
@@ -223,21 +225,21 @@ process_dht_put_content(void *cls,
  * @param cls type of blocks to gather
  */
 static void
-gather_dht_put_blocks(void *cls)
+gather_dht_put_blocks (void *cls)
 {
   struct PutOperator *po = cls;
 
   po->dht_task = NULL;
   po->dht_qe =
-    GNUNET_DATASTORE_get_zero_anonymity(GSF_dsh,
-                                        po->next_uid,
-                                        0,
-                                        UINT_MAX,
-                                        po->dht_put_type,
-                                        &process_dht_put_content,
-                                        po);
+    GNUNET_DATASTORE_get_zero_anonymity (GSF_dsh,
+                                         po->next_uid,
+                                         0,
+                                         UINT_MAX,
+                                         po->dht_put_type,
+                                         &process_dht_put_content,
+                                         po);
   if (NULL == po->dht_qe)
-    po->dht_task = GNUNET_SCHEDULER_add_now(&delay_dht_put_task, po);
+    po->dht_task = GNUNET_SCHEDULER_add_now (&delay_dht_put_task, po);
 }
 
 
@@ -245,17 +247,17 @@ gather_dht_put_blocks(void *cls)
  * Setup the module.
  */
 void
-GSF_put_init_()
+GSF_put_init_ ()
 {
   unsigned int i;
 
   i = 0;
   while (operators[i].dht_put_type != GNUNET_BLOCK_TYPE_ANY)
-    {
-      operators[i].dht_task =
-        GNUNET_SCHEDULER_add_now(&gather_dht_put_blocks, &operators[i]);
-      i++;
-    }
+  {
+    operators[i].dht_task =
+      GNUNET_SCHEDULER_add_now (&gather_dht_put_blocks, &operators[i]);
+    i++;
+  }
 }
 
 
@@ -263,31 +265,31 @@ GSF_put_init_()
  * Shutdown the module.
  */
 void
-GSF_put_done_()
+GSF_put_done_ ()
 {
   struct PutOperator *po;
   unsigned int i;
 
   i = 0;
   while ((po = &operators[i])->dht_put_type != GNUNET_BLOCK_TYPE_ANY)
+  {
+    if (NULL != po->dht_task)
+    {
+      GNUNET_SCHEDULER_cancel (po->dht_task);
+      po->dht_task = NULL;
+    }
+    if (NULL != po->dht_put)
+    {
+      GNUNET_DHT_put_cancel (po->dht_put);
+      po->dht_put = NULL;
+    }
+    if (NULL != po->dht_qe)
     {
-      if (NULL != po->dht_task)
-        {
-          GNUNET_SCHEDULER_cancel(po->dht_task);
-          po->dht_task = NULL;
-        }
-      if (NULL != po->dht_put)
-        {
-          GNUNET_DHT_put_cancel(po->dht_put);
-          po->dht_put = NULL;
-        }
-      if (NULL != po->dht_qe)
-        {
-          GNUNET_DATASTORE_cancel(po->dht_qe);
-          po->dht_qe = NULL;
-        }
-      i++;
+      GNUNET_DATASTORE_cancel (po->dht_qe);
+      po->dht_qe = NULL;
     }
+    i++;
+  }
 }
 
 /* end of gnunet-service-fs_put.c */
diff --git a/src/fs/gnunet-service-fs_put.h b/src/fs/gnunet-service-fs_put.h
index 2d85d9831..b6c9ba86f 100644
--- a/src/fs/gnunet-service-fs_put.h
+++ b/src/fs/gnunet-service-fs_put.h
@@ -33,14 +33,14 @@
  * Setup the module.
  */
 void
-GSF_put_init_(void);
+GSF_put_init_ (void);
 
 
 /**
  * Shutdown the module.
  */
 void
-GSF_put_done_(void);
+GSF_put_done_ (void);
 
 
 #endif
diff --git a/src/fs/gnunet-unindex.c b/src/fs/gnunet-unindex.c
index 873dfa5eb..88825fa60 100644
--- a/src/fs/gnunet-unindex.c
+++ b/src/fs/gnunet-unindex.c
@@ -40,24 +40,24 @@ static struct GNUNET_FS_UnindexContext *uc;
 
 
 static void
-cleanup_task(void *cls)
+cleanup_task (void *cls)
 {
-  GNUNET_FS_stop(ctx);
+  GNUNET_FS_stop (ctx);
   ctx = NULL;
 }
 
 
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
   struct GNUNET_FS_UnindexContext *u;
 
   if (uc != NULL)
-    {
-      u = uc;
-      uc = NULL;
-      GNUNET_FS_unindex_stop(u);
-    }
+  {
+    u = uc;
+    uc = NULL;
+    GNUNET_FS_unindex_stop (u);
+  }
 }
 
 /**
@@ -74,48 +74,48 @@ shutdown_task(void *cls)
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   const char *s;
 
   switch (info->status)
+  {
+  case GNUNET_FS_STATUS_UNINDEX_START:
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    if (verbose)
     {
-    case GNUNET_FS_STATUS_UNINDEX_START:
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
-      if (verbose)
-        {
-          s = GNUNET_STRINGS_relative_time_to_string(info->value.unindex.eta,
-                                                     GNUNET_YES);
-          fprintf(stdout,
-                  _("Unindexing at %llu/%llu (%s remaining)\n"),
-                  (unsigned long long)info->value.unindex.completed,
-                  (unsigned long long)info->value.unindex.size,
-                  s);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_ERROR:
-      fprintf(stderr,
-              _("Error unindexing: %s.\n"),
-              info->value.unindex.specifics.error.message);
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
-      fprintf(stdout, "%s", _("Unindexing done.\n"));
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_STOPPED:
-      GNUNET_SCHEDULER_add_now(&cleanup_task, NULL);
-      break;
-
-    default:
-      fprintf(stderr, _("Unexpected status: %d\n"), info->status);
-      break;
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.unindex.eta,
+                                                  GNUNET_YES);
+      fprintf (stdout,
+               _ ("Unindexing at %llu/%llu (%s remaining)\n"),
+               (unsigned long long) info->value.unindex.completed,
+               (unsigned long long) info->value.unindex.size,
+               s);
     }
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_ERROR:
+    fprintf (stderr,
+             _ ("Error unindexing: %s.\n"),
+             info->value.unindex.specifics.error.message);
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
+    fprintf (stdout, "%s", _ ("Unindexing done.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_STOPPED:
+    GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
+    break;
+
+  default:
+    fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
+    break;
+  }
   return NULL;
 }
 
@@ -129,39 +129,39 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
  * @param c configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
   /* check arguments */
   if ((args[0] == NULL) || (args[1] != NULL))
-    {
-      printf(_("You must specify one and only one filename for unindexing.\n"));
-      ret = -1;
-      return;
-    }
+  {
+    printf (_ ("You must specify one and only one filename for unindexing.\n"));
+    ret = -1;
+    return;
+  }
   cfg = c;
-  ctx = GNUNET_FS_start(cfg,
-                        "gnunet-unindex",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
+  ctx = GNUNET_FS_start (cfg,
+                         "gnunet-unindex",
+                         &progress_cb,
+                         NULL,
+                         GNUNET_FS_FLAGS_NONE,
+                         GNUNET_FS_OPTIONS_END);
   if (NULL == ctx)
-    {
-      fprintf(stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
-      ret = 1;
-      return;
-    }
-  uc = GNUNET_FS_unindex_start(ctx, args[0], NULL);
+  {
+    fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
+    ret = 1;
+    return;
+  }
+  uc = GNUNET_FS_unindex_start (ctx, args[0], NULL);
   if (NULL == uc)
-    {
-      fprintf(stderr, "%s", _("Could not start unindex operation.\n"));
-      GNUNET_FS_stop(ctx);
-      return;
-    }
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task, NULL);
+  {
+    fprintf (stderr, "%s", _ ("Could not start unindex operation.\n"));
+    GNUNET_FS_stop (ctx);
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
 }
 
 
@@ -173,30 +173,30 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
-    GNUNET_GETOPT_option_verbose(&verbose),
+    GNUNET_GETOPT_option_verbose (&verbose),
 
     GNUNET_GETOPT_OPTION_END
   };
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
 
   ret = (GNUNET_OK ==
-         GNUNET_PROGRAM_run(
+         GNUNET_PROGRAM_run (
            argc,
            argv,
            "gnunet-unindex [OPTIONS] FILENAME",
-           gettext_noop(
+           gettext_noop (
              "Unindex a file that was previously indexed with gnunet-publish."),
            options,
            &run,
            NULL))
         ? ret
         : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }
 
diff --git a/src/fs/perf_gnunet_service_fs_p2p.c b/src/fs/perf_gnunet_service_fs_p2p.c
index 515144eb1..39563dfa4 100644
--- a/src/fs/perf_gnunet_service_fs_p2p.c
+++ b/src/fs/perf_gnunet_service_fs_p2p.c
@@ -37,7 +37,7 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
 
 #define NUM_DAEMONS 2
 
@@ -57,14 +57,16 @@ static struct GNUNET_TIME_Absolute start_time;
 /**
  * Master context for 'stat_run'.
  */
-struct StatMaster {
+struct StatMaster
+{
   struct GNUNET_STATISTICS_Handle *stat;
   struct GNUNET_TESTBED_Operation *op;
   unsigned int daemon;
   unsigned int value;
 };
 
-struct StatValues {
+struct StatValues
+{
   const char *subsystem;
   const char *name;
 };
@@ -109,17 +111,17 @@ static struct StatValues stats[] = {
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-print_stat(void *cls, const char *subsystem, const char *name, uint64_t value,
-           int is_persistent)
+print_stat (void *cls, const char *subsystem, const char *name, uint64_t value,
+            int is_persistent)
 {
   struct StatMaster *sm = cls;
 
-  fprintf(stderr,
-          "Peer %2u: %12s/%50s = %12llu\n",
-          sm->daemon,
-          subsystem,
-          name,
-          (unsigned long long)value);
+  fprintf (stderr,
+           "Peer %2u: %12s/%50s = %12llu\n",
+           sm->daemon,
+           subsystem,
+           name,
+           (unsigned long long) value);
   return GNUNET_OK;
 }
 
@@ -128,23 +130,23 @@ print_stat(void *cls, const char *subsystem, const char *name, uint64_t value,
  * Function that gathers stats from all daemons.
  */
 static void
-stat_run(void *cls,
-         struct GNUNET_TESTBED_Operation *op,
-         void *ca_result,
-         const char *emsg);
+stat_run (void *cls,
+          struct GNUNET_TESTBED_Operation *op,
+          void *ca_result,
+          const char *emsg);
 
 
 /**
  * Function called when GET operation on stats is done.
  */
 static void
-get_done(void *cls, int success)
+get_done (void *cls, int success)
 {
   struct StatMaster *sm = cls;
 
-  GNUNET_break(GNUNET_OK == success);
+  GNUNET_break (GNUNET_OK == success);
   sm->value++;
-  stat_run(sm, sm->op, sm->stat, NULL);
+  stat_run (sm, sm->op, sm->stat, NULL);
 }
 
 
@@ -159,11 +161,11 @@ get_done(void *cls, int success)
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-statistics_connect_adapter(void *cls,
-                           const struct GNUNET_CONFIGURATION_Handle *cfg)
+statistics_connect_adapter (void *cls,
+                            const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  return GNUNET_STATISTICS_create("<driver>",
-                                  cfg);
+  return GNUNET_STATISTICS_create ("<driver>",
+                                   cfg);
 }
 
 
@@ -175,10 +177,10 @@ statistics_connect_adapter(void *cls,
  * @param op_result service handle returned from the connect adapter
  */
 static void
-statistics_disconnect_adapter(void *cls,
-                              void *op_result)
+statistics_disconnect_adapter (void *cls,
+                               void *op_result)
 {
-  GNUNET_STATISTICS_destroy(op_result, GNUNET_NO);
+  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
 }
 
 
@@ -186,57 +188,57 @@ statistics_disconnect_adapter(void *cls,
  * Function that gathers stats from all daemons.
  */
 static void
-stat_run(void *cls,
-         struct GNUNET_TESTBED_Operation *op,
-         void *ca_result,
-         const char *emsg)
+stat_run (void *cls,
+          struct GNUNET_TESTBED_Operation *op,
+          void *ca_result,
+          const char *emsg)
 {
   struct StatMaster *sm = cls;
 
   if (NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Failed to statistics service: %s\n",
-                 emsg);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to statistics service: %s\n",
+                emsg);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   sm->stat = ca_result;
 
   if (stats[sm->value].name != NULL)
-    {
-      GNUNET_STATISTICS_get(sm->stat,
+  {
+    GNUNET_STATISTICS_get (sm->stat,
 #if 0
-                            NULL, NULL,
+                           NULL, NULL,
 #else
-                            stats[sm->value].subsystem, stats[sm->value].name,
+                           stats[sm->value].subsystem, stats[sm->value].name,
 #endif
-                            &get_done, &print_stat,
-                            sm);
-      return;
-    }
-  GNUNET_TESTBED_operation_done(sm->op);
+                           &get_done, &print_stat,
+                           sm);
+    return;
+  }
+  GNUNET_TESTBED_operation_done (sm->op);
   sm->value = 0;
   sm->daemon++;
   if (NUM_DAEMONS == sm->daemon)
-    {
-      GNUNET_free(sm);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_free (sm);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   sm->op =
-    GNUNET_TESTBED_service_connect(NULL,
-                                   daemons[sm->daemon],
-                                   "statistics",
-                                   &stat_run, sm,
-                                   &statistics_connect_adapter,
-                                   &statistics_disconnect_adapter,
-                                   NULL);
+    GNUNET_TESTBED_service_connect (NULL,
+                                    daemons[sm->daemon],
+                                    "statistics",
+                                    &stat_run, sm,
+                                    &statistics_connect_adapter,
+                                    &statistics_disconnect_adapter,
+                                    NULL);
 }
 
 
 static void
-do_report(void *cls)
+do_report (void *cls)
 {
   char *fn = cls;
   struct GNUNET_TIME_Relative del;
@@ -244,120 +246,121 @@ do_report(void *cls)
   struct StatMaster *sm;
 
   if (NULL != fn)
-    {
-      GNUNET_DISK_directory_remove(fn);
-      GNUNET_free(fn);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn);
+    GNUNET_free (fn);
+  }
   if (0 ==
-      GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_add(start_time,
-                                                                  TIMEOUT)).rel_value_us)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Timeout during download, shutting down with error\n");
-      ok = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-
-  del = GNUNET_TIME_absolute_get_duration(start_time);
+      GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
+                                                                    TIMEOUT)).
+      rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during download, shutting down with error\n");
+    ok = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+
+  del = GNUNET_TIME_absolute_get_duration (start_time);
   if (del.rel_value_us == 0)
     del.rel_value_us = 1;
   fancy =
-    GNUNET_STRINGS_byte_size_fancy(((unsigned long long)FILESIZE) *
-                                   1000000LL / del.rel_value_us);
-  fprintf(stdout,
-          "Download speed was %s/s\n",
-          fancy);
-  GNUNET_free(fancy);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Finished download, shutting down\n");
-  sm = GNUNET_new(struct StatMaster);
+    GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE)
+                                    * 1000000LL / del.rel_value_us);
+  fprintf (stdout,
+           "Download speed was %s/s\n",
+           fancy);
+  GNUNET_free (fancy);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finished download, shutting down\n");
+  sm = GNUNET_new (struct StatMaster);
   sm->op =
-    GNUNET_TESTBED_service_connect(NULL,
-                                   daemons[sm->daemon],
-                                   "statistics",
-                                   &stat_run, sm,
-                                   &statistics_connect_adapter,
-                                   &statistics_disconnect_adapter,
-                                   NULL);
+    GNUNET_TESTBED_service_connect (NULL,
+                                    daemons[sm->daemon],
+                                    "statistics",
+                                    &stat_run, sm,
+                                    &statistics_connect_adapter,
+                                    &statistics_disconnect_adapter,
+                                    NULL);
 }
 
 
 static void
-do_download(void *cls,
-            const struct GNUNET_FS_Uri *uri,
-            const char *fn)
+do_download (void *cls,
+             const struct GNUNET_FS_Uri *uri,
+             const char *fn)
 {
   int anonymity;
 
   if (NULL == uri)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  start_time = GNUNET_TIME_absolute_get();
-  if (NULL != strstr(progname, "dht"))
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  start_time = GNUNET_TIME_absolute_get ();
+  if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
-  start_time = GNUNET_TIME_absolute_get();
-  GNUNET_FS_TEST_download(daemons[0],
-                          TIMEOUT,
-                          anonymity,
-                          SEED,
-                          uri,
-                          VERBOSE,
-                          &do_report,
-                          (NULL == fn) ? NULL : GNUNET_strdup(fn));
+  start_time = GNUNET_TIME_absolute_get ();
+  GNUNET_FS_TEST_download (daemons[0],
+                           TIMEOUT,
+                           anonymity,
+                           SEED,
+                           uri,
+                           VERBOSE,
+                           &do_report,
+                           (NULL == fn) ? NULL : GNUNET_strdup (fn));
 }
 
 
 static void
-do_publish(void *cls,
-           struct GNUNET_TESTBED_RunHandle *h,
-           unsigned int num_peers,
-           struct GNUNET_TESTBED_Peer **peers,
-           unsigned int links_succeeded,
-           unsigned int links_failed)
+do_publish (void *cls,
+            struct GNUNET_TESTBED_RunHandle *h,
+            unsigned int num_peers,
+            struct GNUNET_TESTBED_Peer **peers,
+            unsigned int links_succeeded,
+            unsigned int links_failed)
 {
   unsigned int i;
   int do_index;
   int anonymity;
 
-  GNUNET_assert(NUM_DAEMONS == num_peers);
+  GNUNET_assert (NUM_DAEMONS == num_peers);
   for (i = 0; i < num_peers; i++)
     daemons[i] = peers[i];
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  if (NULL != strstr(progname, "index"))
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
     do_index = GNUNET_NO;
-  if (NULL != strstr(progname, "dht"))
+  if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
-  GNUNET_FS_TEST_publish(daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity,
-                         do_index, FILESIZE, SEED, VERBOSE, &do_download,
-                         NULL);
+  GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity,
+                          do_index, FILESIZE, SEED, VERBOSE, &do_download,
+                          NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   progname = argv[0];
-  (void)GNUNET_TESTBED_test_run("perf-gnunet-service-fs-p2p",
-                                "perf_gnunet_service_fs_p2p.conf",
-                                NUM_DAEMONS,
-                                0, NULL, NULL,
-                                &do_publish, NULL);
-  GNUNET_DISK_directory_remove("/tmp/gnunet-test-fs-lib/");
+  (void) GNUNET_TESTBED_test_run ("perf-gnunet-service-fs-p2p",
+                                  "perf_gnunet_service_fs_p2p.conf",
+                                  NUM_DAEMONS,
+                                  0, NULL, NULL,
+                                  &do_publish, NULL);
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ok;
 }
 
diff --git a/src/fs/perf_gnunet_service_fs_p2p_respect.c b/src/fs/perf_gnunet_service_fs_p2p_respect.c
index 91ec9c66d..fc17235fa 100644
--- a/src/fs/perf_gnunet_service_fs_p2p_respect.c
+++ b/src/fs/perf_gnunet_service_fs_p2p_respect.c
@@ -57,7 +57,7 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 30)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 30)
 
 /**
  * Number of daemons in clique, must be at least 3 (!).
@@ -93,14 +93,16 @@ static char *fn2;
 /**
  * Master context for 'stat_run'.
  */
-struct StatMaster {
+struct StatMaster
+{
   struct GNUNET_STATISTICS_Handle *stat;
   struct GNUNET_TESTBED_Operation *op;
   unsigned int daemon;
   unsigned int value;
 };
 
-struct StatValues {
+struct StatValues
+{
   const char *subsystem;
   const char *name;
 };
@@ -134,19 +136,19 @@ static struct StatValues stats[] = {
 
 
 static void
-cleanup()
+cleanup ()
 {
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
   if (NULL != fn1)
-    {
-      GNUNET_DISK_directory_remove(fn1);
-      GNUNET_free(fn1);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn1);
+    GNUNET_free (fn1);
+  }
   if (NULL != fn2)
-    {
-      GNUNET_DISK_directory_remove(fn2);
-      GNUNET_free(fn2);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn2);
+    GNUNET_free (fn2);
+  }
 }
 
 
@@ -161,13 +163,13 @@ cleanup()
  * @return GNUNET_OK to continue, GNUNET_SYSERR to abort iteration
  */
 static int
-print_stat(void *cls, const char *subsystem, const char *name, uint64_t value,
-           int is_persistent)
+print_stat (void *cls, const char *subsystem, const char *name, uint64_t value,
+            int is_persistent)
 {
   struct StatMaster *sm = cls;
 
-  fprintf(stderr, "Peer %2u: %12s/%50s = %12llu\n", sm->daemon, subsystem,
-          name, (unsigned long long)value);
+  fprintf (stderr, "Peer %2u: %12s/%50s = %12llu\n", sm->daemon, subsystem,
+           name, (unsigned long long) value);
   return GNUNET_OK;
 }
 
@@ -176,23 +178,23 @@ print_stat(void *cls, const char *subsystem, const char *name, uint64_t value,
  * Function that gathers stats from all daemons.
  */
 static void
-stat_run(void *cls,
-         struct GNUNET_TESTBED_Operation *op,
-         void *ca_result,
-         const char *emsg);
+stat_run (void *cls,
+          struct GNUNET_TESTBED_Operation *op,
+          void *ca_result,
+          const char *emsg);
 
 
 /**
  * Function called when GET operation on stats is done.
  */
 static void
-get_done(void *cls, int success)
+get_done (void *cls, int success)
 {
   struct StatMaster *sm = cls;
 
-  GNUNET_break(GNUNET_OK == success);
+  GNUNET_break (GNUNET_OK == success);
   sm->value++;
-  stat_run(sm, sm->op, sm->stat, NULL);
+  stat_run (sm, sm->op, sm->stat, NULL);
 }
 
 
@@ -208,11 +210,11 @@ get_done(void *cls, int success)
  * @return service handle to return in 'op_result', NULL on error
  */
 static void *
-statistics_connect_adapter(void *cls,
-                           const struct GNUNET_CONFIGURATION_Handle *cfg)
+statistics_connect_adapter (void *cls,
+                            const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
-  return GNUNET_STATISTICS_create("<driver>",
-                                  cfg);
+  return GNUNET_STATISTICS_create ("<driver>",
+                                   cfg);
 }
 
 
@@ -224,10 +226,10 @@ statistics_connect_adapter(void *cls,
  * @param op_result service handle returned from the connect adapter
  */
 static void
-statistics_disconnect_adapter(void *cls,
-                              void *op_result)
+statistics_disconnect_adapter (void *cls,
+                               void *op_result)
 {
-  GNUNET_STATISTICS_destroy(op_result, GNUNET_NO);
+  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
 }
 
 
@@ -235,49 +237,49 @@ statistics_disconnect_adapter(void *cls,
  * Function that gathers stats from all daemons.
  */
 static void
-stat_run(void *cls,
-         struct GNUNET_TESTBED_Operation *op,
-         void *ca_result,
-         const char *emsg)
+stat_run (void *cls,
+          struct GNUNET_TESTBED_Operation *op,
+          void *ca_result,
+          const char *emsg)
 {
   struct StatMaster *sm = cls;
 
   sm->stat = ca_result;
-  GNUNET_assert(NULL != sm->stat);
+  GNUNET_assert (NULL != sm->stat);
   if (NULL != stats[sm->value].name)
-    {
-      GNUNET_STATISTICS_get(sm->stat,
+  {
+    GNUNET_STATISTICS_get (sm->stat,
 #if 0
-                            NULL, NULL,
+                           NULL, NULL,
 #else
-                            stats[sm->value].subsystem, stats[sm->value].name,
+                           stats[sm->value].subsystem, stats[sm->value].name,
 #endif
-                            &get_done, &print_stat,
-                            sm);
-      return;
-    }
-  GNUNET_TESTBED_operation_done(sm->op);
+                           &get_done, &print_stat,
+                           sm);
+    return;
+  }
+  GNUNET_TESTBED_operation_done (sm->op);
   sm->value = 0;
   sm->daemon++;
   if (NUM_DAEMONS == sm->daemon)
-    {
-      GNUNET_free(sm);
-      cleanup();
-      return;
-    }
+  {
+    GNUNET_free (sm);
+    cleanup ();
+    return;
+  }
   sm->op =
-    GNUNET_TESTBED_service_connect(NULL,
-                                   daemons[sm->daemon],
-                                   "statistics",
-                                   &stat_run, sm,
-                                   &statistics_connect_adapter,
-                                   &statistics_disconnect_adapter,
-                                   NULL);
+    GNUNET_TESTBED_service_connect (NULL,
+                                    daemons[sm->daemon],
+                                    "statistics",
+                                    &stat_run, sm,
+                                    &statistics_connect_adapter,
+                                    &statistics_disconnect_adapter,
+                                    NULL);
 }
 
 
 static void
-do_report(void *cls)
+do_report (void *cls)
 {
   static int download_counter;
   const char *type = cls;
@@ -286,62 +288,63 @@ do_report(void *cls)
   struct StatMaster *sm;
 
   if (0 ==
-      GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_add(start_time,
-                                                                  TIMEOUT)).rel_value_us)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Timeout during download for type `%s', shutting down with error\n",
-                 type);
-      ok = 1;
-      cleanup();
-      return;
-    }
-  del = GNUNET_TIME_absolute_get_duration(start_time);
+      GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
+                                                                    TIMEOUT)).
+      rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during download for type `%s', shutting down with error\n",
+                type);
+    ok = 1;
+    cleanup ();
+    return;
+  }
+  del = GNUNET_TIME_absolute_get_duration (start_time);
   if (del.rel_value_us == 0)
     del.rel_value_us = 1;
   fancy =
-    GNUNET_STRINGS_byte_size_fancy(((unsigned long long)FILESIZE) *
-                                   1000000LL / del.rel_value_us);
-  fprintf(stderr, "Download speed of type `%s' was %s/s\n", type, fancy);
-  GNUNET_free(fancy);
+    GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE)
+                                    * 1000000LL / del.rel_value_us);
+  fprintf (stderr, "Download speed of type `%s' was %s/s\n", type, fancy);
+  GNUNET_free (fancy);
   if (NUM_DAEMONS != ++download_counter)
     return;                   /* more downloads to come */
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Finished all downloads, getting statistics\n");
-  sm = GNUNET_new(struct StatMaster);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Finished all downloads, getting statistics\n");
+  sm = GNUNET_new (struct StatMaster);
   sm->op =
-    GNUNET_TESTBED_service_connect(NULL,
-                                   daemons[sm->daemon],
-                                   "statistics",
-                                   &stat_run, sm,
-                                   &statistics_connect_adapter,
-                                   &statistics_disconnect_adapter,
-                                   NULL);
+    GNUNET_TESTBED_service_connect (NULL,
+                                    daemons[sm->daemon],
+                                    "statistics",
+                                    &stat_run, sm,
+                                    &statistics_connect_adapter,
+                                    &statistics_disconnect_adapter,
+                                    NULL);
 }
 
 
 static void
-do_downloads(void *cls, const struct GNUNET_FS_Uri *u2,
-             const char *fn)
+do_downloads (void *cls, const struct GNUNET_FS_Uri *u2,
+              const char *fn)
 {
   int anonymity;
   unsigned int i;
 
   if (NULL == u2)
-    {
-      cleanup();
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    cleanup ();
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   if (NULL != fn)
-    fn2 = GNUNET_strdup(fn);
-  uri2 = GNUNET_FS_uri_dup(u2);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  start_time = GNUNET_TIME_absolute_get();
-  if (NULL != strstr(progname, "dht"))
+    fn2 = GNUNET_strdup (fn);
+  uri2 = GNUNET_FS_uri_dup (u2);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  start_time = GNUNET_TIME_absolute_get ();
+  if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
@@ -349,127 +352,127 @@ do_downloads(void *cls, const struct GNUNET_FS_Uri *u2,
    * these peers do participate in sharing, they just
    * don't have to offer anything *initially*.  */
   for (i = 0; i < NUM_DAEMONS - 2; i++)
-    GNUNET_FS_TEST_download(daemons[i], TIMEOUT, anonymity,
-                            0 == (i % 2) ? SEED1 : SEED2,
-                            0 == (i % 2) ? uri1 : uri2, VERBOSE, &do_report,
-                            "leach");
+    GNUNET_FS_TEST_download (daemons[i], TIMEOUT, anonymity,
+                             0 == (i % 2) ? SEED1 : SEED2,
+                             0 == (i % 2) ? uri1 : uri2, VERBOSE, &do_report,
+                             "leach");
   /* mutual downloads of (primary) sharing peers */
-  GNUNET_FS_TEST_download(daemons[NUM_DAEMONS - 2], TIMEOUT, anonymity, SEED1,
-                          uri1, VERBOSE, &do_report, "seeder 2");
-  GNUNET_FS_TEST_download(daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity, SEED2,
-                          uri2, VERBOSE, &do_report, "seeder 1");
+  GNUNET_FS_TEST_download (daemons[NUM_DAEMONS - 2], TIMEOUT, anonymity, SEED1,
+                           uri1, VERBOSE, &do_report, "seeder 2");
+  GNUNET_FS_TEST_download (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity, SEED2,
+                           uri2, VERBOSE, &do_report, "seeder 1");
 }
 
 
 static void
-do_publish2(void *cls,
-            const struct GNUNET_FS_Uri *u1,
-            const char *fn)
+do_publish2 (void *cls,
+             const struct GNUNET_FS_Uri *u1,
+             const char *fn)
 {
   int do_index;
   int anonymity;
 
   if (NULL == u1)
-    {
-      cleanup();
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-                 "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    cleanup ();
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   if (NULL != fn)
-    fn1 = GNUNET_strdup(fn);
-  uri1 = GNUNET_FS_uri_dup(u1);
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  if (NULL != strstr(progname, "index"))
+    fn1 = GNUNET_strdup (fn);
+  uri1 = GNUNET_FS_uri_dup (u1);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
     do_index = GNUNET_NO;
-  if (NULL != strstr(progname, "dht"))
+  if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
 
-  GNUNET_FS_TEST_publish(daemons[NUM_DAEMONS - 2], TIMEOUT, anonymity,
-                         do_index, FILESIZE, SEED2, VERBOSE, &do_downloads,
-                         NULL);
+  GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 2], TIMEOUT, anonymity,
+                          do_index, FILESIZE, SEED2, VERBOSE, &do_downloads,
+                          NULL);
 }
 
 
 static void
-do_publish1(void *cls,
-            struct GNUNET_TESTBED_Operation *op,
-            const char *emsg)
+do_publish1 (void *cls,
+             struct GNUNET_TESTBED_Operation *op,
+             const char *emsg)
 {
   unsigned int *coco = cls;
   int do_index;
   int anonymity;
 
-  GNUNET_TESTBED_operation_done(op);
+  GNUNET_TESTBED_operation_done (op);
   if (NULL != emsg)
-    {
-      cleanup();
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg);
-      ok = 1;
-      return;
-    }
+  {
+    cleanup ();
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg);
+    ok = 1;
+    return;
+  }
   if (0 != (--(*coco)))
     return; /* more connections to be created */
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  if (NULL != strstr(progname, "index"))
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
     do_index = GNUNET_NO;
-  if (NULL != strstr(progname, "dht"))
+  if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
-  GNUNET_FS_TEST_publish(daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity,
-                         do_index, FILESIZE, SEED1, VERBOSE, &do_publish2,
-                         NULL);
+  GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 1], TIMEOUT, anonymity,
+                          do_index, FILESIZE, SEED1, VERBOSE, &do_publish2,
+                          NULL);
 }
 
 
 static void
-do_connect(void *cls,
-           struct GNUNET_TESTBED_RunHandle *h,
-           unsigned int num_peers,
-           struct GNUNET_TESTBED_Peer **peers,
-           unsigned int links_succeeded,
-           unsigned int links_failed)
+do_connect (void *cls,
+            struct GNUNET_TESTBED_RunHandle *h,
+            unsigned int num_peers,
+            struct GNUNET_TESTBED_Peer **peers,
+            unsigned int links_succeeded,
+            unsigned int links_failed)
 {
   static unsigned int coco;
   unsigned int i;
   unsigned int j;
 
-  GNUNET_assert(NUM_DAEMONS == num_peers);
+  GNUNET_assert (NUM_DAEMONS == num_peers);
   for (i = 0; i < num_peers; i++)
     daemons[i] = peers[i];
   for (i = 0; i < NUM_DAEMONS; i++)
     for (j = i + 1; j < NUM_DAEMONS; j++)
-      {
-        coco++;
-        GNUNET_TESTBED_overlay_connect(NULL,
-                                       &do_publish1,
-                                       &coco,
-                                       peers[i],
-                                       peers[j]);
-      }
+    {
+      coco++;
+      GNUNET_TESTBED_overlay_connect (NULL,
+                                      &do_publish1,
+                                      &coco,
+                                      peers[i],
+                                      peers[j]);
+    }
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   progname = argv[0];
-  (void)GNUNET_TESTBED_test_run("perf-gnunet-service-fs-p2p-respect",
-                                "perf_gnunet_service_fs_p2p.conf",
-                                NUM_DAEMONS,
-                                0, NULL, NULL,
-                                &do_connect, NULL);
-  GNUNET_DISK_directory_remove("/tmp/gnunet-test-fs-lib/");
+  (void) GNUNET_TESTBED_test_run ("perf-gnunet-service-fs-p2p-respect",
+                                  "perf_gnunet_service_fs_p2p.conf",
+                                  NUM_DAEMONS,
+                                  0, NULL, NULL,
+                                  &do_connect, NULL);
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ok;
 }
 
diff --git a/src/fs/plugin_block_fs.c b/src/fs/plugin_block_fs.c
index 8003e3837..e5ea91c98 100644
--- a/src/fs/plugin_block_fs.c
+++ b/src/fs/plugin_block_fs.c
@@ -51,61 +51,62 @@
  *         by this @a type of block (this is not an error)
  */
 static struct GNUNET_BLOCK_Group *
-block_plugin_fs_create_group(void *cls,
-                             enum GNUNET_BLOCK_Type type,
-                             uint32_t nonce,
-                             const void *raw_data,
-                             size_t raw_data_size,
-                             va_list va)
+block_plugin_fs_create_group (void *cls,
+                              enum GNUNET_BLOCK_Type type,
+                              uint32_t nonce,
+                              const void *raw_data,
+                              size_t raw_data_size,
+                              va_list va)
 {
   unsigned int size;
   const char *guard;
 
   switch (type)
-    {
-    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
-      GNUNET_break(NULL == va_arg(va, const char *));
-      return NULL;
-
-    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
-      GNUNET_break(NULL == va_arg(va, const char *));
-      return NULL;
+  {
+  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
+    GNUNET_break (NULL == va_arg (va, const char *));
+    return NULL;
 
-    case GNUNET_BLOCK_TYPE_FS_UBLOCK:
-      guard = va_arg(va, const char *);
-      if (0 == strcmp(guard,
-                      "seen-set-size"))
-        {
-          size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size(va_arg(va, unsigned int),
-                                                             BLOOMFILTER_K);
-        }
-      else if (0 == strcmp(guard,
-                           "filter-size"))
-        {
-          size = va_arg(va, unsigned int);
-        }
-      else
-        {
-          /* va-args invalid! bad bug, complain! */
-          GNUNET_break(0);
-          size = 8;
-        }
-      if (0 == size)
-        size = raw_data_size; /* not for us to determine, use what we got! */
-      GNUNET_break(NULL == va_arg(va, const char *));
-      return GNUNET_BLOCK_GROUP_bf_create(cls,
-                                          size,
-                                          BLOOMFILTER_K,
-                                          type,
-                                          nonce,
-                                          raw_data,
-                                          raw_data_size);
+  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
+    GNUNET_break (NULL == va_arg (va, const char *));
+    return NULL;
 
-    default:
-      GNUNET_break(NULL == va_arg(va, const char *));
-      GNUNET_break(0);
-      return NULL;
+  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
+    guard = va_arg (va, const char *);
+    if (0 == strcmp (guard,
+                     "seen-set-size"))
+    {
+      size = GNUNET_BLOCK_GROUP_compute_bloomfilter_size (va_arg (va, unsigned
+                                                                  int),
+                                                          BLOOMFILTER_K);
+    }
+    else if (0 == strcmp (guard,
+                          "filter-size"))
+    {
+      size = va_arg (va, unsigned int);
+    }
+    else
+    {
+      /* va-args invalid! bad bug, complain! */
+      GNUNET_break (0);
+      size = 8;
     }
+    if (0 == size)
+      size = raw_data_size;   /* not for us to determine, use what we got! */
+    GNUNET_break (NULL == va_arg (va, const char *));
+    return GNUNET_BLOCK_GROUP_bf_create (cls,
+                                         size,
+                                         BLOOMFILTER_K,
+                                         type,
+                                         nonce,
+                                         raw_data,
+                                         raw_data_size);
+
+  default:
+    GNUNET_break (NULL == va_arg (va, const char *));
+    GNUNET_break (0);
+    return NULL;
+  }
 }
 
 
@@ -129,86 +130,87 @@ block_plugin_fs_create_group(void *cls,
  * @return characterization of result
  */
 static enum GNUNET_BLOCK_EvaluationResult
-block_plugin_fs_evaluate(void *cls,
-                         struct GNUNET_BLOCK_Context *ctx,
-                         enum GNUNET_BLOCK_Type type,
-                         struct GNUNET_BLOCK_Group *bg,
-                         enum GNUNET_BLOCK_EvaluationOptions eo,
-                         const struct GNUNET_HashCode *query,
-                         const void *xquery,
-                         size_t xquery_size,
-                         const void *reply_block,
-                         size_t reply_block_size)
+block_plugin_fs_evaluate (void *cls,
+                          struct GNUNET_BLOCK_Context *ctx,
+                          enum GNUNET_BLOCK_Type type,
+                          struct GNUNET_BLOCK_Group *bg,
+                          enum GNUNET_BLOCK_EvaluationOptions eo,
+                          const struct GNUNET_HashCode *query,
+                          const void *xquery,
+                          size_t xquery_size,
+                          const void *reply_block,
+                          size_t reply_block_size)
 {
   const struct UBlock *ub;
   struct GNUNET_HashCode hc;
   struct GNUNET_HashCode chash;
 
   switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
+  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
+    if (0 != xquery_size)
     {
-    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
-    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
-      if (0 != xquery_size)
-        {
-          GNUNET_break_op(0);
-          return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-        }
-      if (NULL == reply_block)
-        return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
-      return GNUNET_BLOCK_EVALUATION_OK_LAST;
-
-    case GNUNET_BLOCK_TYPE_FS_UBLOCK:
-      if (0 != xquery_size)
-        {
-          GNUNET_break_op(0);
-          return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
-        }
-      if (NULL == reply_block)
-        return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
+      GNUNET_break_op (0);
+      return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
+    }
+    if (NULL == reply_block)
+      return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
+    return GNUNET_BLOCK_EVALUATION_OK_LAST;
 
-      if (reply_block_size < sizeof(struct UBlock))
-        {
-          GNUNET_break_op(0);
-          return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-        }
-      ub = reply_block;
-      GNUNET_CRYPTO_hash(&ub->verification_key,
-                         sizeof(ub->verification_key),
-                         &hc);
-      if (0 != memcmp(&hc,
-                      query,
-                      sizeof(struct GNUNET_HashCode)))
-        {
-          GNUNET_break_op(0);
-          return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-        }
-      if (reply_block_size != ntohl(ub->purpose.size) + sizeof(struct GNUNET_CRYPTO_EcdsaSignature))
-        {
-          GNUNET_break_op(0);
-          return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-        }
-      if ((0 == (eo & GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO)) &&
-          (GNUNET_OK !=
-           GNUNET_CRYPTO_ecdsa_verify(GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK,
-                                      &ub->purpose,
-                                      &ub->signature,
-                                      &ub->verification_key)))
-        {
-          GNUNET_break_op(0);
-          return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
-        }
-      GNUNET_CRYPTO_hash(reply_block,
-                         reply_block_size,
-                         &chash);
-      if (GNUNET_YES ==
-          GNUNET_BLOCK_GROUP_bf_test_and_set(bg,
-                                             &chash))
-        return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
-      return GNUNET_BLOCK_EVALUATION_OK_MORE;
+  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
+    if (0 != xquery_size)
+    {
+      GNUNET_break_op (0);
+      return GNUNET_BLOCK_EVALUATION_REQUEST_INVALID;
+    }
+    if (NULL == reply_block)
+      return GNUNET_BLOCK_EVALUATION_REQUEST_VALID;
 
-    default:
-      return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
+    if (reply_block_size < sizeof(struct UBlock))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+    }
+    ub = reply_block;
+    GNUNET_CRYPTO_hash (&ub->verification_key,
+                        sizeof(ub->verification_key),
+                        &hc);
+    if (0 != memcmp (&hc,
+                     query,
+                     sizeof(struct GNUNET_HashCode)))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+    }
+    if (reply_block_size != ntohl (ub->purpose.size) + sizeof(struct
+                                                              GNUNET_CRYPTO_EcdsaSignature))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
+    }
+    if ((0 == (eo & GNUNET_BLOCK_EO_LOCAL_SKIP_CRYPTO)) &&
+        (GNUNET_OK !=
+         GNUNET_CRYPTO_ecdsa_verify (GNUNET_SIGNATURE_PURPOSE_FS_UBLOCK,
+                                     &ub->purpose,
+                                     &ub->signature,
+                                     &ub->verification_key)))
+    {
+      GNUNET_break_op (0);
+      return GNUNET_BLOCK_EVALUATION_RESULT_INVALID;
     }
+    GNUNET_CRYPTO_hash (reply_block,
+                        reply_block_size,
+                        &chash);
+    if (GNUNET_YES ==
+        GNUNET_BLOCK_GROUP_bf_test_and_set (bg,
+                                            &chash))
+      return GNUNET_BLOCK_EVALUATION_OK_DUPLICATE;
+    return GNUNET_BLOCK_EVALUATION_OK_MORE;
+
+  default:
+    return GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED;
+  }
 }
 
 
@@ -224,37 +226,37 @@ block_plugin_fs_evaluate(void *cls,
  *         (or if extracting a key from a block of this type does not work)
  */
 static int
-block_plugin_fs_get_key(void *cls,
-                        enum GNUNET_BLOCK_Type type,
-                        const void *block,
-                        size_t block_size,
-                        struct GNUNET_HashCode *key)
+block_plugin_fs_get_key (void *cls,
+                         enum GNUNET_BLOCK_Type type,
+                         const void *block,
+                         size_t block_size,
+                         struct GNUNET_HashCode *key)
 {
   const struct UBlock *ub;
 
   switch (type)
-    {
-    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
-    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
-      GNUNET_CRYPTO_hash(block, block_size, key);
-      return GNUNET_OK;
-
-    case GNUNET_BLOCK_TYPE_FS_UBLOCK:
-      if (block_size < sizeof(struct UBlock))
-        {
-          GNUNET_break(0);
-          return GNUNET_SYSERR;
-        }
-      ub = block;
-      GNUNET_CRYPTO_hash(&ub->verification_key,
-                         sizeof(ub->verification_key),
-                         key);
-      return GNUNET_OK;
+  {
+  case GNUNET_BLOCK_TYPE_FS_DBLOCK:
+  case GNUNET_BLOCK_TYPE_FS_IBLOCK:
+    GNUNET_CRYPTO_hash (block, block_size, key);
+    return GNUNET_OK;
 
-    default:
-      GNUNET_break(0);
+  case GNUNET_BLOCK_TYPE_FS_UBLOCK:
+    if (block_size < sizeof(struct UBlock))
+    {
+      GNUNET_break (0);
       return GNUNET_SYSERR;
     }
+    ub = block;
+    GNUNET_CRYPTO_hash (&ub->verification_key,
+                        sizeof(ub->verification_key),
+                        key);
+    return GNUNET_OK;
+
+  default:
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
 }
 
 
@@ -262,10 +264,9 @@ block_plugin_fs_get_key(void *cls,
  * Entry point for the plugin.
  */
 void *
-libgnunet_plugin_block_fs_init(void *cls)
+libgnunet_plugin_block_fs_init (void *cls)
 {
-  static enum GNUNET_BLOCK_Type types[] =
-  {
+  static enum GNUNET_BLOCK_Type types[] = {
     GNUNET_BLOCK_TYPE_FS_DBLOCK,
     GNUNET_BLOCK_TYPE_FS_IBLOCK,
     GNUNET_BLOCK_TYPE_FS_UBLOCK,
@@ -273,7 +274,7 @@ libgnunet_plugin_block_fs_init(void *cls)
   };
   struct GNUNET_BLOCK_PluginFunctions *api;
 
-  api = GNUNET_new(struct GNUNET_BLOCK_PluginFunctions);
+  api = GNUNET_new (struct GNUNET_BLOCK_PluginFunctions);
   api->evaluate = &block_plugin_fs_evaluate;
   api->get_key = &block_plugin_fs_get_key;
   api->create_group = &block_plugin_fs_create_group;
@@ -286,11 +287,11 @@ libgnunet_plugin_block_fs_init(void *cls)
  * Exit point from the plugin.
  */
 void *
-libgnunet_plugin_block_fs_done(void *cls)
+libgnunet_plugin_block_fs_done (void *cls)
 {
   struct GNUNET_BLOCK_PluginFunctions *api = cls;
 
-  GNUNET_free(api);
+  GNUNET_free (api);
   return NULL;
 }
 
diff --git a/src/fs/test_fs.c b/src/fs/test_fs.c
index e88bacf59..73de7b204 100644
--- a/src/fs/test_fs.c
+++ b/src/fs/test_fs.c
@@ -30,19 +30,20 @@
 
 #define DEBUG_VERBOSE GNUNET_NO
 
-#define CHECK(a) if (!(a)) { ok = GNUNET_NO; GNUNET_GE_BREAK(NULL, 0); goto FAILURE; }
+#define CHECK(a) if (! (a)) { ok = GNUNET_NO; GNUNET_GE_BREAK (NULL, 0); \
+                              goto FAILURE; }
 
 static char *
-makeName(unsigned int i)
+makeName (unsigned int i)
 {
   char *fn;
 
-  fn = GNUNET_malloc(strlen("/tmp/gnunet-basic_fsui_test/BASIC_FSUI_TEST") +
-                     14);
-  GNUNET_snprintf(fn,
-                  strlen("/tmp/gnunet-basic_fsui_test/BASIC_FSUI_TEST") + 14,
-                  "/tmp/gnunet-basic_fsui_test/BASIC_FSUI_TEST%u", i);
-  GNUNET_disk_directory_create_for_file(NULL, fn);
+  fn = GNUNET_malloc (strlen ("/tmp/gnunet-basic_fsui_test/BASIC_FSUI_TEST")
+                      + 14);
+  GNUNET_snprintf (fn,
+                   strlen ("/tmp/gnunet-basic_fsui_test/BASIC_FSUI_TEST") + 14,
+                   "/tmp/gnunet-basic_fsui_test/BASIC_FSUI_TEST%u", i);
+  GNUNET_disk_directory_create_for_file (NULL, fn);
   return fn;
 }
 
@@ -55,47 +56,47 @@ static struct GNUNET_ECRS_URI *search_uri;
 static struct GNUNET_FSUI_Context *ctx;
 
 static void *
-eventCallback(void *cls, const GNUNET_FSUI_Event * event)
+eventCallback (void *cls, const GNUNET_FSUI_Event *event)
 {
   static char unused;
 
   switch (event->type)
-    {
-    case GNUNET_FSUI_search_resumed:
-    case GNUNET_FSUI_download_resumed:
-    case GNUNET_FSUI_upload_resumed:
-    case GNUNET_FSUI_unindex_resumed:
-      return &unused;
-
-    case GNUNET_FSUI_search_result:
+  {
+  case GNUNET_FSUI_search_resumed:
+  case GNUNET_FSUI_download_resumed:
+  case GNUNET_FSUI_upload_resumed:
+  case GNUNET_FSUI_unindex_resumed:
+    return &unused;
+
+  case GNUNET_FSUI_search_result:
 #if DEBUG_VERBOSE
-      printf("Received search result\n");
+    printf ("Received search result\n");
 #endif
-      search_uri = GNUNET_ECRS_uri_duplicate(event->data.SearchResult.fi.uri);
-      search_meta = GNUNET_meta_data_duplicate(event->data.SearchResult.fi.meta);
-      break;
+    search_uri = GNUNET_ECRS_uri_duplicate (event->data.SearchResult.fi.uri);
+    search_meta = GNUNET_meta_data_duplicate (event->data.SearchResult.fi.meta);
+    break;
 
-    case GNUNET_FSUI_upload_completed:
+  case GNUNET_FSUI_upload_completed:
 #if DEBUG_VERBOSE
-      printf("Upload complete.\n");
+    printf ("Upload complete.\n");
 #endif
-      break;
+    break;
 
-    case GNUNET_FSUI_download_completed:
+  case GNUNET_FSUI_download_completed:
 #if DEBUG_VERBOSE
-      printf("Download complete.\n");
+    printf ("Download complete.\n");
 #endif
-      break;
+    break;
 
-    case GNUNET_FSUI_unindex_completed:
+  case GNUNET_FSUI_unindex_completed:
 #if DEBUG_VERBOSE
-      printf("Unindex complete.\n");
+    printf ("Unindex complete.\n");
 #endif
-      break;
+    break;
 
-    default:
-      break;
-    }
+  default:
+    break;
+  }
   lastEvent = event->type;
   return NULL;
 }
@@ -103,7 +104,7 @@ eventCallback(void *cls, const GNUNET_FSUI_Event * event)
 #define START_DAEMON 1
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
 #if START_DAEMON
   struct GNUNET_OS_Process *daemon;
@@ -127,128 +128,130 @@ main(int argc, char *argv[])
   struct GNUNET_FSUI_UnindexList *unindex = NULL;
   struct GNUNET_FSUI_DownloadList *download = NULL;
 
-  cfg = GNUNET_GC_create();
-  if (-1 == GNUNET_GC_parse_configuration(cfg, "check.conf"))
-    {
-      GNUNET_GC_free(cfg);
-      return -1;
-    }
+  cfg = GNUNET_GC_create ();
+  if (-1 == GNUNET_GC_parse_configuration (cfg, "check.conf"))
+  {
+    GNUNET_GC_free (cfg);
+    return -1;
+  }
 #if START_DAEMON
-  daemon = GNUNET_daemon_start(NULL, cfg, "peer.conf", GNUNET_NO);
-  GNUNET_GE_ASSERT(NULL, daemon != NULL);
-  CHECK(GNUNET_OK ==
-        GNUNET_wait_for_daemon_running(NULL, cfg, 60 * GNUNET_CRON_SECONDS));
+  daemon = GNUNET_daemon_start (NULL, cfg, "peer.conf", GNUNET_NO);
+  GNUNET_GE_ASSERT (NULL, daemon != NULL);
+  CHECK (GNUNET_OK ==
+         GNUNET_wait_for_daemon_running (NULL, cfg, 60 * GNUNET_CRON_SECONDS));
 #endif
-  GNUNET_thread_sleep(5 * GNUNET_CRON_SECONDS);         /* give apps time to start */
+  GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);         /* give apps time to start */
   ok = GNUNET_YES;
 
   /* ACTUAL TEST CODE */
-  ctx = GNUNET_FSUI_start(NULL, cfg, "basic_fsui_test", 32,     /* thread pool size */
-                          GNUNET_NO,    /* no resume */
-                          &eventCallback, NULL);
-  CHECK(ctx != NULL);
-  filename = makeName(42);
-  GNUNET_disk_file_write(NULL, filename, "foo bar test!",
-                         strlen("foo bar test!"), "600");
-  meta = GNUNET_meta_data_create();
+  ctx = GNUNET_FSUI_start (NULL, cfg, "basic_fsui_test", 32,     /* thread pool size */
+                           GNUNET_NO,   /* no resume */
+                           &eventCallback, NULL);
+  CHECK (ctx != NULL);
+  filename = makeName (42);
+  GNUNET_disk_file_write (NULL, filename, "foo bar test!",
+                          strlen ("foo bar test!"), "600");
+  meta = GNUNET_meta_data_create ();
   kuri =
-    GNUNET_ECRS_keyword_command_line_to_uri(NULL, 2,
-                                            (const char **)keywords);
+    GNUNET_ECRS_keyword_command_line_to_uri (NULL, 2,
+                                             (const char **) keywords);
   /* upload */
-  upload = GNUNET_FSUI_upload_start(ctx, filename, (GNUNET_FSUI_DirectoryScanCallback) & GNUNET_disk_directory_scan, NULL, 0,   /* anonymity */
-                                    0,  /* priority */
-                                    GNUNET_YES, GNUNET_NO, GNUNET_NO,
-                                    GNUNET_get_time() + 5 * GNUNET_CRON_HOURS,
-                                    meta, kuri, kuri);
-  CHECK(upload != NULL);
-  GNUNET_ECRS_uri_destroy(kuri);
-  GNUNET_meta_data_destroy(meta);
+  upload = GNUNET_FSUI_upload_start (ctx, filename,
+                                     (GNUNET_FSUI_DirectoryScanCallback)
+                                     & GNUNET_disk_directory_scan, NULL, 0,                                                     /* anonymity */
+                                     0, /* priority */
+                                     GNUNET_YES, GNUNET_NO, GNUNET_NO,
+                                     GNUNET_get_time () + 5 * GNUNET_CRON_HOURS,
+                                     meta, kuri, kuri);
+  CHECK (upload != NULL);
+  GNUNET_ECRS_uri_destroy (kuri);
+  GNUNET_meta_data_destroy (meta);
   prog = 0;
   while (lastEvent != GNUNET_FSUI_upload_completed)
-    {
-      prog++;
-      CHECK(prog < 10000) GNUNET_thread_sleep(50 * GNUNET_CRON_MILLISECONDS);
-      if (GNUNET_shutdown_test() == GNUNET_YES)
-        break;
-    }
+  {
+    prog++;
+    CHECK (prog < 10000) GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+    if (GNUNET_shutdown_test () == GNUNET_YES)
+      break;
+  }
 
   /* search */
-  GNUNET_snprintf(keyword, 40, "+%s +%s", keywords[0], keywords[1]);
-  uri = GNUNET_ECRS_keyword_string_to_uri(NULL, keyword);
-  search = GNUNET_FSUI_search_start(ctx, 0, uri);
-  GNUNET_ECRS_uri_destroy(uri);
-  CHECK(search != NULL);
+  GNUNET_snprintf (keyword, 40, "+%s +%s", keywords[0], keywords[1]);
+  uri = GNUNET_ECRS_keyword_string_to_uri (NULL, keyword);
+  search = GNUNET_FSUI_search_start (ctx, 0, uri);
+  GNUNET_ECRS_uri_destroy (uri);
+  CHECK (search != NULL);
   prog = 0;
   while (lastEvent != GNUNET_FSUI_search_result)
-    {
-      prog++;
-      CHECK(prog < 10000);
-      GNUNET_thread_sleep(50 * GNUNET_CRON_MILLISECONDS);
-      if (GNUNET_shutdown_test() == GNUNET_YES)
-        break;
-    }
-  GNUNET_FSUI_search_abort(search);
-  GNUNET_FSUI_search_stop(search);
+  {
+    prog++;
+    CHECK (prog < 10000);
+    GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+    if (GNUNET_shutdown_test () == GNUNET_YES)
+      break;
+  }
+  GNUNET_FSUI_search_abort (search);
+  GNUNET_FSUI_search_stop (search);
 
   /* download */
-  fn = makeName(43);
+  fn = makeName (43);
   download =
-    GNUNET_FSUI_download_start(ctx, 0, GNUNET_NO, search_uri, search_meta,
-                               fn, NULL, NULL);
-  GNUNET_free(fn);
+    GNUNET_FSUI_download_start (ctx, 0, GNUNET_NO, search_uri, search_meta,
+                                fn, NULL, NULL);
+  GNUNET_free (fn);
   prog = 0;
   while (lastEvent != GNUNET_FSUI_download_completed)
-    {
-      prog++;
-      CHECK(prog < 10000);
-      GNUNET_thread_sleep(50 * GNUNET_CRON_MILLISECONDS);
-      if (GNUNET_shutdown_test() == GNUNET_YES)
-        break;
-    }
-  GNUNET_FSUI_download_stop(download);
+  {
+    prog++;
+    CHECK (prog < 10000);
+    GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+    if (GNUNET_shutdown_test () == GNUNET_YES)
+      break;
+  }
+  GNUNET_FSUI_download_stop (download);
   download = NULL;
-  GNUNET_ECRS_uri_destroy(search_uri);
-  GNUNET_meta_data_destroy(search_meta);
+  GNUNET_ECRS_uri_destroy (search_uri);
+  GNUNET_meta_data_destroy (search_meta);
   /* unindex */
-  unindex = GNUNET_FSUI_unindex_start(ctx, filename);
+  unindex = GNUNET_FSUI_unindex_start (ctx, filename);
   prog = 0;
   while (lastEvent != GNUNET_FSUI_unindex_completed)
-    {
-      prog++;
-      CHECK(prog < 10000);
-      GNUNET_thread_sleep(50 * GNUNET_CRON_MILLISECONDS);
-      if (GNUNET_shutdown_test() == GNUNET_YES)
-        break;
-    }
+  {
+    prog++;
+    CHECK (prog < 10000);
+    GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+    if (GNUNET_shutdown_test () == GNUNET_YES)
+      break;
+  }
   if (lastEvent != GNUNET_FSUI_unindex_completed)
-    GNUNET_FSUI_unindex_abort(unindex);
-  GNUNET_FSUI_unindex_stop(unindex);
+    GNUNET_FSUI_unindex_abort (unindex);
+  GNUNET_FSUI_unindex_stop (unindex);
 
 
   /* END OF TEST CODE */
 FAILURE:
   if (ctx != NULL)
-    GNUNET_FSUI_stop(ctx);
+    GNUNET_FSUI_stop (ctx);
   if (filename != NULL)
-    {
-      unlink(filename);
-      GNUNET_free(filename);
-    }
+  {
+    unlink (filename);
+    GNUNET_free (filename);
+  }
   if (download != NULL)
-    {
-      GNUNET_FSUI_download_abort(download);
-      GNUNET_FSUI_download_stop(download);
-    }
-  filename = makeName(43);
+  {
+    GNUNET_FSUI_download_abort (download);
+    GNUNET_FSUI_download_stop (download);
+  }
+  filename = makeName (43);
   /* TODO: verify file 'filename(42)' == file 'filename(43)' */
-  unlink(filename);
-  GNUNET_free(filename);
+  unlink (filename);
+  GNUNET_free (filename);
 
 #if START_DAEMON
-  GNUNET_GE_ASSERT(NULL, GNUNET_OK == GNUNET_daemon_stop(NULL, daemon));
-  GNUNET_OS_process_destroy(daemon);
+  GNUNET_GE_ASSERT (NULL, GNUNET_OK == GNUNET_daemon_stop (NULL, daemon));
+  GNUNET_OS_process_destroy (daemon);
 #endif
-  GNUNET_GC_free(cfg);
+  GNUNET_GC_free (cfg);
 
   return (ok == GNUNET_YES) ? 0 : 1;
 }
diff --git a/src/fs/test_fs_directory.c b/src/fs/test_fs_directory.c
index 936c3bed4..37d74613a 100644
--- a/src/fs/test_fs_directory.c
+++ b/src/fs/test_fs_directory.c
@@ -30,9 +30,11 @@
 #include "gnunet_fs_service.h"
 #include "fs_api.h"
 
-#define ABORT() { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); return 1; }
+#define ABORT() { fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__); \
+                  return 1; }
 
-struct PCLS {
+struct PCLS
+{
   struct GNUNET_FS_Uri **uri;
   struct GNUNET_CONTAINER_MetaData **md;
   unsigned int pos;
@@ -40,9 +42,9 @@ struct PCLS {
 };
 
 static void
-processor(void *cls, const char *filename, const struct GNUNET_FS_Uri *uri,
-          const struct GNUNET_CONTAINER_MetaData *md, size_t length,
-          const void *data)
+processor (void *cls, const char *filename, const struct GNUNET_FS_Uri *uri,
+           const struct GNUNET_CONTAINER_MetaData *md, size_t length,
+           const void *data)
 {
   struct PCLS *p = cls;
   int i;
@@ -50,19 +52,19 @@ processor(void *cls, const char *filename, const struct GNUNET_FS_Uri *uri,
   if (NULL == uri)
     return;                     /* ignore directory's meta data */
   for (i = 0; i < p->max; i++)
+  {
+    if (GNUNET_CONTAINER_meta_data_test_equal (p->md[i], md) &&
+        GNUNET_FS_uri_test_equal (p->uri[i], uri))
     {
-      if (GNUNET_CONTAINER_meta_data_test_equal(p->md[i], md) &&
-          GNUNET_FS_uri_test_equal(p->uri[i], uri))
-        {
-          p->pos++;
-          return;
-        }
+      p->pos++;
+      return;
     }
-  fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__);
+  }
+  fprintf (stderr, "Error at %s:%d\n", __FILE__, __LINE__);
 }
 
 static int
-testDirectory(unsigned int i)
+testDirectory (unsigned int i)
 {
   struct GNUNET_FS_DirectoryBuilder *db;
   char *data;
@@ -81,99 +83,99 @@ testDirectory(unsigned int i)
   const char *s;
 
   cls.max = i;
-  uris = GNUNET_malloc(sizeof(struct GNUNET_FS_Uri *) * i);
-  mds = GNUNET_malloc(sizeof(struct GNUNET_CONTAINER_MetaData *) * i);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  GNUNET_CONTAINER_meta_data_insert(meta, "<test>", EXTRACTOR_METATYPE_TITLE,
-                                    EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                    "A title", strlen("A title") + 1);
-  GNUNET_CONTAINER_meta_data_insert(meta, "<test>",
-                                    EXTRACTOR_METATYPE_AUTHOR_NAME,
-                                    EXTRACTOR_METAFORMAT_UTF8, "text/plain",
-                                    "An author", strlen("An author") + 1);
+  uris = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri *) * i);
+  mds = GNUNET_malloc (sizeof(struct GNUNET_CONTAINER_MetaData *) * i);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_insert (meta, "<test>", EXTRACTOR_METATYPE_TITLE,
+                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                     "A title", strlen ("A title") + 1);
+  GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
+                                     EXTRACTOR_METATYPE_AUTHOR_NAME,
+                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
+                                     "An author", strlen ("An author") + 1);
   for (p = 0; p < i; p++)
+  {
+    mds[p] = GNUNET_CONTAINER_meta_data_create ();
+    for (q = 0; q <= p; q++)
     {
-      mds[p] = GNUNET_CONTAINER_meta_data_create();
-      for (q = 0; q <= p; q++)
-        {
-          GNUNET_snprintf(txt, sizeof(txt), "%u -- %u\n", p, q);
-          GNUNET_CONTAINER_meta_data_insert(mds[p], "<test>",
+      GNUNET_snprintf (txt, sizeof(txt), "%u -- %u\n", p, q);
+      GNUNET_CONTAINER_meta_data_insert (mds[p], "<test>",
 #if HAVE_EXTRACTOR_H && HAVE_LIBEXTRACTOR
-                                            q % EXTRACTOR_metatype_get_max(),
+                                         q % EXTRACTOR_metatype_get_max (),
 #else
-                                            q % 128,
+                                         q % 128,
 #endif
-                                            EXTRACTOR_METAFORMAT_UTF8,
-                                            "text/plain", txt, strlen(txt) + 1);
-        }
-      GNUNET_snprintf(uri, sizeof(uri),
-                      "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.%u",
-                      p);
-      emsg = NULL;
-      uris[p] = GNUNET_FS_uri_parse(uri, &emsg);
-      if (uris[p] == NULL)
-        {
-          GNUNET_CONTAINER_meta_data_destroy(mds[p]);
-          while (--p > 0)
-            {
-              GNUNET_CONTAINER_meta_data_destroy(mds[p]);
-              GNUNET_FS_uri_destroy(uris[p]);
-            }
-          GNUNET_free(mds);
-          GNUNET_free(uris);
-          GNUNET_free(emsg);
-          GNUNET_CONTAINER_meta_data_destroy(meta);
-          ABORT();              /* error in testcase */
-        }
-      GNUNET_assert(emsg == NULL);
+                                         EXTRACTOR_METAFORMAT_UTF8,
+                                         "text/plain", txt, strlen (txt) + 1);
     }
-  start = GNUNET_TIME_absolute_get();
-  db = GNUNET_FS_directory_builder_create(meta);
-  for (p = 0; p < i; p++)
-    GNUNET_FS_directory_builder_add(db, uris[p], mds[p], NULL);
-  GNUNET_FS_directory_builder_finish(db, &dlen, (void **)&data);
-  s = GNUNET_STRINGS_relative_time_to_string(GNUNET_TIME_absolute_get_duration
-                                               (start),
-                                             GNUNET_YES);
-  fprintf(stdout,
-          "Creating directory with %u entires and total size %llu took %s\n",
-          i, (unsigned long long)dlen, s);
-  if (i < 100)
+    GNUNET_snprintf (uri, sizeof(uri),
+                     "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.%u",
+                     p);
+    emsg = NULL;
+    uris[p] = GNUNET_FS_uri_parse (uri, &emsg);
+    if (uris[p] == NULL)
     {
-      cls.pos = 0;
-      cls.uri = uris;
-      cls.md = mds;
-      GNUNET_FS_directory_list_contents(dlen, data, 0, &processor, &cls);
-      GNUNET_assert(cls.pos == i);
+      GNUNET_CONTAINER_meta_data_destroy (mds[p]);
+      while (--p > 0)
+      {
+        GNUNET_CONTAINER_meta_data_destroy (mds[p]);
+        GNUNET_FS_uri_destroy (uris[p]);
+      }
+      GNUNET_free (mds);
+      GNUNET_free (uris);
+      GNUNET_free (emsg);
+      GNUNET_CONTAINER_meta_data_destroy (meta);
+      ABORT ();                 /* error in testcase */
     }
-  GNUNET_free(data);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
+    GNUNET_assert (emsg == NULL);
+  }
+  start = GNUNET_TIME_absolute_get ();
+  db = GNUNET_FS_directory_builder_create (meta);
   for (p = 0; p < i; p++)
-    {
-      GNUNET_CONTAINER_meta_data_destroy(mds[p]);
-      GNUNET_FS_uri_destroy(uris[p]);
-    }
-  GNUNET_free(uris);
-  GNUNET_free(mds);
+    GNUNET_FS_directory_builder_add (db, uris[p], mds[p], NULL);
+  GNUNET_FS_directory_builder_finish (db, &dlen, (void **) &data);
+  s = GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration
+                                                (start),
+                                              GNUNET_YES);
+  fprintf (stdout,
+           "Creating directory with %u entires and total size %llu took %s\n",
+           i, (unsigned long long) dlen, s);
+  if (i < 100)
+  {
+    cls.pos = 0;
+    cls.uri = uris;
+    cls.md = mds;
+    GNUNET_FS_directory_list_contents (dlen, data, 0, &processor, &cls);
+    GNUNET_assert (cls.pos == i);
+  }
+  GNUNET_free (data);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  for (p = 0; p < i; p++)
+  {
+    GNUNET_CONTAINER_meta_data_destroy (mds[p]);
+    GNUNET_FS_uri_destroy (uris[p]);
+  }
+  GNUNET_free (uris);
+  GNUNET_free (mds);
   return ret;
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup("test_fs_directory",
+  GNUNET_log_setup ("test_fs_directory",
 #if VERBOSE
-                   "DEBUG",
+                    "DEBUG",
 #else
-                   "WARNING",
+                    "WARNING",
 #endif
-                   NULL);
+                    NULL);
   for (i = 17; i < 1000; i *= 2)
-    failureCount += testDirectory(i);
+    failureCount += testDirectory (i);
   if (failureCount != 0)
     return 1;
   return 0;
diff --git a/src/fs/test_fs_download.c b/src/fs/test_fs_download.c
index f7c35a680..422c41523 100644
--- a/src/fs/test_fs_download.c
+++ b/src/fs/test_fs_download.c
@@ -38,12 +38,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 static unsigned int anonymity_level;
 
@@ -57,7 +57,7 @@ static struct GNUNET_FS_DownloadContext *download;
 
 static struct GNUNET_FS_PublishContext *publish;
 
-static struct GNUNET_SCHEDULER_Task * timeout_kill;
+static struct GNUNET_SCHEDULER_Task *timeout_kill;
 
 static char *fn;
 
@@ -67,198 +67,199 @@ static int err;
 
 
 static void
-timeout_kill_task(void *cls)
+timeout_kill_task (void *cls)
 {
   if (NULL != download)
-    {
-      GNUNET_FS_download_stop(download, GNUNET_YES);
-      download = NULL;
-    }
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
   else if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
   timeout_kill = NULL;
   err = 1;
 }
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
 }
 
 
 static void
-stop_fs_task(void *cls)
+stop_fs_task (void *cls)
 {
-  GNUNET_FS_stop(fs);
+  GNUNET_FS_stop (fs);
   fs = NULL;
 }
 
 
 static void
-abort_download_task(void *cls)
+abort_download_task (void *cls)
 {
   uint64_t size;
 
   if (NULL != download)
-    {
-      GNUNET_FS_download_stop(download, GNUNET_YES);
-      download = NULL;
-    }
-  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_size(fn, &size, GNUNET_YES, GNUNET_NO));
-  GNUNET_assert(size == FILESIZE);
-  GNUNET_DISK_directory_remove(fn);
-  GNUNET_free(fn);
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES,
+                                                     GNUNET_NO));
+  GNUNET_assert (size == FILESIZE);
+  GNUNET_DISK_directory_remove (fn);
+  GNUNET_free (fn);
   fn = NULL;
-  GNUNET_SCHEDULER_cancel(timeout_kill);
+  GNUNET_SCHEDULER_cancel (timeout_kill);
   timeout_kill = NULL;
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      fprintf(stdout,
-              "Publishing complete, %llu kb/s.\n",
-              (unsigned long long)(FILESIZE * 1000000LL /
-                                   (1 +
-                                    GNUNET_TIME_absolute_get_duration
-                                      (start).rel_value_us) / 1024LL));
-      GAUGER("FS",
-             (GNUNET_YES == indexed)
-             ? "Publishing speed (indexing)"
-             : "Publishing speed (insertion)",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024LL), "kb/s");
-      fn = GNUNET_DISK_mktemp("gnunet-download-test-dst");
-      start = GNUNET_TIME_absolute_get();
-      download =
-        GNUNET_FS_download_start(fs,
-                                 event->value.publish.specifics.
-                                 completed.chk_uri, NULL, fn, NULL, 0,
-                                 FILESIZE, anonymity_level,
-                                 GNUNET_FS_DOWNLOAD_OPTION_NONE,
-                                 "download", NULL);
-      GNUNET_assert(download != NULL);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      fprintf(stdout,
-              "Download complete,  %llu kb/s.\n",
-              (unsigned long long)(FILESIZE * 1000000LL /
-                                   (1 +
-                                    GNUNET_TIME_absolute_get_duration
-                                      (start).rel_value_us) / 1024LL));
-      GAUGER("FS",
-             (GNUNET_YES == indexed)
-             ? "Local download speed (indexed)"
-             : "Local download speed (inserted)",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024LL), "kb/s");
-      GNUNET_SCHEDULER_add_now(&abort_download_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
-      GNUNET_assert(download == event->value.download.dc);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Download is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.download.completed,
-                 (unsigned long long)event->value.download.size,
-                 event->value.download.specifics.progress.depth,
-                 (unsigned long long)event->value.download.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
-      fprintf(stderr, "Error downloading file: %s\n",
-              event->value.download.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_download_task, NULL);
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-    case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_SCHEDULER_add_now(&stop_fs_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_START:
-      GNUNET_assert(0 == strcmp("download", event->value.download.cctx));
-      GNUNET_assert(NULL == event->value.download.pctx);
-      GNUNET_assert(NULL != event->value.download.uri);
-      GNUNET_assert(0 == strcmp(fn, event->value.download.filename));
-      GNUNET_assert(FILESIZE == event->value.download.size);
-      GNUNET_assert(0 == event->value.download.completed);
-      GNUNET_assert(1 == event->value.download.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
-      GNUNET_assert(download == event->value.download.dc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    default:
-      printf("Unexpected event: %d\n", event->status);
-      break;
-    }
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    fprintf (stdout,
+             "Publishing complete, %llu kb/s.\n",
+             (unsigned long long) (FILESIZE * 1000000LL
+                                   / (1
+                                      + GNUNET_TIME_absolute_get_duration
+                                        (start).rel_value_us) / 1024LL));
+    GAUGER ("FS",
+            (GNUNET_YES == indexed)
+            ? "Publishing speed (indexing)"
+            : "Publishing speed (insertion)",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024LL), "kb/s");
+    fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
+    start = GNUNET_TIME_absolute_get ();
+    download =
+      GNUNET_FS_download_start (fs,
+                                event->value.publish.specifics.
+                                completed.chk_uri, NULL, fn, NULL, 0,
+                                FILESIZE, anonymity_level,
+                                GNUNET_FS_DOWNLOAD_OPTION_NONE,
+                                "download", NULL);
+    GNUNET_assert (download != NULL);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    fprintf (stdout,
+             "Download complete,  %llu kb/s.\n",
+             (unsigned long long) (FILESIZE * 1000000LL
+                                   / (1
+                                      + GNUNET_TIME_absolute_get_duration
+                                        (start).rel_value_us) / 1024LL));
+    GAUGER ("FS",
+            (GNUNET_YES == indexed)
+            ? "Local download speed (indexed)"
+            : "Local download speed (inserted)",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024LL), "kb/s");
+    GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    GNUNET_assert (download == event->value.download.dc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Download is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.download.completed,
+                (unsigned long long) event->value.download.size,
+                event->value.download.specifics.progress.depth,
+                (unsigned long long) event->value.download.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+    fprintf (stderr, "Error downloading file: %s\n",
+             event->value.download.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_SCHEDULER_add_now (&stop_fs_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_START:
+    GNUNET_assert (0 == strcmp ("download", event->value.download.cctx));
+    GNUNET_assert (NULL == event->value.download.pctx);
+    GNUNET_assert (NULL != event->value.download.uri);
+    GNUNET_assert (0 == strcmp (fn, event->value.download.filename));
+    GNUNET_assert (FILESIZE == event->value.download.size);
+    GNUNET_assert (0 == event->value.download.completed);
+    GNUNET_assert (1 == event->value.download.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+    GNUNET_assert (download == event->value.download.dc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *binary_name = cls;
   const char *keywords[] = {
@@ -273,89 +274,90 @@ run(void *cls,
   struct GNUNET_FS_BlockOptions bo;
 
   if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_get_value_yesno(cfg,
-                                           "download-test",
-                                           "USE_STREAM"))
+      GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                            "download-test",
+                                            "USE_STREAM"))
     anonymity_level = 0;
   else
     anonymity_level = 1;
-  fs = GNUNET_FS_start(cfg, binary_name, &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, binary_name, &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = anonymity_level;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
 
   if (GNUNET_YES ==
-      GNUNET_CONFIGURATION_get_value_yesno(cfg,
-                                           "download-test",
-                                           "USE_INDEX"))
-    {
-      fn1 = GNUNET_DISK_mktemp("gnunet-download-indexed-test");
-      GNUNET_assert(FILESIZE ==
-                    GNUNET_DISK_fn_write(fn1, buf, FILESIZE,
-                                         GNUNET_DISK_PERM_USER_READ |
-                                         GNUNET_DISK_PERM_USER_WRITE));
-      GNUNET_free(buf);
-      fi = GNUNET_FS_file_information_create_from_file(fs, "publish-context", fn1,
-                                                       kuri, meta, GNUNET_YES,
-                                                       &bo);
-      indexed = GNUNET_YES;
-    }
+      GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                            "download-test",
+                                            "USE_INDEX"))
+  {
+    fn1 = GNUNET_DISK_mktemp ("gnunet-download-indexed-test");
+    GNUNET_assert (FILESIZE ==
+                   GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
+                                         GNUNET_DISK_PERM_USER_READ
+                                         | GNUNET_DISK_PERM_USER_WRITE));
+    GNUNET_free (buf);
+    fi = GNUNET_FS_file_information_create_from_file (fs, "publish-context",
+                                                      fn1,
+                                                      kuri, meta, GNUNET_YES,
+                                                      &bo);
+    indexed = GNUNET_YES;
+  }
   else
-    {
-      fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
-                                                       FILESIZE, buf, kuri, meta,
-                                                       GNUNET_NO, &bo);
-      /* note: buf will be free'd as part of 'fi' now */
-      indexed = GNUNET_NO;
-    }
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fi);
+  {
+    fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
+                                                      FILESIZE, buf, kuri, meta,
+                                                      GNUNET_NO, &bo);
+    /* note: buf will be free'd as part of 'fi' now */
+    indexed = GNUNET_NO;
+  }
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fi);
   timeout_kill =
-    GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_kill_task, NULL);
-  start = GNUNET_TIME_absolute_get();
+    GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_kill_task, NULL);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
+    GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   const char *binary_name;
   const char *config_name;
 
   binary_name = "test-fs-download";
   config_name = "test_fs_download_data.conf";
-  if (NULL != strstr(argv[0], "indexed"))
-    {
-      binary_name = "test-fs-download-indexed";
-      config_name = "test_fs_download_indexed.conf";
-    }
-  if (NULL != strstr(argv[0], "cadet"))
-    {
-      binary_name = "test-fs-download-cadet";
-      config_name = "test_fs_download_cadet.conf";
-    }
-  if (0 != GNUNET_TESTING_peer_run(binary_name,
-                                   config_name,
-                                   &run, (void *)binary_name))
+  if (NULL != strstr (argv[0], "indexed"))
+  {
+    binary_name = "test-fs-download-indexed";
+    config_name = "test_fs_download_indexed.conf";
+  }
+  if (NULL != strstr (argv[0], "cadet"))
+  {
+    binary_name = "test-fs-download-cadet";
+    config_name = "test_fs_download_cadet.conf";
+  }
+  if (0 != GNUNET_TESTING_peer_run (binary_name,
+                                    config_name,
+                                    &run, (void *) binary_name))
     return 1;
   if (NULL != fn1)
-    {
-      unlink(fn1);
-      GNUNET_free(fn1);
-    }
+  {
+    unlink (fn1);
+    GNUNET_free (fn1);
+  }
   return err;
 }
 
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index 78dbe821e..7b7a886eb 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -36,12 +36,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -54,7 +54,7 @@ static struct GNUNET_FS_DownloadContext *download;
 
 static struct GNUNET_FS_PublishContext *publish;
 
-static struct GNUNET_SCHEDULER_Task * timeout_kill;
+static struct GNUNET_SCHEDULER_Task *timeout_kill;
 
 static char *fn;
 
@@ -62,66 +62,67 @@ static int err;
 
 
 static void
-timeout_kill_task(void *cls)
+timeout_kill_task (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Timeout downloading file\n");
   if (download != NULL)
-    {
-      GNUNET_FS_download_stop(download, GNUNET_YES);
-      download = NULL;
-    }
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
   else if (publish != NULL)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   timeout_kill = NULL;
   err = 1;
 }
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
   if (publish != NULL)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
 }
 
 
 static void
-abort_download_task(void *cls)
+abort_download_task (void *cls)
 {
   uint64_t size;
 
   if (download != NULL)
-    {
-      GNUNET_FS_download_stop(download, GNUNET_YES);
-      download = NULL;
-    }
-  GNUNET_assert(GNUNET_OK == GNUNET_DISK_file_size(fn, &size, GNUNET_YES, GNUNET_NO));
-  GNUNET_assert(size == FILESIZE);
-  GNUNET_DISK_directory_remove(fn);
-  GNUNET_free(fn);
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES,
+                                                     GNUNET_NO));
+  GNUNET_assert (size == FILESIZE);
+  GNUNET_DISK_directory_remove (fn);
+  GNUNET_free (fn);
   fn = NULL;
-  GNUNET_SCHEDULER_cancel(timeout_kill);
+  GNUNET_SCHEDULER_cancel (timeout_kill);
   timeout_kill = NULL;
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event);
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task(void *cls)
+restart_fs_task (void *cls)
 {
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n");
-  GNUNET_FS_stop(fs);
-  fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Restarting FS.\n");
+  GNUNET_FS_stop (fs);
+  fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -133,7 +134,7 @@ restart_fs_task(void *cls)
  * @param ev type of the event to consider
  */
 static void
-consider_restart(int ev)
+consider_restart (int ev)
 {
   static int prev[32];
   static int off;
@@ -143,158 +144,158 @@ consider_restart(int ev)
     if (prev[i] == ev)
       return;
   prev[off++] = ev;
-  GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                     &restart_fs_task, NULL);
+  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
+                                      &restart_fs_task, NULL);
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf("Publishing complete, %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024LL));
-      fn = GNUNET_DISK_mktemp("gnunet-download-test-dst");
-      start = GNUNET_TIME_absolute_get();
-      GNUNET_assert(download == NULL);
-      GNUNET_FS_download_start(fs,
-                               event->value.publish.specifics.completed.chk_uri,
-                               NULL, fn, NULL, 0, FILESIZE, 1,
-                               GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      printf("Download complete,  %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024LL));
-      GNUNET_SCHEDULER_add_now(&abort_download_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
-      consider_restart(event->status);
-      GNUNET_assert(download == event->value.download.dc);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Download is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.download.completed,
-                 (unsigned long long)event->value.download.size,
-                 event->value.download.specifics.progress.depth,
-                 (unsigned long long)event->value.download.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
-      fprintf(stderr, "Error downloading file: %s\n",
-              event->value.download.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_download_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
-      GNUNET_assert(event->value.publish.pc == publish);
-      publish = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_RESUME:
-      GNUNET_assert(NULL == publish);
-      publish = event->value.publish.pc;
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n");
-      GNUNET_assert(event->value.download.dc == download);
-      download = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
-      GNUNET_assert(NULL == download);
-      download = event->value.download.dc;
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n");
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-      consider_restart(event->status);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download active.\n");
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
-      consider_restart(event->status);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n");
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_START:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Download started.\n");
-      consider_restart(event->status);
-      GNUNET_assert(download == NULL);
-      download = event->value.download.dc;
-      GNUNET_assert(0 == strcmp("download", event->value.download.cctx));
-      GNUNET_assert(NULL == event->value.download.pctx);
-      GNUNET_assert(NULL != event->value.download.uri);
-      GNUNET_assert(0 == strcmp(fn, event->value.download.filename));
-      GNUNET_assert(FILESIZE == event->value.download.size);
-      GNUNET_assert(0 == event->value.download.completed);
-      GNUNET_assert(1 == event->value.download.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
-      GNUNET_assert(download == event->value.download.dc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      download = NULL;
-      break;
-
-    default:
-      printf("Unexpected event: %d\n", event->status);
-      break;
-    }
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    printf ("Publishing complete, %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024LL));
+    fn = GNUNET_DISK_mktemp ("gnunet-download-test-dst");
+    start = GNUNET_TIME_absolute_get ();
+    GNUNET_assert (download == NULL);
+    GNUNET_FS_download_start (fs,
+                              event->value.publish.specifics.completed.chk_uri,
+                              NULL, fn, NULL, 0, FILESIZE, 1,
+                              GNUNET_FS_DOWNLOAD_OPTION_NONE, "download", NULL);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    printf ("Download complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024LL));
+    GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    consider_restart (event->status);
+    GNUNET_assert (download == event->value.download.dc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Download is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.download.completed,
+                (unsigned long long) event->value.download.size,
+                event->value.download.specifics.progress.depth,
+                (unsigned long long) event->value.download.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+    fprintf (stderr, "Error downloading file: %s\n",
+             event->value.download.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_download_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
+    GNUNET_assert (event->value.publish.pc == publish);
+    publish = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_RESUME:
+    GNUNET_assert (NULL == publish);
+    publish = event->value.publish.pc;
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_SUSPEND:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download suspended.\n");
+    GNUNET_assert (event->value.download.dc == download);
+    download = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_RESUME:
+    GNUNET_assert (NULL == download);
+    download = event->value.download.dc;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download resumed.\n");
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+    consider_restart (event->status);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download active.\n");
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+    consider_restart (event->status);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download inactive.\n");
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_START:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download started.\n");
+    consider_restart (event->status);
+    GNUNET_assert (download == NULL);
+    download = event->value.download.dc;
+    GNUNET_assert (0 == strcmp ("download", event->value.download.cctx));
+    GNUNET_assert (NULL == event->value.download.pctx);
+    GNUNET_assert (NULL != event->value.download.uri);
+    GNUNET_assert (0 == strcmp (fn, event->value.download.filename));
+    GNUNET_assert (FILESIZE == event->value.download.size);
+    GNUNET_assert (0 == event->value.download.completed);
+    GNUNET_assert (1 == event->value.download.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+    GNUNET_assert (download == event->value.download.dc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    download = NULL;
+    break;
+
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -308,40 +309,40 @@ run(void *cls,
   struct GNUNET_FS_BlockOptions bo;
 
   cfg = c;
-  fs = GNUNET_FS_start(cfg, "test-fs-download-persistence", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-download-persistence", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
-  fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
-                                                   FILESIZE, buf, kuri, meta,
-                                                   GNUNET_NO, &bo);
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fi);
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+  fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
+                                                    FILESIZE, buf, kuri, meta,
+                                                    GNUNET_NO, &bo);
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fi);
   timeout_kill =
-    GNUNET_SCHEDULER_add_delayed(TIMEOUT, &timeout_kill_task, NULL);
-  start = GNUNET_TIME_absolute_get();
+    GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_kill_task, NULL);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
+    GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-download-persistence",
-                                   "test_fs_download_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-download-persistence",
+                                    "test_fs_download_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_file_information.c b/src/fs/test_fs_file_information.c
index 1f008997f..3f6f2d5a8 100644
--- a/src/fs/test_fs_file_information.c
+++ b/src/fs/test_fs_file_information.c
@@ -44,21 +44,21 @@
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static int
-mycleaner(void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length,
-          struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri,
-          struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
+mycleaner (void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length,
+           struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri,
+           struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
 {
   return GNUNET_OK;
 }
 
 
 static void
-run(void *cls, char *const *args, const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *cfg)
+run (void *cls, char *const *args, const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -76,67 +76,67 @@ run(void *cls, char *const *args, const char *cfgfile,
   size_t i;
   struct GNUNET_FS_BlockOptions bo;
 
-  fs = GNUNET_FS_start(cfg, "test-fs-file-information", NULL, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  fn1 = GNUNET_DISK_mktemp("gnunet-file_information-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-file-information", NULL, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  fn1 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn1, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  fn2 = GNUNET_DISK_mktemp("gnunet-file_information-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  fn2 = GNUNET_DISK_mktemp ("gnunet-file_information-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn2, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
   fi1 =
-    GNUNET_FS_file_information_create_from_file(fs,
-                                                "file_information-context1",
-                                                fn1, kuri, meta, GNUNET_YES,
-                                                &bo);
-  GNUNET_assert(fi1 != NULL);
+    GNUNET_FS_file_information_create_from_file (fs,
+                                                 "file_information-context1",
+                                                 fn1, kuri, meta, GNUNET_YES,
+                                                 &bo);
+  GNUNET_assert (fi1 != NULL);
   fi2 =
-    GNUNET_FS_file_information_create_from_file(fs,
-                                                "file_information-context2",
-                                                fn2, kuri, meta, GNUNET_YES,
-                                                &bo);
-  GNUNET_assert(fi2 != NULL);
+    GNUNET_FS_file_information_create_from_file (fs,
+                                                 "file_information-context2",
+                                                 fn2, kuri, meta, GNUNET_YES,
+                                                 &bo);
+  GNUNET_assert (fi2 != NULL);
   fidir =
-    GNUNET_FS_file_information_create_empty_directory(fs,
-                                                      "file_information-context-dir",
-                                                      kuri, meta, &bo, NULL);
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi1));
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi2));
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fidir);
+    GNUNET_FS_file_information_create_empty_directory (fs,
+                                                       "file_information-context-dir",
+                                                       kuri, meta, &bo, NULL);
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fidir);
   /* FIXME: test more of API! */
-  GNUNET_FS_file_information_destroy(fidir, &mycleaner, NULL);
-  GNUNET_DISK_directory_remove(fn1);
-  GNUNET_DISK_directory_remove(fn2);
-  GNUNET_free_non_null(fn1);
-  GNUNET_free_non_null(fn2);
-  GNUNET_FS_stop(fs);
+  GNUNET_FS_file_information_destroy (fidir, &mycleaner, NULL);
+  GNUNET_DISK_directory_remove (fn1);
+  GNUNET_DISK_directory_remove (fn2);
+  GNUNET_free_non_null (fn1);
+  GNUNET_free_non_null (fn2);
+  GNUNET_FS_stop (fs);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   char *const argvx[] = {
     "test-fs-file_information",
@@ -148,12 +148,12 @@ main(int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup("test_fs_file_information",
-                   "WARNING",
-                   NULL);
-  GNUNET_PROGRAM_run((sizeof(argvx) / sizeof(char *)) - 1, argvx,
-                     "test-fs-file_information", "nohelp", options, &run,
-                     NULL);
+  GNUNET_log_setup ("test_fs_file_information",
+                    "WARNING",
+                    NULL);
+  GNUNET_PROGRAM_run ((sizeof(argvx) / sizeof(char *)) - 1, argvx,
+                      "test-fs-file_information", "nohelp", options, &run,
+                      NULL);
   return 0;
 }
 
diff --git a/src/fs/test_fs_getopt.c b/src/fs/test_fs_getopt.c
index 48777b0e0..3d0da752b 100644
--- a/src/fs/test_fs_getopt.c
+++ b/src/fs/test_fs_getopt.c
@@ -27,11 +27,11 @@
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  GNUNET_log_setup("test_fs_getopt",
-                   "WARNING",
-                   NULL);
-  fprintf(stderr, "%s", "WARNING: testcase not yet written.\n");
+  GNUNET_log_setup ("test_fs_getopt",
+                    "WARNING",
+                    NULL);
+  fprintf (stderr, "%s", "WARNING: testcase not yet written.\n");
   return 0;                     /* testcase passed */
 }
diff --git a/src/fs/test_fs_list_indexed.c b/src/fs/test_fs_list_indexed.c
index b5e5982d0..431d42b2e 100644
--- a/src/fs/test_fs_list_indexed.c
+++ b/src/fs/test_fs_list_indexed.c
@@ -40,12 +40,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -62,121 +62,121 @@ static int err;
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
-  GNUNET_FS_publish_stop(publish);
+  GNUNET_FS_publish_stop (publish);
   publish = NULL;
-  GNUNET_DISK_directory_remove(fn1);
-  GNUNET_free(fn1);
+  GNUNET_DISK_directory_remove (fn1);
+  GNUNET_free (fn1);
   fn1 = NULL;
-  GNUNET_DISK_directory_remove(fn2);
-  GNUNET_free(fn2);
+  GNUNET_DISK_directory_remove (fn2);
+  GNUNET_free (fn2);
   fn2 = NULL;
 }
 
 
 static void
-list_indexed_task(void *cls)
+list_indexed_task (void *cls)
 {
-  GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
+  GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   void *ret;
 
   ret = NULL;
   switch (event->status)
+  {
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    ret = event->value.publish.cctx;
+    printf ("Publish complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024));
+    if (0 == strcmp ("list_indexed-context-dir", event->value.publish.cctx))
+      GNUNET_SCHEDULER_add_now (&list_indexed_task, NULL);
+
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    ret = event->value.publish.cctx;
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    ret = event->value.publish.cctx;
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    ret = event->value.publish.cctx;
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    err = 1;
+    if (0 == strcmp ("list_indexed-context-dir", event->value.publish.cctx))
+      GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    ret = event->value.publish.cctx;
+    if (0 == strcmp ("list_indexed-context1", event->value.publish.cctx))
     {
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      ret = event->value.publish.cctx;
-      printf("Publish complete,  %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024));
-      if (0 == strcmp("list_indexed-context-dir", event->value.publish.cctx))
-        GNUNET_SCHEDULER_add_now(&list_indexed_task, NULL);
-
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      ret = event->value.publish.cctx;
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      ret = event->value.publish.cctx;
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      ret = event->value.publish.cctx;
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      err = 1;
-      if (0 == strcmp("list_indexed-context-dir", event->value.publish.cctx))
-        GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      ret = event->value.publish.cctx;
-      if (0 == strcmp("list_indexed-context1", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 ==
-                        strcmp("list_indexed-context-dir",
-                               event->value.publish.pctx));
-          GNUNET_assert(FILESIZE == event->value.publish.size);
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(1 == event->value.publish.anonymity);
-        }
-      else if (0 == strcmp("list_indexed-context2", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 ==
-                        strcmp("list_indexed-context-dir",
-                               event->value.publish.pctx));
-          GNUNET_assert(FILESIZE == event->value.publish.size);
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(2 == event->value.publish.anonymity);
-        }
-      else if (0 ==
-               strcmp("list_indexed-context-dir", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(3 == event->value.publish.anonymity);
-        }
-      else
-        GNUNET_assert(0);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      if (0 == strcmp("list_indexed-context-dir", event->value.publish.cctx))
-        {
-          GNUNET_assert(publish == event->value.publish.pc);
-          publish = NULL;
-        }
-      break;
-
-    default:
-      printf("Unexpected event: %d\n", event->status);
-      break;
+      GNUNET_assert (0 ==
+                     strcmp ("list_indexed-context-dir",
+                             event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (1 == event->value.publish.anonymity);
     }
+    else if (0 == strcmp ("list_indexed-context2", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 ==
+                     strcmp ("list_indexed-context-dir",
+                             event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (2 == event->value.publish.anonymity);
+    }
+    else if (0 ==
+             strcmp ("list_indexed-context-dir", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (3 == event->value.publish.anonymity);
+    }
+    else
+      GNUNET_assert (0);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    if (0 == strcmp ("list_indexed-context-dir", event->value.publish.cctx))
+    {
+      GNUNET_assert (publish == event->value.publish.pc);
+      publish = NULL;
+    }
+    break;
+
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return ret;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -191,70 +191,70 @@ run(void *cls,
   size_t i;
   struct GNUNET_FS_BlockOptions bo;
 
-  fs = GNUNET_FS_start(cfg, "test-fs-list_indexed", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  fn1 = GNUNET_DISK_mktemp("gnunet-list_indexed-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-list_indexed", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  fn1 = GNUNET_DISK_mktemp ("gnunet-list_indexed-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn1, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  fn2 = GNUNET_DISK_mktemp("gnunet-list_indexed-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  fn2 = GNUNET_DISK_mktemp ("gnunet-list_indexed-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn2, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
   fi1 =
-    GNUNET_FS_file_information_create_from_file(fs, "list_indexed-context1",
-                                                fn1, kuri, meta, GNUNET_YES,
-                                                &bo);
-  GNUNET_assert(NULL != fi1);
+    GNUNET_FS_file_information_create_from_file (fs, "list_indexed-context1",
+                                                 fn1, kuri, meta, GNUNET_YES,
+                                                 &bo);
+  GNUNET_assert (NULL != fi1);
   bo.anonymity_level = 2;
   fi2 =
-    GNUNET_FS_file_information_create_from_file(fs, "list_indexed-context2",
-                                                fn2, kuri, meta, GNUNET_YES,
-                                                &bo);
-  GNUNET_assert(NULL != fi2);
+    GNUNET_FS_file_information_create_from_file (fs, "list_indexed-context2",
+                                                 fn2, kuri, meta, GNUNET_YES,
+                                                 &bo);
+  GNUNET_assert (NULL != fi2);
   bo.anonymity_level = 3;
   fidir =
-    GNUNET_FS_file_information_create_empty_directory(fs,
-                                                      "list_indexed-context-dir",
-                                                      kuri, meta, &bo, NULL);
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi1));
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi2));
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fidir);
-  start = GNUNET_TIME_absolute_get();
+    GNUNET_FS_file_information_create_empty_directory (fs,
+                                                       "list_indexed-context-dir",
+                                                       kuri, meta, &bo, NULL);
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fidir);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fidir, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
+    GNUNET_FS_publish_start (fs, fidir, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-list-indexed",
-                                   "test_fs_list_indexed_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-list-indexed",
+                                    "test_fs_list_indexed_data.conf",
+                                    &run, NULL))
     return 1;
   return 0;
 }
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index 3abbd5063..cdcb4d8fd 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -41,7 +41,7 @@ static struct GNUNET_FS_SearchContext *sks_search;
 
 static struct GNUNET_FS_SearchContext *ksk_search;
 
-static struct GNUNET_SCHEDULER_Task * kill_task;
+static struct GNUNET_SCHEDULER_Task *kill_task;
 
 static int update_started;
 
@@ -49,123 +49,123 @@ static int err;
 
 
 static void
-abort_ksk_search_task(void *cls)
+abort_ksk_search_task (void *cls)
 {
   if (ksk_search != NULL)
+  {
+    GNUNET_FS_search_stop (ksk_search);
+    ksk_search = NULL;
+    if (sks_search == NULL)
     {
-      GNUNET_FS_search_stop(ksk_search);
-      ksk_search = NULL;
-      if (sks_search == NULL)
-        {
-          GNUNET_FS_stop(fs);
-          if (NULL != kill_task)
-            GNUNET_SCHEDULER_cancel(kill_task);
-        }
+      GNUNET_FS_stop (fs);
+      if (NULL != kill_task)
+        GNUNET_SCHEDULER_cancel (kill_task);
     }
+  }
 }
 
 
 static void
-abort_sks_search_task(void *cls)
+abort_sks_search_task (void *cls)
 {
   if (sks_search == NULL)
     return;
-  GNUNET_FS_search_stop(sks_search);
+  GNUNET_FS_search_stop (sks_search);
   sks_search = NULL;
   if (ksk_search == NULL)
-    {
-      GNUNET_FS_stop(fs);
-      if (NULL != kill_task)
-        GNUNET_SCHEDULER_cancel(kill_task);
-    }
+  {
+    GNUNET_FS_stop (fs);
+    if (NULL != kill_task)
+      GNUNET_SCHEDULER_cancel (kill_task);
+  }
 }
 
 
 static void
-do_timeout(void *cls)
+do_timeout (void *cls)
 {
   err = 1;
-  fprintf(stderr, "%s", "Operation timed out\n");
+  fprintf (stderr, "%s", "Operation timed out\n");
   kill_task = NULL;
-  abort_sks_search_task(NULL);
-  abort_ksk_search_task(NULL);
+  abort_sks_search_task (NULL);
+  abort_ksk_search_task (NULL);
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   switch (event->status)
+  {
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    if (sks_search == event->value.search.sc)
     {
-    case GNUNET_FS_STATUS_SEARCH_RESULT:
-      if (sks_search == event->value.search.sc)
-        {
-          if (!GNUNET_FS_uri_test_equal
-                (sks_expect_uri, event->value.search.specifics.result.uri))
-            {
-              fprintf(stderr, "%s", "Wrong result for sks search!\n");
-              err = 1;
-            }
-          /* give system 1ms to initiate update search! */
-          GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MILLISECONDS,
-                                       &abort_sks_search_task, NULL);
-        }
-      else if (ksk_search == event->value.search.sc)
-        {
-          if (!GNUNET_FS_uri_test_equal
-                (ksk_expect_uri, event->value.search.specifics.result.uri))
-            {
-              fprintf(stderr, "%s", "Wrong result for ksk search!\n");
-              err = 1;
-            }
-          GNUNET_SCHEDULER_add_now(&abort_ksk_search_task, NULL);
-        }
-      else
-        {
-          fprintf(stderr, "%s", "Unexpected search result received!\n");
-          GNUNET_break(0);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf(stderr, "Error searching file: %s\n",
-              event->value.search.specifics.error.message);
-      if (sks_search == event->value.search.sc)
-        GNUNET_SCHEDULER_add_now(&abort_sks_search_task, NULL);
-      else if (ksk_search == event->value.search.sc)
-        GNUNET_SCHEDULER_add_now(&abort_ksk_search_task, NULL);
-      else
-        GNUNET_break(0);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_START:
-      GNUNET_assert((NULL == event->value.search.cctx) ||
-                    (0 == strcmp("sks_search", event->value.search.cctx)) ||
-                    (0 == strcmp("ksk_search", event->value.search.cctx)));
-      if (NULL == event->value.search.cctx)
-        {
-          GNUNET_assert(0 == strcmp("sks_search", event->value.search.pctx));
-          update_started = GNUNET_YES;
-        }
-      GNUNET_assert(1 == event->value.search.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
-      return NULL;
-
-    case GNUNET_FS_STATUS_SEARCH_STOPPED:
-      return NULL;
-
-    default:
-      fprintf(stderr, "Unexpected event: %d\n", event->status);
-      break;
+      if (! GNUNET_FS_uri_test_equal
+            (sks_expect_uri, event->value.search.specifics.result.uri))
+      {
+        fprintf (stderr, "%s", "Wrong result for sks search!\n");
+        err = 1;
+      }
+      /* give system 1ms to initiate update search! */
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
+                                    &abort_sks_search_task, NULL);
     }
+    else if (ksk_search == event->value.search.sc)
+    {
+      if (! GNUNET_FS_uri_test_equal
+            (ksk_expect_uri, event->value.search.specifics.result.uri))
+      {
+        fprintf (stderr, "%s", "Wrong result for ksk search!\n");
+        err = 1;
+      }
+      GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
+    }
+    else
+    {
+      fprintf (stderr, "%s", "Unexpected search result received!\n");
+      GNUNET_break (0);
+    }
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr, "Error searching file: %s\n",
+             event->value.search.specifics.error.message);
+    if (sks_search == event->value.search.sc)
+      GNUNET_SCHEDULER_add_now (&abort_sks_search_task, NULL);
+    else if (ksk_search == event->value.search.sc)
+      GNUNET_SCHEDULER_add_now (&abort_ksk_search_task, NULL);
+    else
+      GNUNET_break (0);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_START:
+    GNUNET_assert ((NULL == event->value.search.cctx) ||
+                   (0 == strcmp ("sks_search", event->value.search.cctx)) ||
+                   (0 == strcmp ("ksk_search", event->value.search.cctx)));
+    if (NULL == event->value.search.cctx)
+    {
+      GNUNET_assert (0 == strcmp ("sks_search", event->value.search.pctx));
+      update_started = GNUNET_YES;
+    }
+    GNUNET_assert (1 == event->value.search.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+    return NULL;
+
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    return NULL;
+
+  default:
+    fprintf (stderr, "Unexpected event: %d\n", event->status);
+    break;
+  }
   return event->value.search.cctx;
 }
 
 
 static void
-publish_cont(void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
+publish_cont (void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
 {
   char *msg;
   struct GNUNET_FS_Uri *sks_uri;
@@ -174,37 +174,37 @@ publish_cont(void *cls, const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
   char *ret;
 
   if (NULL != emsg)
-    {
-      fprintf(stderr, "Error publishing: %s\n", emsg);
-      err = 1;
-      GNUNET_FS_stop(fs);
-      return;
-    }
-  ret = GNUNET_STRINGS_data_to_string(&nsid, sizeof(nsid), buf, sizeof(buf));
-  GNUNET_assert(NULL != ret);
+  {
+    fprintf (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  ret = GNUNET_STRINGS_data_to_string (&nsid, sizeof(nsid), buf, sizeof(buf));
+  GNUNET_assert (NULL != ret);
   ret[0] = '\0';
-  GNUNET_snprintf(sbuf, sizeof(sbuf), "gnunet://fs/sks/%s/this", buf);
-  sks_uri = GNUNET_FS_uri_parse(sbuf, &msg);
+  GNUNET_snprintf (sbuf, sizeof(sbuf), "gnunet://fs/sks/%s/this", buf);
+  sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
   if (NULL == sks_uri)
-    {
-      fprintf(stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
-      err = 1;
-      GNUNET_FS_stop(fs);
-      GNUNET_free_non_null(msg);
-      return;
-    }
+  {
+    fprintf (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    GNUNET_free_non_null (msg);
+    return;
+  }
   ksk_search =
-    GNUNET_FS_search_start(fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
-                           "ksk_search");
+    GNUNET_FS_search_start (fs, ksk_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                            "ksk_search");
   sks_search =
-    GNUNET_FS_search_start(fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
-                           "sks_search");
-  GNUNET_FS_uri_destroy(sks_uri);
+    GNUNET_FS_search_start (fs, sks_uri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                            "sks_search");
+  GNUNET_FS_uri_destroy (sks_uri);
 }
 
 
 static void
-sks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
+sks_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
   struct GNUNET_CONTAINER_MetaData *meta;
   struct GNUNET_FS_Uri *ksk_uri;
@@ -212,61 +212,61 @@ sks_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
   struct GNUNET_FS_BlockOptions bo;
 
   if (NULL == uri)
-    {
-      fprintf(stderr, "Error publishing: %s\n", emsg);
-      err = 1;
-      GNUNET_FS_stop(fs);
-      return;
-    }
-  meta = GNUNET_CONTAINER_meta_data_create();
+  {
+    fprintf (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  meta = GNUNET_CONTAINER_meta_data_create ();
   msg = NULL;
-  ksk_uri = GNUNET_FS_uri_parse("gnunet://fs/ksk/ns-search", &msg);
-  GNUNET_assert(NULL == msg);
-  ksk_expect_uri = GNUNET_FS_uri_dup(uri);
+  ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/ns-search", &msg);
+  GNUNET_assert (NULL == msg);
+  ksk_expect_uri = GNUNET_FS_uri_dup (uri);
   bo.content_priority = 1;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
   bo.expiration_time =
-    GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES);
-  GNUNET_FS_publish_ksk(fs, ksk_uri, meta, uri, &bo,
-                        GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
-  GNUNET_FS_uri_destroy(ksk_uri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
+    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  GNUNET_FS_publish_ksk (fs, ksk_uri, meta, uri, &bo,
+                         GNUNET_FS_PUBLISH_OPTION_NONE, &publish_cont, NULL);
+  GNUNET_FS_uri_destroy (ksk_uri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
 }
 
 
 static void
-adv_cont(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
+adv_cont (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
   struct GNUNET_CONTAINER_MetaData *meta;
   struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
   struct GNUNET_FS_BlockOptions bo;
 
   if (NULL != emsg)
-    {
-      fprintf(stderr, "Error publishing: %s\n", emsg);
-      err = 1;
-      GNUNET_FS_stop(fs);
-      return;
-    }
-  ns = GNUNET_CRYPTO_ecdsa_key_create();
-  meta = GNUNET_CONTAINER_meta_data_create();
-  sks_expect_uri = GNUNET_FS_uri_dup(uri);
+  {
+    fprintf (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  ns = GNUNET_CRYPTO_ecdsa_key_create ();
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  sks_expect_uri = GNUNET_FS_uri_dup (uri);
   bo.content_priority = 1;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
   bo.expiration_time =
-    GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES);
-  GNUNET_CRYPTO_ecdsa_key_get_public(ns, &nsid);
-  GNUNET_FS_publish_sks(fs, ns, "this", "next", meta, uri,
-                        &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_free(ns);
+    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  GNUNET_CRYPTO_ecdsa_key_get_public (ns, &nsid);
+  GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri,
+                         &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_free (ns);
 }
 
 
 static void
-testNamespace()
+testNamespace ()
 {
   struct GNUNET_CRYPTO_EcdsaPrivateKey *ns;
   struct GNUNET_FS_BlockOptions bo;
@@ -274,46 +274,46 @@ testNamespace()
   struct GNUNET_FS_Uri *ksk_uri;
   struct GNUNET_FS_Uri *sks_uri;
 
-  ns = GNUNET_CRYPTO_ecdsa_key_create();
-  meta = GNUNET_CONTAINER_meta_data_create();
-  ksk_uri = GNUNET_FS_uri_parse("gnunet://fs/ksk/testnsa", NULL);
+  ns = GNUNET_CRYPTO_ecdsa_key_create ();
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/testnsa", NULL);
   bo.content_priority = 1;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
   bo.expiration_time =
-    GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES);
-  sks_uri = GNUNET_FS_uri_sks_create(&nsid, "root");
-  GNUNET_FS_publish_ksk(fs,
-                        ksk_uri, meta, sks_uri,
-                        &bo, GNUNET_FS_PUBLISH_OPTION_NONE,
-                        &adv_cont, NULL);
-  GNUNET_FS_uri_destroy(sks_uri);
+    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  sks_uri = GNUNET_FS_uri_sks_create (&nsid, "root");
+  GNUNET_FS_publish_ksk (fs,
+                         ksk_uri, meta, sks_uri,
+                         &bo, GNUNET_FS_PUBLISH_OPTION_NONE,
+                         &adv_cont, NULL);
+  GNUNET_FS_uri_destroy (sks_uri);
   kill_task =
-    GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_MINUTES, &do_timeout,
-                                 NULL);
-  GNUNET_FS_uri_destroy(ksk_uri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_free(ns);
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
+                                  NULL);
+  GNUNET_FS_uri_destroy (ksk_uri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_free (ns);
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
-  fs = GNUNET_FS_start(cfg, "test-fs-namespace", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  testNamespace();
+  fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  testNamespace ();
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-namespace",
-                                   "test_fs_namespace_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace",
+                                    "test_fs_namespace_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_namespace_list_updateable.c b/src/fs/test_fs_namespace_list_updateable.c
index 9a28fcb1b..4311f0110 100644
--- a/src/fs/test_fs_namespace_list_updateable.c
+++ b/src/fs/test_fs_namespace_list_updateable.c
@@ -45,128 +45,130 @@ static struct GNUNET_FS_BlockOptions bo;
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   return NULL;
 }
 
 
 static void
-do_shutdown()
+do_shutdown ()
 {
   if (uri_this != NULL)
-    GNUNET_FS_uri_destroy(uri_this);
+    GNUNET_FS_uri_destroy (uri_this);
   if (uri_next != NULL)
-    GNUNET_FS_uri_destroy(uri_next);
+    GNUNET_FS_uri_destroy (uri_next);
   if (ns != NULL)
-    GNUNET_free(ns);
+    GNUNET_free (ns);
   if (meta != NULL)
-    GNUNET_CONTAINER_meta_data_destroy(meta);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
 }
 
 
 static void
-check_next(void *cls, const char *last_id,
-           const struct GNUNET_FS_Uri *last_uri,
-           const struct GNUNET_CONTAINER_MetaData *last_meta,
-           const char *next_id)
+check_next (void *cls, const char *last_id,
+            const struct GNUNET_FS_Uri *last_uri,
+            const struct GNUNET_CONTAINER_MetaData *last_meta,
+            const char *next_id)
 {
-  GNUNET_break(0 == strcmp(last_id, "next"));
-  GNUNET_break(0 == strcmp(next_id, "future"));
+  GNUNET_break (0 == strcmp (last_id, "next"));
+  GNUNET_break (0 == strcmp (next_id, "future"));
   err -= 4;
 }
 
 
 static void
-check_this_next(void *cls, const char *last_id,
-                const struct GNUNET_FS_Uri *last_uri,
-                const struct GNUNET_CONTAINER_MetaData *last_meta,
-                const char *next_id)
+check_this_next (void *cls, const char *last_id,
+                 const struct GNUNET_FS_Uri *last_uri,
+                 const struct GNUNET_CONTAINER_MetaData *last_meta,
+                 const char *next_id)
 {
-  GNUNET_break(0 == strcmp(last_id, "this"));
-  GNUNET_break(0 == strcmp(next_id, "next"));
+  GNUNET_break (0 == strcmp (last_id, "this"));
+  GNUNET_break (0 == strcmp (next_id, "next"));
   err -= 2;
   err += 4;
-  GNUNET_FS_namespace_list_updateable(fs, ns, next_id, &check_next, NULL);
+  GNUNET_FS_namespace_list_updateable (fs, ns, next_id, &check_next, NULL);
 }
 
 
 static void
-sks_cont_next(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
+sks_cont_next (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
-  GNUNET_assert(NULL == emsg);
+  GNUNET_assert (NULL == emsg);
   err += 2;
-  GNUNET_FS_namespace_list_updateable(fs, ns, NULL, &check_this_next, NULL);
+  GNUNET_FS_namespace_list_updateable (fs, ns, NULL, &check_this_next, NULL);
 }
 
 
 static void
-check_this(void *cls, const char *last_id,
-           const struct GNUNET_FS_Uri *last_uri,
-           const struct GNUNET_CONTAINER_MetaData *last_meta,
-           const char *next_id)
+check_this (void *cls, const char *last_id,
+            const struct GNUNET_FS_Uri *last_uri,
+            const struct GNUNET_CONTAINER_MetaData *last_meta,
+            const char *next_id)
 {
-  GNUNET_break(0 == strcmp(last_id, "this"));
-  GNUNET_break(0 == strcmp(next_id, "next"));
+  GNUNET_break (0 == strcmp (last_id, "this"));
+  GNUNET_break (0 == strcmp (next_id, "next"));
   err -= 1;
 }
 
 
 static void
-sks_cont_this(void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
+sks_cont_this (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
-  GNUNET_assert(NULL == emsg);
+  GNUNET_assert (NULL == emsg);
   err = 1;
-  GNUNET_FS_namespace_list_updateable(fs, ns, NULL, &check_this, NULL);
-  GNUNET_FS_publish_sks(fs, ns, "next", "future", meta, uri_next, &bo,
-                        GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont_next, NULL);
+  GNUNET_FS_namespace_list_updateable (fs, ns, NULL, &check_this, NULL);
+  GNUNET_FS_publish_sks (fs, ns, "next", "future", meta, uri_next, &bo,
+                         GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont_next, NULL);
 }
 
 
 static void
-testNamespace()
+testNamespace ()
 {
-  ns = GNUNET_CRYPTO_ecdsa_key_create();
-  GNUNET_assert(NULL != ns);
+  ns = GNUNET_CRYPTO_ecdsa_key_create ();
+  GNUNET_assert (NULL != ns);
   bo.content_priority = 1;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
   bo.expiration_time =
-    GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_MINUTES);
-  meta = GNUNET_CONTAINER_meta_data_create();
+    GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  meta = GNUNET_CONTAINER_meta_data_create ();
 
   uri_this =
     GNUNET_FS_uri_parse
-      ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42",
+    (
+      "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42",
       NULL);
   uri_next =
     GNUNET_FS_uri_parse
-      ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.43",
+    (
+      "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.43",
       NULL);
-  GNUNET_FS_publish_sks(fs, ns, "this", "next", meta, uri_this, &bo,
-                        GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont_this, NULL);
+  GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri_this, &bo,
+                         GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont_this, NULL);
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
-  fs = GNUNET_FS_start(cfg, "test-fs-namespace", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  testNamespace();
+  fs = GNUNET_FS_start (cfg, "test-fs-namespace", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  testNamespace ();
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-namespace-list-updateable",
-                                   "test_fs_namespace_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-namespace-list-updateable",
+                                    "test_fs_namespace_data.conf",
+                                    &run, NULL))
     return 1;
-  do_shutdown();
+  do_shutdown ();
   return err;
 }
 
diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c
index 02c1587d2..40eaa09e3 100644
--- a/src/fs/test_fs_publish.c
+++ b/src/fs/test_fs_publish.c
@@ -36,12 +36,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -58,111 +58,111 @@ static int err;
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
-  GNUNET_FS_publish_stop(publish);
+  GNUNET_FS_publish_stop (publish);
   publish = NULL;
-  GNUNET_DISK_directory_remove(fn1);
-  GNUNET_free(fn1);
+  GNUNET_DISK_directory_remove (fn1);
+  GNUNET_free (fn1);
   fn1 = NULL;
-  GNUNET_DISK_directory_remove(fn2);
-  GNUNET_free(fn2);
+  GNUNET_DISK_directory_remove (fn2);
+  GNUNET_free (fn2);
   fn2 = NULL;
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   void *ret;
 
   ret = NULL;
   switch (event->status)
+  {
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    ret = event->value.publish.cctx;
+    printf ("Publish complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024));
+    if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+      GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    ret = event->value.publish.cctx;
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    ret = event->value.publish.cctx;
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    ret = event->value.publish.cctx;
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    err = 1;
+    if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
     {
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      ret = event->value.publish.cctx;
-      printf("Publish complete,  %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024));
-      if (0 == strcmp("publish-context-dir", event->value.publish.cctx))
-        GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      ret = event->value.publish.cctx;
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      ret = event->value.publish.cctx;
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      ret = event->value.publish.cctx;
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      err = 1;
-      if (0 == strcmp("publish-context-dir", event->value.publish.cctx))
-        {
-          fprintf(stderr, "Scheduling abort task for error on `%s'\n",
-                  (const char *)event->value.publish.cctx);
-          GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      ret = event->value.publish.cctx;
-      if (0 == strcmp("publish-context1", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 ==
-                        strcmp("publish-context-dir", event->value.publish.pctx));
-          GNUNET_assert(FILESIZE == event->value.publish.size);
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(1 == event->value.publish.anonymity);
-        }
-      else if (0 == strcmp("publish-context2", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 ==
-                        strcmp("publish-context-dir", event->value.publish.pctx));
-          GNUNET_assert(FILESIZE == event->value.publish.size);
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(2 == event->value.publish.anonymity);
-        }
-      else if (0 == strcmp("publish-context-dir", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(3 == event->value.publish.anonymity);
-        }
-      else
-        GNUNET_assert(0);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      if (0 == strcmp("publish-context-dir", event->value.publish.cctx))
-        GNUNET_assert(publish == event->value.publish.pc);
-      break;
-
-    default:
-      printf("Unexpected event: %d\n", event->status);
-      break;
+      fprintf (stderr, "Scheduling abort task for error on `%s'\n",
+               (const char *) event->value.publish.cctx);
+      GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
     }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    ret = event->value.publish.cctx;
+    if (0 == strcmp ("publish-context1", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 ==
+                     strcmp ("publish-context-dir", event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (1 == event->value.publish.anonymity);
+    }
+    else if (0 == strcmp ("publish-context2", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 ==
+                     strcmp ("publish-context-dir", event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (2 == event->value.publish.anonymity);
+    }
+    else if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (3 == event->value.publish.anonymity);
+    }
+    else
+      GNUNET_assert (0);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+      GNUNET_assert (publish == event->value.publish.pc);
+    break;
+
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return ret;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -177,70 +177,70 @@ run(void *cls,
   size_t i;
   struct GNUNET_FS_BlockOptions bo;
 
-  fs = GNUNET_FS_start(cfg, "test-fs-publish", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  fn1 = GNUNET_DISK_mktemp("gnunet-publish-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-publish", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  fn1 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn1, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  fn2 = GNUNET_DISK_mktemp("gnunet-publish-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  fn2 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn2, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
 
   fi1 =
-    GNUNET_FS_file_information_create_from_file(fs, "publish-context1", fn1,
-                                                kuri, meta, GNUNET_YES, &bo);
+    GNUNET_FS_file_information_create_from_file (fs, "publish-context1", fn1,
+                                                 kuri, meta, GNUNET_YES, &bo);
 
-  GNUNET_assert(NULL != fi1);
+  GNUNET_assert (NULL != fi1);
   bo.anonymity_level = 2;
   fi2 =
-    GNUNET_FS_file_information_create_from_file(fs, "publish-context2", fn2,
-                                                kuri, meta, GNUNET_YES, &bo);
-  GNUNET_assert(NULL != fi2);
+    GNUNET_FS_file_information_create_from_file (fs, "publish-context2", fn2,
+                                                 kuri, meta, GNUNET_YES, &bo);
+  GNUNET_assert (NULL != fi2);
   bo.anonymity_level = 3;
   fidir =
-    GNUNET_FS_file_information_create_empty_directory(fs,
-                                                      "publish-context-dir",
-                                                      kuri, meta, &bo, NULL);
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi1));
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi2));
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fidir);
-  start = GNUNET_TIME_absolute_get();
+    GNUNET_FS_file_information_create_empty_directory (fs,
+                                                       "publish-context-dir",
+                                                       kuri, meta, &bo, NULL);
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fidir);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fidir, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
+    GNUNET_FS_publish_start (fs, fidir, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-publish",
-                                   "test_fs_publish_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-publish",
+                                    "test_fs_publish_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_publish_persistence.c b/src/fs/test_fs_publish_persistence.c
index 7cba55179..4247f78dd 100644
--- a/src/fs/test_fs_publish_persistence.c
+++ b/src/fs/test_fs_publish_persistence.c
@@ -36,12 +36,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -64,39 +64,39 @@ static struct GNUNET_SCHEDULER_Task *rtask;
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
-  GNUNET_FS_publish_stop(publish);
+  GNUNET_FS_publish_stop (publish);
   publish = NULL;
-  GNUNET_DISK_directory_remove(fn1);
-  GNUNET_free(fn1);
+  GNUNET_DISK_directory_remove (fn1);
+  GNUNET_free (fn1);
   fn1 = NULL;
-  GNUNET_DISK_directory_remove(fn2);
-  GNUNET_free(fn2);
+  GNUNET_DISK_directory_remove (fn2);
+  GNUNET_free (fn2);
   fn2 = NULL;
-  GNUNET_FS_stop(fs);
+  GNUNET_FS_stop (fs);
   fs = NULL;
   if (NULL != rtask)
-    {
-      GNUNET_SCHEDULER_cancel(rtask);
-      rtask = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (rtask);
+    rtask = NULL;
+  }
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event);
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task(void *cls)
+restart_fs_task (void *cls)
 {
   rtask = NULL;
-  GNUNET_FS_stop(fs);
-  fs = GNUNET_FS_start(cfg, "test-fs-publish-persistence",
-                       &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE,
-                       GNUNET_FS_OPTIONS_END);
+  GNUNET_FS_stop (fs);
+  fs = GNUNET_FS_start (cfg, "test-fs-publish-persistence",
+                        &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE,
+                        GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -108,7 +108,7 @@ restart_fs_task(void *cls)
  * @param ev type of the event to consider
  */
 static void
-consider_restart(int ev)
+consider_restart (int ev)
 {
   static int prev[32];
   static int off;
@@ -119,123 +119,123 @@ consider_restart(int ev)
       return;
   prev[off++] = ev;
   rtask =
-    GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                       &restart_fs_task, NULL);
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
+                                        &restart_fs_task, NULL);
 }
 
 
 static void *
-progress_cb(void *cls,
-            const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls,
+             const struct GNUNET_FS_ProgressInfo *event)
 {
   void *ret;
 
   ret = NULL;
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      ret = event->value.publish.cctx;
-      printf("Publish complete,  %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024));
-      if ((NULL != event->value.publish.cctx) &&
-          (0 == strcmp("publish-context-dir", event->value.publish.cctx)))
-        GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      ret = event->value.publish.cctx;
-      return ret;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      consider_restart(event->status);
-      ret = event->value.publish.cctx;
-      GNUNET_assert(publish == event->value.publish.pc);
+  {
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    ret = event->value.publish.cctx;
+    printf ("Publish complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024));
+    if ((NULL != event->value.publish.cctx) &&
+        (0 == strcmp ("publish-context-dir", event->value.publish.cctx)))
+      GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    ret = event->value.publish.cctx;
+    return ret;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    consider_restart (event->status);
+    ret = event->value.publish.cctx;
+    GNUNET_assert (publish == event->value.publish.pc);
 #if VERBOSE
-      printf("Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-             (unsigned long long)event->value.publish.completed,
-             (unsigned long long)event->value.publish.size,
-             event->value.publish.specifics.progress.depth,
-             (unsigned long long)event->value.publish.specifics.
-             progress.offset);
+    printf ("Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+            (unsigned long long) event->value.publish.completed,
+            (unsigned long long) event->value.publish.size,
+            event->value.publish.specifics.progress.depth,
+            (unsigned long long) event->value.publish.specifics.
+            progress.offset);
 #endif
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
-      if (event->value.publish.pc == publish)
-        publish = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_RESUME:
-      if (NULL == publish)
-        {
-          GNUNET_assert(GNUNET_YES ==
-                        GNUNET_FS_file_information_is_directory(event->
-                                                                value.publish.
-                                                                fi));
-          publish = event->value.publish.pc;
-          return "publish-context-dir";
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      ret = event->value.publish.cctx;
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      err = 1;
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      consider_restart(event->status);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
+    if (event->value.publish.pc == publish)
+      publish = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_RESUME:
+    if (NULL == publish)
+    {
+      GNUNET_assert (GNUNET_YES ==
+                     GNUNET_FS_file_information_is_directory (event->
+                                                              value.publish.
+                                                              fi));
       publish = event->value.publish.pc;
-      ret = event->value.publish.cctx;
-      if (0 == strcmp("publish-context1", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 ==
-                        strcmp("publish-context-dir", event->value.publish.pctx));
-          GNUNET_assert(FILESIZE == event->value.publish.size);
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(1 == event->value.publish.anonymity);
-        }
-      else if (0 == strcmp("publish-context2", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 ==
-                        strcmp("publish-context-dir", event->value.publish.pctx));
-          GNUNET_assert(FILESIZE == event->value.publish.size);
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(2 == event->value.publish.anonymity);
-        }
-      else if (0 == strcmp("publish-context-dir", event->value.publish.cctx))
-        {
-          GNUNET_assert(0 == event->value.publish.completed);
-          GNUNET_assert(3 == event->value.publish.anonymity);
-        }
-      else
-        GNUNET_assert(0);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      consider_restart(event->status);
-      if ((NULL != event->value.publish.cctx) &&
-          (0 == strcmp("publish-context-dir", event->value.publish.cctx)))
-        GNUNET_assert(publish == event->value.publish.pc);
-      break;
-
-    default:
-      printf("Unexpected event: %d\n", event->status);
-      break;
+      return "publish-context-dir";
+    }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    ret = event->value.publish.cctx;
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    err = 1;
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    consider_restart (event->status);
+    publish = event->value.publish.pc;
+    ret = event->value.publish.cctx;
+    if (0 == strcmp ("publish-context1", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 ==
+                     strcmp ("publish-context-dir", event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (1 == event->value.publish.anonymity);
+    }
+    else if (0 == strcmp ("publish-context2", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 ==
+                     strcmp ("publish-context-dir", event->value.publish.pctx));
+      GNUNET_assert (FILESIZE == event->value.publish.size);
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (2 == event->value.publish.anonymity);
+    }
+    else if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+    {
+      GNUNET_assert (0 == event->value.publish.completed);
+      GNUNET_assert (3 == event->value.publish.anonymity);
     }
+    else
+      GNUNET_assert (0);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    consider_restart (event->status);
+    if ((NULL != event->value.publish.cctx) &&
+        (0 == strcmp ("publish-context-dir", event->value.publish.cctx)))
+      GNUNET_assert (publish == event->value.publish.pc);
+    break;
+
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return ret;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -251,67 +251,67 @@ run(void *cls,
   struct GNUNET_FS_BlockOptions bo;
 
   cfg = c;
-  fs = GNUNET_FS_start(cfg, "test-fs-publish-persistence", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  fn1 = GNUNET_DISK_mktemp("gnunet-publish-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-publish-persistence", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  fn1 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn1, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  fn2 = GNUNET_DISK_mktemp("gnunet-publish-test-dst");
-  buf = GNUNET_malloc(FILESIZE);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn1, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  fn2 = GNUNET_DISK_mktemp ("gnunet-publish-test-dst");
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn2, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn2, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
   fi1 =
-    GNUNET_FS_file_information_create_from_file(fs, "publish-context1", fn1,
-                                                kuri, meta, GNUNET_YES, &bo);
-  GNUNET_assert(NULL != fi1);
+    GNUNET_FS_file_information_create_from_file (fs, "publish-context1", fn1,
+                                                 kuri, meta, GNUNET_YES, &bo);
+  GNUNET_assert (NULL != fi1);
   bo.anonymity_level = 2;
   fi2 =
-    GNUNET_FS_file_information_create_from_file(fs, "publish-context2", fn2,
-                                                kuri, meta, GNUNET_YES, &bo);
-  GNUNET_assert(NULL != fi2);
+    GNUNET_FS_file_information_create_from_file (fs, "publish-context2", fn2,
+                                                 kuri, meta, GNUNET_YES, &bo);
+  GNUNET_assert (NULL != fi2);
   bo.anonymity_level = 3;
   fidir =
-    GNUNET_FS_file_information_create_empty_directory(fs,
-                                                      "publish-context-dir",
-                                                      kuri, meta, &bo, NULL);
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi1));
-  GNUNET_assert(GNUNET_OK == GNUNET_FS_file_information_add(fidir, fi2));
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fidir);
-  start = GNUNET_TIME_absolute_get();
-  GNUNET_FS_publish_start(fs, fidir, NULL, NULL, NULL,
-                          GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
+    GNUNET_FS_file_information_create_empty_directory (fs,
+                                                       "publish-context-dir",
+                                                       kuri, meta, &bo, NULL);
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi1));
+  GNUNET_assert (GNUNET_OK == GNUNET_FS_file_information_add (fidir, fi2));
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fidir);
+  start = GNUNET_TIME_absolute_get ();
+  GNUNET_FS_publish_start (fs, fidir, NULL, NULL, NULL,
+                           GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-publish-persistence",
-                                   "test_fs_publish_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-publish-persistence",
+                                    "test_fs_publish_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_search.c b/src/fs/test_fs_search.c
index 7906a4163..16f8ecbda 100644
--- a/src/fs/test_fs_search.c
+++ b/src/fs/test_fs_search.c
@@ -36,12 +36,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -52,60 +52,60 @@ static struct GNUNET_FS_SearchContext *search;
 
 static struct GNUNET_FS_PublishContext *publish;
 
-static struct GNUNET_SCHEDULER_Task * timeout_task;
+static struct GNUNET_SCHEDULER_Task *timeout_task;
 
 static int err;
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   if (NULL != timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
 }
 
 
 static void
-abort_error(void *cls)
+abort_error (void *cls)
 {
-  fprintf(stderr,
-          "Timeout\n");
+  fprintf (stderr,
+           "Timeout\n");
   timeout_task = NULL;
   if (NULL != search)
-    {
-      GNUNET_FS_search_stop(search);
-      search = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (search);
+    search = NULL;
+  }
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   err = 1;
 }
 
 
 static void
-abort_search_task(void *cls)
+abort_search_task (void *cls)
 {
   if (NULL != search)
-    {
-      GNUNET_FS_search_stop(search);
-      search = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (search);
+    search = NULL;
+  }
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   const char *keywords[] = {
     "down_foo"
@@ -113,91 +113,91 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
   struct GNUNET_FS_Uri *kuri;
 
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      kuri = GNUNET_FS_uri_ksk_create_from_args(1, keywords);
-      start = GNUNET_TIME_absolute_get();
-      search =
-        GNUNET_FS_search_start(fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
-                               "search");
-      GNUNET_FS_uri_destroy(kuri);
-      GNUNET_assert(search != NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Search complete.\n");
-      GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf(stderr, "Error searching file: %s\n",
-              event->value.search.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_START:
-      GNUNET_assert(search == NULL);
-      GNUNET_assert(0 == strcmp("search", event->value.search.cctx));
-      GNUNET_assert(1 == event->value.search.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_STOPPED:
-      GNUNET_assert(search == event->value.search.sc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    default:
-      fprintf(stderr, "Unexpected event: %d\n", event->status);
-      break;
-    }
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    kuri = GNUNET_FS_uri_ksk_create_from_args (1, keywords);
+    start = GNUNET_TIME_absolute_get ();
+    search =
+      GNUNET_FS_search_start (fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                              "search");
+    GNUNET_FS_uri_destroy (kuri);
+    GNUNET_assert (search != NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Search complete.\n");
+    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr, "Error searching file: %s\n",
+             event->value.search.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_START:
+    GNUNET_assert (search == NULL);
+    GNUNET_assert (0 == strcmp ("search", event->value.search.cctx));
+    GNUNET_assert (1 == event->value.search.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    GNUNET_assert (search == event->value.search.sc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  default:
+    fprintf (stderr, "Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -210,40 +210,40 @@ run(void *cls,
   struct GNUNET_FS_FileInformation *fi;
   size_t i;
 
-  fs = GNUNET_FS_start(cfg, "test-fs-search", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-search", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
-  fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
-                                                   FILESIZE, buf, kuri, meta,
-                                                   GNUNET_NO, &bo);
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fi);
-  start = GNUNET_TIME_absolute_get();
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+  fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
+                                                    FILESIZE, buf, kuri, meta,
+                                                    GNUNET_NO, &bo);
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fi);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
-  timeout_task = GNUNET_SCHEDULER_add_delayed(LIFETIME,
-                                              &abort_error, NULL);
+    GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
+  timeout_task = GNUNET_SCHEDULER_add_delayed (LIFETIME,
+                                               &abort_error, NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-search",
-                                   "test_fs_search_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-search",
+                                    "test_fs_search_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_search_persistence.c b/src/fs/test_fs_search_persistence.c
index b01abe75f..40671823d 100644
--- a/src/fs/test_fs_search_persistence.c
+++ b/src/fs/test_fs_search_persistence.c
@@ -36,12 +36,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -54,68 +54,68 @@ static struct GNUNET_FS_PublishContext *publish;
 
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
-static struct GNUNET_SCHEDULER_Task * timeout_task;
+static struct GNUNET_SCHEDULER_Task *timeout_task;
 
 static int err;
 
 
 static void
-abort_error(void *cls)
+abort_error (void *cls)
 {
   timeout_task = NULL;
-  fprintf(stderr,
-          "Timeout\n");
+  fprintf (stderr,
+           "Timeout\n");
   if (NULL != search)
-    {
-      GNUNET_FS_search_stop(search);
-      search = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (search);
+    search = NULL;
+  }
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   err = 1;
 }
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   if (NULL != timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
 }
 
 
 static void
-abort_search_task(void *cls)
+abort_search_task (void *cls)
 {
   if (NULL != search)
-    {
-      GNUNET_FS_search_stop(search);
-      search = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (search);
+    search = NULL;
+  }
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event);
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task(void *cls)
+restart_fs_task (void *cls)
 {
-  GNUNET_FS_stop(fs);
-  fs = GNUNET_FS_start(cfg, "test-fs-search-persistence", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
+  GNUNET_FS_stop (fs);
+  fs = GNUNET_FS_start (cfg, "test-fs-search-persistence", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -127,7 +127,7 @@ restart_fs_task(void *cls)
  * @param ev type of the event to consider
  */
 static void
-consider_restart(int ev)
+consider_restart (int ev)
 {
   static int prev[32];
   static int off;
@@ -137,13 +137,13 @@ consider_restart(int ev)
     if (prev[i] == ev)
       return;
   prev[off++] = ev;
-  GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                     &restart_fs_task, NULL);
+  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
+                                      &restart_fs_task, NULL);
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   const char *keywords[] = {
     "down_foo"
@@ -151,118 +151,118 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
   struct GNUNET_FS_Uri *kuri;
 
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      kuri = GNUNET_FS_uri_ksk_create_from_args(1, keywords);
-      start = GNUNET_TIME_absolute_get();
-      GNUNET_FS_search_start(fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
-                             "search");
-      GNUNET_FS_uri_destroy(kuri);
-      GNUNET_assert(search != NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
-      if (event->value.publish.pc == publish)
-        publish = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_RESUME:
-      if (NULL == publish)
-        publish = event->value.publish.pc;
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT:
-      /* FIXME: consider_restart (event->status); cannot be tested with
-       * search result since we exit here after the first one... */
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Search complete.\n");
-      GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf(stderr, "Error searching file: %s\n",
-              event->value.search.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_SUSPEND:
-      if (event->value.search.sc == search)
-        search = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESUME:
-      if (NULL == search)
-        {
-          search = event->value.search.sc;
-          return "search";
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_START:
-      consider_restart(event->status);
-      GNUNET_assert(search == NULL);
-      search = event->value.search.sc;
-      GNUNET_assert(0 == strcmp("search", event->value.search.cctx));
-      GNUNET_assert(1 == event->value.search.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_STOPPED:
-      GNUNET_assert(search == event->value.search.sc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    kuri = GNUNET_FS_uri_ksk_create_from_args (1, keywords);
+    start = GNUNET_TIME_absolute_get ();
+    GNUNET_FS_search_start (fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                            "search");
+    GNUNET_FS_uri_destroy (kuri);
+    GNUNET_assert (search != NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
+    if (event->value.publish.pc == publish)
+      publish = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_RESUME:
+    if (NULL == publish)
+      publish = event->value.publish.pc;
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    /* FIXME: consider_restart (event->status); cannot be tested with
+     * search result since we exit here after the first one... */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Search complete.\n");
+    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr, "Error searching file: %s\n",
+             event->value.search.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_SUSPEND:
+    if (event->value.search.sc == search)
       search = NULL;
-      break;
+    break;
 
-    default:
-      fprintf(stderr, "Unexpected event: %d\n", event->status);
-      break;
+  case GNUNET_FS_STATUS_SEARCH_RESUME:
+    if (NULL == search)
+    {
+      search = event->value.search.sc;
+      return "search";
     }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_START:
+    consider_restart (event->status);
+    GNUNET_assert (search == NULL);
+    search = event->value.search.sc;
+    GNUNET_assert (0 == strcmp ("search", event->value.search.cctx));
+    GNUNET_assert (1 == event->value.search.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    GNUNET_assert (search == event->value.search.sc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    search = NULL;
+    break;
+
+  default:
+    fprintf (stderr, "Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -276,40 +276,40 @@ run(void *cls,
   struct GNUNET_FS_BlockOptions bo;
 
   cfg = c;
-  fs = GNUNET_FS_start(cfg, "test-fs-search-persistence", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-search-persistence", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
-  fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
-                                                   FILESIZE, buf, kuri, meta,
-                                                   GNUNET_NO, &bo);
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fi);
-  start = GNUNET_TIME_absolute_get();
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+  fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
+                                                    FILESIZE, buf, kuri, meta,
+                                                    GNUNET_NO, &bo);
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fi);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
-  timeout_task = GNUNET_SCHEDULER_add_delayed(LIFETIME,
-                                              &abort_error, NULL);
+    GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
+  timeout_task = GNUNET_SCHEDULER_add_delayed (LIFETIME,
+                                               &abort_error, NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-search-persistence",
-                                   "test_fs_search_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-search-persistence",
+                                    "test_fs_search_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_search_probes.c b/src/fs/test_fs_search_probes.c
index 5584efca7..2e2dc6005 100644
--- a/src/fs/test_fs_search_probes.c
+++ b/src/fs/test_fs_search_probes.c
@@ -37,12 +37,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -53,58 +53,58 @@ static struct GNUNET_FS_SearchContext *search;
 
 static struct GNUNET_FS_PublishContext *publish;
 
-static struct GNUNET_SCHEDULER_Task * timeout_task;
+static struct GNUNET_SCHEDULER_Task *timeout_task;
 
 static int err;
 
 
 static void
-abort_error(void *cls)
+abort_error (void *cls)
 {
   timeout_task = NULL;
-  fprintf(stderr,
-          "Timeout\n");
+  fprintf (stderr,
+           "Timeout\n");
   if (NULL != search)
-    {
-      GNUNET_FS_search_stop(search);
-      search = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (search);
+    search = NULL;
+  }
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   err = 1;
 }
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   if (NULL != timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
 }
 
 
 static void
-abort_search_task(void *cls)
+abort_search_task (void *cls)
 {
   if (search != NULL)
-    GNUNET_FS_search_stop(search);
+    GNUNET_FS_search_stop (search);
   search = NULL;
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   const char *keywords[] = {
     "down_foo"
@@ -112,97 +112,97 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
   struct GNUNET_FS_Uri *kuri;
 
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      kuri = GNUNET_FS_uri_ksk_create_from_args(1, keywords);
-      start = GNUNET_TIME_absolute_get();
-      search =
-        GNUNET_FS_search_start(fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
-                               "search");
-      GNUNET_FS_uri_destroy(kuri);
-      GNUNET_assert(search != NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Search complete.\n");
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf(stderr, "Error searching file: %s\n",
-              event->value.search.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_UPDATE:
-      if ((0 < event->value.search.specifics.update.availability_rank) &&
-          (0 < event->value.search.specifics.update.availability_certainty))
-        GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_START:
-      GNUNET_assert(search == NULL);
-      GNUNET_assert(0 == strcmp("search", event->value.search.cctx));
-      GNUNET_assert(1 == event->value.search.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_STOPPED:
-      GNUNET_assert(search == event->value.search.sc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    default:
-      fprintf(stderr,
-              "Unexpected event: %d\n",
-              event->status);
-      break;
-    }
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    kuri = GNUNET_FS_uri_ksk_create_from_args (1, keywords);
+    start = GNUNET_TIME_absolute_get ();
+    search =
+      GNUNET_FS_search_start (fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                              "search");
+    GNUNET_FS_uri_destroy (kuri);
+    GNUNET_assert (search != NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Search complete.\n");
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr, "Error searching file: %s\n",
+             event->value.search.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_UPDATE:
+    if ((0 < event->value.search.specifics.update.availability_rank) &&
+        (0 < event->value.search.specifics.update.availability_certainty))
+      GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_START:
+    GNUNET_assert (search == NULL);
+    GNUNET_assert (0 == strcmp ("search", event->value.search.cctx));
+    GNUNET_assert (1 == event->value.search.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    GNUNET_assert (search == event->value.search.sc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  default:
+    fprintf (stderr,
+             "Unexpected event: %d\n",
+             event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -215,41 +215,41 @@ run(void *cls,
   struct GNUNET_FS_FileInformation *fi;
   size_t i;
 
-  fs = GNUNET_FS_start(cfg, "test-fs-search", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_DO_PROBES,
-                       GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  buf = GNUNET_malloc(FILESIZE);
+  fs = GNUNET_FS_start (cfg, "test-fs-search", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_DO_PROBES,
+                        GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
-  fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
-                                                   FILESIZE, buf, kuri, meta,
-                                                   GNUNET_NO, &bo);
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fi);
-  start = GNUNET_TIME_absolute_get();
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+  fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
+                                                    FILESIZE, buf, kuri, meta,
+                                                    GNUNET_NO, &bo);
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fi);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
-  timeout_task = GNUNET_SCHEDULER_add_delayed(LIFETIME,
-                                              &abort_error, NULL);
+    GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
+  timeout_task = GNUNET_SCHEDULER_add_delayed (LIFETIME,
+                                               &abort_error, NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-search-probes",
-                                   "test_fs_search_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-search-probes",
+                                    "test_fs_search_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_search_with_and.c b/src/fs/test_fs_search_with_and.c
index e43b8e25a..60ceb94ee 100644
--- a/src/fs/test_fs_search_with_and.c
+++ b/src/fs/test_fs_search_with_and.c
@@ -42,12 +42,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -58,7 +58,7 @@ static struct GNUNET_FS_SearchContext *search;
 
 static struct GNUNET_FS_PublishContext *publish;
 
-static struct GNUNET_SCHEDULER_Task * timeout_task;
+static struct GNUNET_SCHEDULER_Task *timeout_task;
 
 static int err;
 
@@ -66,150 +66,150 @@ static int processed_files;
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   if (NULL != timeout_task)
-    {
-      GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
 }
 
 
 static void
-abort_error(void *cls)
+abort_error (void *cls)
 {
-  fprintf(stderr,
-          "Timeout\n");
+  fprintf (stderr,
+           "Timeout\n");
   timeout_task = NULL;
   if (NULL != search)
-    {
-      GNUNET_FS_search_stop(search);
-      search = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (search);
+    search = NULL;
+  }
   if (NULL != publish)
-    {
-      GNUNET_FS_publish_stop(publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
   err = 1;
 }
 
 
 static void
-abort_search_task(void *cls)
+abort_search_task (void *cls)
 {
   if (NULL != search)
-    {
-      GNUNET_FS_search_stop(search);
-      search = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (search);
+    search = NULL;
+  }
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   struct GNUNET_FS_Uri *kuri;
 
   switch (event->status)
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    processed_files++;
+    if (processed_files == NUM_FILES)
     {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      processed_files++;
-      if (processed_files == NUM_FILES)
-        {
-          char *emsg = NULL;
-          kuri = GNUNET_FS_uri_ksk_create("+down_foo +down_bar", &emsg);
-          GNUNET_assert(kuri != NULL);
-
-          start = GNUNET_TIME_absolute_get();
-          search =
-            GNUNET_FS_search_start(fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
-                                   "search");
-          GNUNET_FS_uri_destroy(kuri);
-          GNUNET_assert(search != NULL);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Search complete.\n");
-      GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf(stderr, "Error searching file: %s\n",
-              event->value.search.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_search_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_START:
-      GNUNET_assert(search == NULL);
-      GNUNET_assert(0 == strcmp("search", event->value.search.cctx));
-      GNUNET_assert(1 == event->value.search.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
-      break;
-
-    case GNUNET_FS_STATUS_SEARCH_STOPPED:
-      GNUNET_assert(search == event->value.search.sc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    default:
-      fprintf(stderr, "Unexpected event: %d\n", event->status);
-      break;
+      char *emsg = NULL;
+      kuri = GNUNET_FS_uri_ksk_create ("+down_foo +down_bar", &emsg);
+      GNUNET_assert (kuri != NULL);
+
+      start = GNUNET_TIME_absolute_get ();
+      search =
+        GNUNET_FS_search_start (fs, kuri, 1, GNUNET_FS_SEARCH_OPTION_NONE,
+                                "search");
+      GNUNET_FS_uri_destroy (kuri);
+      GNUNET_assert (search != NULL);
     }
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Search complete.\n");
+    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr, "Error searching file: %s\n",
+             event->value.search.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_search_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_START:
+    GNUNET_assert (search == NULL);
+    GNUNET_assert (0 == strcmp ("search", event->value.search.cctx));
+    GNUNET_assert (1 == event->value.search.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED:
+    break;
+
+  case GNUNET_FS_STATUS_SEARCH_STOPPED:
+    GNUNET_assert (search == event->value.search.sc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  default:
+    fprintf (stderr, "Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -223,47 +223,47 @@ run(void *cls,
   size_t i;
   size_t j;
 
-  fs = GNUNET_FS_start(cfg, "test-fs-search", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
+  fs = GNUNET_FS_start (cfg, "test-fs-search", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
 
   processed_files = 0;
   for (j = 0; j < NUM_FILES; j++)
-    {
-      buf = GNUNET_malloc(FILESIZE);
-      for (i = 0; i < FILESIZE; i++)
-        buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-      meta = GNUNET_CONTAINER_meta_data_create();
-      kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
-      bo.content_priority = 42;
-      bo.anonymity_level = 1;
-      bo.replication_level = 0;
-      bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
-      fi = GNUNET_FS_file_information_create_from_data(fs, "publish-context",
-                                                       FILESIZE, buf, kuri, meta,
-                                                       GNUNET_NO, &bo);
-      GNUNET_FS_uri_destroy(kuri);
-      GNUNET_CONTAINER_meta_data_destroy(meta);
-      GNUNET_assert(NULL != fi);
-      start = GNUNET_TIME_absolute_get();
-      publish =
-        GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                                GNUNET_FS_PUBLISH_OPTION_NONE);
-      GNUNET_assert(publish != NULL);
-    }
-
-
-  timeout_task = GNUNET_SCHEDULER_add_delayed(LIFETIME,
-                                              &abort_error, NULL);
+  {
+    buf = GNUNET_malloc (FILESIZE);
+    for (i = 0; i < FILESIZE; i++)
+      buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+    meta = GNUNET_CONTAINER_meta_data_create ();
+    kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
+    bo.content_priority = 42;
+    bo.anonymity_level = 1;
+    bo.replication_level = 0;
+    bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+    fi = GNUNET_FS_file_information_create_from_data (fs, "publish-context",
+                                                      FILESIZE, buf, kuri, meta,
+                                                      GNUNET_NO, &bo);
+    GNUNET_FS_uri_destroy (kuri);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_assert (NULL != fi);
+    start = GNUNET_TIME_absolute_get ();
+    publish =
+      GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                               GNUNET_FS_PUBLISH_OPTION_NONE);
+    GNUNET_assert (publish != NULL);
+  }
+
+
+  timeout_task = GNUNET_SCHEDULER_add_delayed (LIFETIME,
+                                               &abort_error, NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-search-with-and",
-                                   "test_fs_search_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-search-with-and",
+                                    "test_fs_search_data.conf",
+                                    &run, NULL))
     return 1;
   return err;
 }
diff --git a/src/fs/test_fs_start_stop.c b/src/fs/test_fs_start_stop.c
index 4e3c17db0..1d6e27d62 100644
--- a/src/fs/test_fs_start_stop.c
+++ b/src/fs/test_fs_start_stop.c
@@ -30,32 +30,32 @@
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   struct GNUNET_FS_Handle *fs;
 
-  fs = GNUNET_FS_start(cfg, "test-fs-start-stop", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  GNUNET_FS_stop(fs);
+  fs = GNUNET_FS_start (cfg, "test-fs-start-stop", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  GNUNET_FS_stop (fs);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-start-stop",
-                                   "test_fs_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-start-stop",
+                                    "test_fs_data.conf",
+                                    &run, NULL))
     return 1;
   return 0;
 }
diff --git a/src/fs/test_fs_test_lib.c b/src/fs/test_fs_test_lib.c
index 7e27469cc..25b843e85 100644
--- a/src/fs/test_fs_test_lib.c
+++ b/src/fs/test_fs_test_lib.c
@@ -36,7 +36,7 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
 
 #define NUM_DAEMONS 2
 
@@ -50,74 +50,75 @@ static int ret;
 
 
 static void
-do_stop(void *cls)
+do_stop (void *cls)
 {
   char *fn = cls;
 
   if (0 ==
-      GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_add(start_time,
-                                                                  TIMEOUT)).rel_value_us)
-    {
-      GNUNET_break(0);
-      ret = 1;
-    }
+      GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
+                                                                    TIMEOUT)).
+      rel_value_us)
+  {
+    GNUNET_break (0);
+    ret = 1;
+  }
   else
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Finished download, shutting down\n");
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished download, shutting down\n");
+  }
   if (NULL != fn)
-    {
-      GNUNET_DISK_directory_remove(fn);
-      GNUNET_free(fn);
-    }
-  GNUNET_SCHEDULER_shutdown();
+  {
+    GNUNET_DISK_directory_remove (fn);
+    GNUNET_free (fn);
+  }
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
 static void
-do_download(void *cls,
-            const struct GNUNET_FS_Uri *uri,
-            const char *fn)
+do_download (void *cls,
+             const struct GNUNET_FS_Uri *uri,
+             const char *fn)
 {
   if (NULL == uri)
-    {
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_shutdown();
-      ret = 1;
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Downloading %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  start_time = GNUNET_TIME_absolute_get();
-  GNUNET_FS_TEST_download(the_peers[0],
-                          TIMEOUT, 1, SEED,
-                          uri,
-                          VERBOSE,
-                          &do_stop,
-                          (NULL == fn) ? NULL : GNUNET_strdup(fn));
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_shutdown ();
+    ret = 1;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Downloading %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  start_time = GNUNET_TIME_absolute_get ();
+  GNUNET_FS_TEST_download (the_peers[0],
+                           TIMEOUT, 1, SEED,
+                           uri,
+                           VERBOSE,
+                           &do_stop,
+                           (NULL == fn) ? NULL : GNUNET_strdup (fn));
 }
 
 
 static void
-do_publish(void *cls,
-           struct GNUNET_TESTBED_Operation *op,
-           const char *emsg)
+do_publish (void *cls,
+            struct GNUNET_TESTBED_Operation *op,
+            const char *emsg)
 {
-  GNUNET_TESTBED_operation_done(op);
+  GNUNET_TESTBED_operation_done (op);
   if (NULL != emsg)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect peers: %s\n", emsg);
-      GNUNET_break(0);
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  GNUNET_FS_TEST_publish(the_peers[0], TIMEOUT, 1, GNUNET_NO, FILESIZE, SEED,
-                         VERBOSE, &do_download, NULL);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to connect peers: %s\n", emsg);
+    GNUNET_break (0);
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  GNUNET_FS_TEST_publish (the_peers[0], TIMEOUT, 1, GNUNET_NO, FILESIZE, SEED,
+                          VERBOSE, &do_download, NULL);
 }
 
 
@@ -134,23 +135,23 @@ do_publish(void *cls,
  *          failed
  */
 static void
-run(void *cls,
-    struct GNUNET_TESTBED_RunHandle *h,
-    unsigned int num_peers,
-    struct GNUNET_TESTBED_Peer **peers,
-    unsigned int links_succeeded,
-    unsigned int links_failed)
+run (void *cls,
+     struct GNUNET_TESTBED_RunHandle *h,
+     unsigned int num_peers,
+     struct GNUNET_TESTBED_Peer **peers,
+     unsigned int links_succeeded,
+     unsigned int links_failed)
 {
   unsigned int i;
 
-  GNUNET_assert(NUM_DAEMONS == num_peers);
+  GNUNET_assert (NUM_DAEMONS == num_peers);
   for (i = 0; i < num_peers; i++)
     the_peers[i] = peers[i];
-  GNUNET_TESTBED_overlay_connect(NULL,
-                                 &do_publish,
-                                 NULL,
-                                 peers[0],
-                                 peers[1]);
+  GNUNET_TESTBED_overlay_connect (NULL,
+                                  &do_publish,
+                                  NULL,
+                                  peers[0],
+                                  peers[1]);
 }
 
 
@@ -162,15 +163,15 @@ run(void *cls,
  * @return 0 on success
  */
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  GNUNET_DISK_directory_remove("/tmp/gnunet-test-fs-lib/");
-  (void)GNUNET_TESTBED_test_run("test_fs_test_lib",
-                                "fs_test_lib_data.conf",
-                                NUM_DAEMONS,
-                                0, NULL, NULL,
-                                &run, NULL);
-  GNUNET_DISK_directory_remove("/tmp/gnunet-test-fs-lib/");
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
+  (void) GNUNET_TESTBED_test_run ("test_fs_test_lib",
+                                  "fs_test_lib_data.conf",
+                                  NUM_DAEMONS,
+                                  0, NULL, NULL,
+                                  &run, NULL);
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ret;
 }
 
diff --git a/src/fs/test_fs_unindex.c b/src/fs/test_fs_unindex.c
index 1c1cf6239..19b935dbf 100644
--- a/src/fs/test_fs_unindex.c
+++ b/src/fs/test_fs_unindex.c
@@ -37,12 +37,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -57,127 +57,127 @@ static char *fn;
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
-  GNUNET_FS_publish_stop(publish);
+  GNUNET_FS_publish_stop (publish);
   publish = NULL;
 }
 
 
 static void
-abort_unindex_task(void *cls)
+abort_unindex_task (void *cls)
 {
-  GNUNET_FS_unindex_stop(unindex);
+  GNUNET_FS_unindex_stop (unindex);
   unindex = NULL;
-  GNUNET_DISK_directory_remove(fn);
-  GNUNET_free(fn);
+  GNUNET_DISK_directory_remove (fn);
+  GNUNET_free (fn);
   fn = NULL;
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf("Publishing complete, %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024));
-      start = GNUNET_TIME_absolute_get();
-      unindex = GNUNET_FS_unindex_start(fs, fn, "unindex");
-      GNUNET_assert(unindex != NULL);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
-      printf("Unindex complete,  %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024));
-      GNUNET_SCHEDULER_add_now(&abort_unindex_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
-      GNUNET_assert(unindex == event->value.unindex.uc);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Unindex is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.unindex.completed,
-                 (unsigned long long)event->value.unindex.size,
-                 event->value.unindex.specifics.progress.depth,
-                 (unsigned long long)event->value.unindex.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_ERROR:
-      fprintf(stderr, "Error unindexing file: %s\n",
-              event->value.unindex.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_unindex_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_START:
-      GNUNET_assert(unindex == NULL);
-      GNUNET_assert(0 == strcmp("unindex", event->value.unindex.cctx));
-      GNUNET_assert(0 == strcmp(fn, event->value.unindex.filename));
-      GNUNET_assert(FILESIZE == event->value.unindex.size);
-      GNUNET_assert(0 == event->value.unindex.completed);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_STOPPED:
-      GNUNET_assert(unindex == event->value.unindex.uc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    default:
-      printf("Unexpected event: %d\n", event->status);
-      break;
-    }
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    printf ("Publishing complete, %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024));
+    start = GNUNET_TIME_absolute_get ();
+    unindex = GNUNET_FS_unindex_start (fs, fn, "unindex");
+    GNUNET_assert (unindex != NULL);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
+    printf ("Unindex complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024));
+    GNUNET_SCHEDULER_add_now (&abort_unindex_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    GNUNET_assert (unindex == event->value.unindex.uc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unindex is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.unindex.completed,
+                (unsigned long long) event->value.unindex.size,
+                event->value.unindex.specifics.progress.depth,
+                (unsigned long long) event->value.unindex.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_ERROR:
+    fprintf (stderr, "Error unindexing file: %s\n",
+             event->value.unindex.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_unindex_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_START:
+    GNUNET_assert (unindex == NULL);
+    GNUNET_assert (0 == strcmp ("unindex", event->value.unindex.cctx));
+    GNUNET_assert (0 == strcmp (fn, event->value.unindex.filename));
+    GNUNET_assert (FILESIZE == event->value.unindex.size);
+    GNUNET_assert (0 == event->value.unindex.completed);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_STOPPED:
+    GNUNET_assert (unindex == event->value.unindex.uc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *cfg,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *cfg,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -190,44 +190,44 @@ run(void *cls,
   size_t i;
   struct GNUNET_FS_BlockOptions bo;
 
-  fn = GNUNET_DISK_mktemp("gnunet-unindex-test-dst");
-  fs = GNUNET_FS_start(cfg, "test-fs-unindex", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  buf = GNUNET_malloc(FILESIZE);
+  fn = GNUNET_DISK_mktemp ("gnunet-unindex-test-dst");
+  fs = GNUNET_FS_start (cfg, "test-fs-unindex", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
-  fi = GNUNET_FS_file_information_create_from_file(fs, "publish-context", fn,
-                                                   kuri, meta, GNUNET_YES,
-                                                   &bo);
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fi);
-  start = GNUNET_TIME_absolute_get();
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+  fi = GNUNET_FS_file_information_create_from_file (fs, "publish-context", fn,
+                                                    kuri, meta, GNUNET_YES,
+                                                    &bo);
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fi);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
+    GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-unindex",
-                                   "test_fs_unindex_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-unindex",
+                                    "test_fs_unindex_data.conf",
+                                    &run, NULL))
     return 1;
   return 0;
 }
diff --git a/src/fs/test_fs_unindex_persistence.c b/src/fs/test_fs_unindex_persistence.c
index 7deebb95b..28079b842 100644
--- a/src/fs/test_fs_unindex_persistence.c
+++ b/src/fs/test_fs_unindex_persistence.c
@@ -36,12 +36,12 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 60)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
 
 /**
  * How long should our test-content live?
  */
-#define LIFETIME GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 15)
+#define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 
 static struct GNUNET_TIME_Absolute start;
@@ -58,40 +58,40 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 
 static void
-abort_publish_task(void *cls)
+abort_publish_task (void *cls)
 {
-  GNUNET_FS_publish_stop(publish);
+  GNUNET_FS_publish_stop (publish);
   publish = NULL;
 }
 
 
 static void
-abort_unindex_task(void *cls)
+abort_unindex_task (void *cls)
 {
   if (unindex != NULL)
-    {
-      GNUNET_FS_unindex_stop(unindex);
-      unindex = NULL;
-    }
+  {
+    GNUNET_FS_unindex_stop (unindex);
+    unindex = NULL;
+  }
   if (fn != NULL)
-    {
-      GNUNET_DISK_directory_remove(fn);
-      GNUNET_free(fn);
-      fn = NULL;
-    }
+  {
+    GNUNET_DISK_directory_remove (fn);
+    GNUNET_free (fn);
+    fn = NULL;
+  }
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event);
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task(void *cls)
+restart_fs_task (void *cls)
 {
-  GNUNET_FS_stop(fs);
-  fs = GNUNET_FS_start(cfg, "test-fs-unindex-persistence", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
+  GNUNET_FS_stop (fs);
+  fs = GNUNET_FS_start (cfg, "test-fs-unindex-persistence", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -103,7 +103,7 @@ restart_fs_task(void *cls)
  * @param ev type of the event to consider
  */
 static void
-consider_restart(int ev)
+consider_restart (int ev)
 {
   static int prev[32];
   static int off;
@@ -113,140 +113,140 @@ consider_restart(int ev)
     if (prev[i] == ev)
       return;
   prev[off++] = ev;
-  GNUNET_SCHEDULER_add_with_priority(GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                     &restart_fs_task, NULL);
+  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
+                                      &restart_fs_task, NULL);
 }
 
 
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   switch (event->status)
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.publish.completed,
+                (unsigned long long) event->value.publish.size,
+                event->value.publish.specifics.progress.depth,
+                (unsigned long long) event->value.publish.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    printf ("Publishing complete, %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024));
+    start = GNUNET_TIME_absolute_get ();
+    unindex = GNUNET_FS_unindex_start (fs, fn, "unindex");
+    GNUNET_assert (unindex != NULL);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
+    printf ("Unindex complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000000LL
+                                  / (1
+                                     + GNUNET_TIME_absolute_get_duration
+                                       (start).rel_value_us) / 1024));
+    GNUNET_SCHEDULER_add_now (&abort_unindex_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    consider_restart (event->status);
+    GNUNET_assert (unindex == event->value.unindex.uc);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Unindex is progressing (%llu/%llu at level %u off %llu)...\n",
+                (unsigned long long) event->value.unindex.completed,
+                (unsigned long long) event->value.unindex.size,
+                event->value.unindex.specifics.progress.depth,
+                (unsigned long long) event->value.unindex.specifics.
+                progress.offset);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
+    if (event->value.publish.pc == publish)
+      publish = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_RESUME:
+    if (NULL == publish)
     {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Publish is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.publish.completed,
-                 (unsigned long long)event->value.publish.size,
-                 event->value.publish.specifics.progress.depth,
-                 (unsigned long long)event->value.publish.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf("Publishing complete, %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024));
-      start = GNUNET_TIME_absolute_get();
-      unindex = GNUNET_FS_unindex_start(fs, fn, "unindex");
-      GNUNET_assert(unindex != NULL);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
-      printf("Unindex complete,  %llu kbps.\n",
-             (unsigned long long)(FILESIZE * 1000000LL /
-                                  (1 +
-                                   GNUNET_TIME_absolute_get_duration
-                                     (start).rel_value_us) / 1024));
-      GNUNET_SCHEDULER_add_now(&abort_unindex_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
-      consider_restart(event->status);
-      GNUNET_assert(unindex == event->value.unindex.uc);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Unindex is progressing (%llu/%llu at level %u off %llu)...\n",
-                 (unsigned long long)event->value.unindex.completed,
-                 (unsigned long long)event->value.unindex.size,
-                 event->value.unindex.specifics.progress.depth,
-                 (unsigned long long)event->value.unindex.specifics.
-                 progress.offset);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_SUSPEND:
-      if (event->value.publish.pc == publish)
-        publish = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_RESUME:
-      if (NULL == publish)
-        {
-          publish = event->value.publish.pc;
-          return "publish-context";
-        }
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_SUSPEND:
-      GNUNET_assert(event->value.unindex.uc == unindex);
-      unindex = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_RESUME:
-      GNUNET_assert(NULL == unindex);
-      unindex = event->value.unindex.uc;
-      return "unindex";
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr, "Error publishing file: %s\n",
-              event->value.publish.specifics.error.message);
-      GNUNET_break(0);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_ERROR:
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Error unindexing file: %s\n",
-                 event->value.unindex.specifics.error.message);
-      GNUNET_SCHEDULER_add_now(&abort_unindex_task, NULL);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      GNUNET_assert(0 == strcmp("publish-context", event->value.publish.cctx));
-      GNUNET_assert(NULL == event->value.publish.pctx);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(0 == event->value.publish.completed);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_assert(publish == event->value.publish.pc);
-      GNUNET_assert(FILESIZE == event->value.publish.size);
-      GNUNET_assert(1 == event->value.publish.anonymity);
-      GNUNET_FS_stop(fs);
-      fs = NULL;
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_START:
-      consider_restart(event->status);
-      GNUNET_assert(unindex == NULL);
-      GNUNET_assert(0 == strcmp("unindex", event->value.unindex.cctx));
-      GNUNET_assert(0 == strcmp(fn, event->value.unindex.filename));
-      GNUNET_assert(FILESIZE == event->value.unindex.size);
-      GNUNET_assert(0 == event->value.unindex.completed);
-      break;
-
-    case GNUNET_FS_STATUS_UNINDEX_STOPPED:
-      GNUNET_assert(unindex == event->value.unindex.uc);
-      GNUNET_SCHEDULER_add_now(&abort_publish_task, NULL);
-      break;
-
-    default:
-      printf("Unexpected event: %d\n", event->status);
-      break;
+      publish = event->value.publish.pc;
+      return "publish-context";
     }
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_SUSPEND:
+    GNUNET_assert (event->value.unindex.uc == unindex);
+    unindex = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_RESUME:
+    GNUNET_assert (NULL == unindex);
+    unindex = event->value.unindex.uc;
+    return "unindex";
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr, "Error publishing file: %s\n",
+             event->value.publish.specifics.error.message);
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_ERROR:
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Error unindexing file: %s\n",
+                event->value.unindex.specifics.error.message);
+    GNUNET_SCHEDULER_add_now (&abort_unindex_task, NULL);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    GNUNET_assert (0 == strcmp ("publish-context", event->value.publish.cctx));
+    GNUNET_assert (NULL == event->value.publish.pctx);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (0 == event->value.publish.completed);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_assert (publish == event->value.publish.pc);
+    GNUNET_assert (FILESIZE == event->value.publish.size);
+    GNUNET_assert (1 == event->value.publish.anonymity);
+    GNUNET_FS_stop (fs);
+    fs = NULL;
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_START:
+    consider_restart (event->status);
+    GNUNET_assert (unindex == NULL);
+    GNUNET_assert (0 == strcmp ("unindex", event->value.unindex.cctx));
+    GNUNET_assert (0 == strcmp (fn, event->value.unindex.filename));
+    GNUNET_assert (FILESIZE == event->value.unindex.size);
+    GNUNET_assert (0 == event->value.unindex.completed);
+    break;
+
+  case GNUNET_FS_STATUS_UNINDEX_STOPPED:
+    GNUNET_assert (unindex == event->value.unindex.uc);
+    GNUNET_SCHEDULER_add_now (&abort_publish_task, NULL);
+    break;
+
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-run(void *cls,
-    const struct GNUNET_CONFIGURATION_Handle *c,
-    struct GNUNET_TESTING_Peer *peer)
+run (void *cls,
+     const struct GNUNET_CONFIGURATION_Handle *c,
+     struct GNUNET_TESTING_Peer *peer)
 {
   const char *keywords[] = {
     "down_foo",
@@ -260,44 +260,44 @@ run(void *cls,
   struct GNUNET_FS_BlockOptions bo;
 
   cfg = c;
-  fn = GNUNET_DISK_mktemp("gnunet-unindex-test-dst");
-  fs = GNUNET_FS_start(cfg, "test-fs-unindex-persistence", &progress_cb, NULL,
-                       GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
-  GNUNET_assert(NULL != fs);
-  buf = GNUNET_malloc(FILESIZE);
+  fn = GNUNET_DISK_mktemp ("gnunet-unindex-test-dst");
+  fs = GNUNET_FS_start (cfg, "test-fs-unindex-persistence", &progress_cb, NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
+  buf = GNUNET_malloc (FILESIZE);
   for (i = 0; i < FILESIZE; i++)
-    buf[i] = GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK, 256);
-  GNUNET_assert(FILESIZE ==
-                GNUNET_DISK_fn_write(fn, buf, FILESIZE,
-                                     GNUNET_DISK_PERM_USER_READ |
-                                     GNUNET_DISK_PERM_USER_WRITE));
-  GNUNET_free(buf);
-  meta = GNUNET_CONTAINER_meta_data_create();
-  kuri = GNUNET_FS_uri_ksk_create_from_args(2, keywords);
+    buf[i] = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 256);
+  GNUNET_assert (FILESIZE ==
+                 GNUNET_DISK_fn_write (fn, buf, FILESIZE,
+                                       GNUNET_DISK_PERM_USER_READ
+                                       | GNUNET_DISK_PERM_USER_WRITE));
+  GNUNET_free (buf);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  kuri = GNUNET_FS_uri_ksk_create_from_args (2, keywords);
   bo.content_priority = 42;
   bo.anonymity_level = 1;
   bo.replication_level = 0;
-  bo.expiration_time = GNUNET_TIME_relative_to_absolute(LIFETIME);
-  fi = GNUNET_FS_file_information_create_from_file(fs, "publish-context", fn,
-                                                   kuri, meta, GNUNET_YES,
-                                                   &bo);
-  GNUNET_FS_uri_destroy(kuri);
-  GNUNET_CONTAINER_meta_data_destroy(meta);
-  GNUNET_assert(NULL != fi);
-  start = GNUNET_TIME_absolute_get();
+  bo.expiration_time = GNUNET_TIME_relative_to_absolute (LIFETIME);
+  fi = GNUNET_FS_file_information_create_from_file (fs, "publish-context", fn,
+                                                    kuri, meta, GNUNET_YES,
+                                                    &bo);
+  GNUNET_FS_uri_destroy (kuri);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_assert (NULL != fi);
+  start = GNUNET_TIME_absolute_get ();
   publish =
-    GNUNET_FS_publish_start(fs, fi, NULL, NULL, NULL,
-                            GNUNET_FS_PUBLISH_OPTION_NONE);
-  GNUNET_assert(publish != NULL);
+    GNUNET_FS_publish_start (fs, fi, NULL, NULL, NULL,
+                             GNUNET_FS_PUBLISH_OPTION_NONE);
+  GNUNET_assert (publish != NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
-  if (0 != GNUNET_TESTING_peer_run("test-fs-unindex-persistence",
-                                   "test_fs_unindex_data.conf",
-                                   &run, NULL))
+  if (0 != GNUNET_TESTING_peer_run ("test-fs-unindex-persistence",
+                                    "test_fs_unindex_data.conf",
+                                    &run, NULL))
     return 1;
   return 0;
 }
diff --git a/src/fs/test_fs_uri.c b/src/fs/test_fs_uri.c
index 3cbbc27d3..0602d8318 100644
--- a/src/fs/test_fs_uri.c
+++ b/src/fs/test_fs_uri.c
@@ -29,52 +29,52 @@
 
 
 static int
-testKeyword()
+testKeyword ()
 {
   char *uri;
   struct GNUNET_FS_Uri *ret;
   char *emsg;
 
-  if (NULL != (ret = GNUNET_FS_uri_parse("gnunet://fs/ksk/++", &emsg)))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(emsg);
-  ret = GNUNET_FS_uri_parse("gnunet://fs/ksk/foo+bar", &emsg);
+  if (NULL != (ret = GNUNET_FS_uri_parse ("gnunet://fs/ksk/++", &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (emsg);
+  ret = GNUNET_FS_uri_parse ("gnunet://fs/ksk/foo+bar", &emsg);
   if (NULL == ret)
-    {
-      GNUNET_free(emsg);
-      GNUNET_assert(0);
-    }
-  if (!GNUNET_FS_uri_test_ksk(ret))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
+  {
+    GNUNET_free (emsg);
+    GNUNET_assert (0);
+  }
+  if (! GNUNET_FS_uri_test_ksk (ret))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
   if ((2 != ret->data.ksk.keywordCount) ||
-      (0 != strcmp(" foo", ret->data.ksk.keywords[0])) ||
-      (0 != strcmp(" bar", ret->data.ksk.keywords[1])))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
+      (0 != strcmp (" foo", ret->data.ksk.keywords[0])) ||
+      (0 != strcmp (" bar", ret->data.ksk.keywords[1])))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
 
-  uri = GNUNET_FS_uri_to_string(ret);
-  if (0 != strcmp(uri, "gnunet://fs/ksk/foo+bar"))
-    {
-      GNUNET_free(uri);
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(uri);
-  GNUNET_FS_uri_destroy(ret);
+  uri = GNUNET_FS_uri_to_string (ret);
+  if (0 != strcmp (uri, "gnunet://fs/ksk/foo+bar"))
+  {
+    GNUNET_free (uri);
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (uri);
+  GNUNET_FS_uri_destroy (ret);
   return 0;
 }
 
 
 static int
-testLocation()
+testLocation ()
 {
   struct GNUNET_FS_Uri *uri;
   char *uric;
@@ -85,70 +85,71 @@ testLocation()
 
   baseURI =
     GNUNET_FS_uri_parse
-      ("gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.15999",
+    (
+      "gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.15999",
       &emsg);
-  GNUNET_assert(baseURI != NULL);
-  GNUNET_assert(emsg == NULL);
-  pk = GNUNET_CRYPTO_eddsa_key_create();
-  uri = GNUNET_FS_uri_loc_create(baseURI,
-                                 pk,
-                                 GNUNET_TIME_absolute_get());
-  GNUNET_free(pk);
+  GNUNET_assert (baseURI != NULL);
+  GNUNET_assert (emsg == NULL);
+  pk = GNUNET_CRYPTO_eddsa_key_create ();
+  uri = GNUNET_FS_uri_loc_create (baseURI,
+                                  pk,
+                                  GNUNET_TIME_absolute_get ());
+  GNUNET_free (pk);
   if (NULL == uri)
-    {
-      GNUNET_break(0);
-      GNUNET_FS_uri_destroy(baseURI);
-      return 1;
-    }
-  if (!GNUNET_FS_uri_test_loc(uri))
-    {
-      GNUNET_break(0);
-      GNUNET_FS_uri_destroy(uri);
-      GNUNET_FS_uri_destroy(baseURI);
-      return 1;
-    }
-  uri2 = GNUNET_FS_uri_loc_get_uri(uri);
-  if (!GNUNET_FS_uri_test_equal(baseURI, uri2))
-    {
-      GNUNET_break(0);
-      GNUNET_FS_uri_destroy(uri);
-      GNUNET_FS_uri_destroy(uri2);
-      GNUNET_FS_uri_destroy(baseURI);
-      return 1;
-    }
-  GNUNET_FS_uri_destroy(uri2);
-  GNUNET_FS_uri_destroy(baseURI);
-  uric = GNUNET_FS_uri_to_string(uri);
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (baseURI);
+    return 1;
+  }
+  if (! GNUNET_FS_uri_test_loc (uri))
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_FS_uri_destroy (baseURI);
+    return 1;
+  }
+  uri2 = GNUNET_FS_uri_loc_get_uri (uri);
+  if (! GNUNET_FS_uri_test_equal (baseURI, uri2))
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_FS_uri_destroy (uri2);
+    GNUNET_FS_uri_destroy (baseURI);
+    return 1;
+  }
+  GNUNET_FS_uri_destroy (uri2);
+  GNUNET_FS_uri_destroy (baseURI);
+  uric = GNUNET_FS_uri_to_string (uri);
 #if 0
   /* not for the faint of heart: */
-  printf("URI: `%s'\n", uric);
+  printf ("URI: `%s'\n", uric);
 #endif
-  uri2 = GNUNET_FS_uri_parse(uric, &emsg);
-  GNUNET_free(uric);
+  uri2 = GNUNET_FS_uri_parse (uric, &emsg);
+  GNUNET_free (uric);
   if (uri2 == NULL)
-    {
-      fprintf(stderr, "URI parsing failed: %s\n", emsg);
-      GNUNET_break(0);
-      GNUNET_FS_uri_destroy(uri);
-      GNUNET_free(emsg);
-      return 1;
-    }
-  GNUNET_assert(NULL == emsg);
-  if (GNUNET_YES != GNUNET_FS_uri_test_equal(uri, uri2))
-    {
-      GNUNET_break(0);
-      GNUNET_FS_uri_destroy(uri);
-      GNUNET_FS_uri_destroy(uri2);
-      return 1;
-    }
-  GNUNET_FS_uri_destroy(uri2);
-  GNUNET_FS_uri_destroy(uri);
+  {
+    fprintf (stderr, "URI parsing failed: %s\n", emsg);
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_free (emsg);
+    return 1;
+  }
+  GNUNET_assert (NULL == emsg);
+  if (GNUNET_YES != GNUNET_FS_uri_test_equal (uri, uri2))
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_FS_uri_destroy (uri2);
+    return 1;
+  }
+  GNUNET_FS_uri_destroy (uri2);
+  GNUNET_FS_uri_destroy (uri);
   return 0;
 }
 
 
 static int
-testNamespace(int i)
+testNamespace (int i)
 {
   char *uri;
   struct GNUNET_FS_Uri *ret;
@@ -161,71 +162,74 @@ testNamespace(int i)
 
   if (NULL !=
       (ret =
-         GNUNET_FS_uri_parse("gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3VUK",
-                             &emsg)))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(emsg);
+         GNUNET_FS_uri_parse (
+           "gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3VUK",
+           &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (emsg);
   if (NULL !=
       (ret =
          GNUNET_FS_uri_parse
-           ("gnunet://fs/sks/XQHH4R288W26EBV369F6RCE0PJVJTX2Y74Q2FJPMPGA31HJX2JG/this", &emsg)))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(emsg);
-  if (NULL != (ret = GNUNET_FS_uri_parse("gnunet://fs/sks/test", &emsg)))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(emsg);
-  ph = GNUNET_CRYPTO_ecdsa_key_create();
-  GNUNET_CRYPTO_ecdsa_key_get_public(ph, &id);
-  sret = GNUNET_STRINGS_data_to_string(&id, sizeof(id),
-                                       ubuf, sizeof(ubuf) - 1);
-  GNUNET_assert(NULL != sret);
+         (
+           "gnunet://fs/sks/XQHH4R288W26EBV369F6RCE0PJVJTX2Y74Q2FJPMPGA31HJX2JG/this",
+           &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (emsg);
+  if (NULL != (ret = GNUNET_FS_uri_parse ("gnunet://fs/sks/test", &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (emsg);
+  ph = GNUNET_CRYPTO_ecdsa_key_create ();
+  GNUNET_CRYPTO_ecdsa_key_get_public (ph, &id);
+  sret = GNUNET_STRINGS_data_to_string (&id, sizeof(id),
+                                        ubuf, sizeof(ubuf) - 1);
+  GNUNET_assert (NULL != sret);
   sret[0] = '\0';
-  GNUNET_snprintf(buf, sizeof(buf),
-                  "gnunet://fs/sks/%s/test",
-                  ubuf);
-  ret = GNUNET_FS_uri_parse(buf, &emsg);
+  GNUNET_snprintf (buf, sizeof(buf),
+                   "gnunet://fs/sks/%s/test",
+                   ubuf);
+  ret = GNUNET_FS_uri_parse (buf, &emsg);
   if (NULL == ret)
-    {
-      GNUNET_free(emsg);
-      GNUNET_assert(0);
-    }
-  if (GNUNET_FS_uri_test_ksk(ret))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  if (!GNUNET_FS_uri_test_sks(ret))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
+  {
+    GNUNET_free (emsg);
+    GNUNET_assert (0);
+  }
+  if (GNUNET_FS_uri_test_ksk (ret))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  if (! GNUNET_FS_uri_test_sks (ret))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
 
-  uri = GNUNET_FS_uri_to_string(ret);
+  uri = GNUNET_FS_uri_to_string (ret);
   if (0 !=
-      strcmp(uri,
-             buf))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_free(uri);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(uri);
-  GNUNET_FS_uri_destroy(ret);
+      strcmp (uri,
+              buf))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_free (uri);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (uri);
+  GNUNET_FS_uri_destroy (ret);
   return 0;
 }
 
 
 static int
-testFile(int i)
+testFile (int i)
 {
   char *uri;
   struct GNUNET_FS_Uri *ret;
@@ -234,92 +238,96 @@ testFile(int i)
   if (NULL !=
       (ret =
          GNUNET_FS_uri_parse
-           ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H00000440000.42",
+         (
+           "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H00000440000.42",
            &emsg)))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(emsg);
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (emsg);
   if (NULL !=
       (ret =
          GNUNET_FS_uri_parse
-           ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000",
+         (
+           "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000",
            &emsg)))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(emsg);
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (emsg);
   if (NULL !=
       (ret =
          GNUNET_FS_uri_parse
-           ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.FGH",
+         (
+           "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.FGH",
            &emsg)))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(emsg);
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (emsg);
   ret =
     GNUNET_FS_uri_parse
-      ("gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.42",
+    (
+      "gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.42",
       &emsg);
   if (ret == NULL)
-    {
-      GNUNET_free(emsg);
-      GNUNET_assert(0);
-    }
-  if (GNUNET_FS_uri_test_ksk(ret))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  if (GNUNET_FS_uri_test_sks(ret))
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  if (GNUNET_ntohll(ret->data.chk.file_length) != 42)
-    {
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
+  {
+    GNUNET_free (emsg);
+    GNUNET_assert (0);
+  }
+  if (GNUNET_FS_uri_test_ksk (ret))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  if (GNUNET_FS_uri_test_sks (ret))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  if (GNUNET_ntohll (ret->data.chk.file_length) != 42)
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
 
-  uri = GNUNET_FS_uri_to_string(ret);
+  uri = GNUNET_FS_uri_to_string (ret);
   if (0 !=
-      strcmp(uri,
-             "gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.42"))
-    {
-      GNUNET_free(uri);
-      GNUNET_FS_uri_destroy(ret);
-      GNUNET_assert(0);
-    }
-  GNUNET_free(uri);
-  GNUNET_FS_uri_destroy(ret);
+      strcmp (uri,
+              "gnunet://fs/chk/4QZP479A9SKGFNMQ2ZBCYE71YV2QMTVGWTVPB6A10ASVCKXDHB05DKPSC7ZF6E9P9W1VE47394EQY7NXA47Q6R35M7P1MJPGP59D1Z8.D54QD1K5XCG5878T6YZ19AM60MQ6FC0YNVK7QY08KK0KM0FJJ3KQWYG112FN5T07KN7J0X35DF6WVBT9B8ZMZ3X2BXJ22X3KFQ6MV2G.42"))
+  {
+    GNUNET_free (uri);
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_assert (0);
+  }
+  GNUNET_free (uri);
+  GNUNET_FS_uri_destroy (ret);
   return 0;
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup("test_fs_uri",
-                   "WARNING",
-                   NULL);
-  failureCount += testKeyword();
-  failureCount += testLocation();
+  GNUNET_log_setup ("test_fs_uri",
+                    "WARNING",
+                    NULL);
+  failureCount += testKeyword ();
+  failureCount += testLocation ();
   for (i = 0; i < 255; i++)
-    {
-      /* fprintf (stderr, "%s",  "."); */
-      failureCount += testNamespace(i);
-      failureCount += testFile(i);
-    }
+  {
+    /* fprintf (stderr, "%s",  "."); */
+    failureCount += testNamespace (i);
+    failureCount += testFile (i);
+  }
   /* fprintf (stderr, "%s",  "\n"); */
-  GNUNET_DISK_directory_remove("/tmp/gnunet-test-fs-uri");
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-uri");
   if (failureCount != 0)
     return 1;
   return 0;
diff --git a/src/fs/test_gnunet_service_fs_migration.c b/src/fs/test_gnunet_service_fs_migration.c
index c56e89e11..9842f8a83 100644
--- a/src/fs/test_gnunet_service_fs_migration.c
+++ b/src/fs/test_gnunet_service_fs_migration.c
@@ -37,12 +37,13 @@
 /**
  * How long until we give up on transmitting the message?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 120)
 
 /**
  * How long do we give the peers for content migration?
  */
-#define MIGRATION_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 90)
+#define MIGRATION_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \
+                                                       90)
 
 #define SEED 42
 
@@ -55,7 +56,8 @@ static struct GNUNET_TIME_Absolute start_time;
 static struct GNUNET_TESTBED_Operation *op;
 
 
-struct DownloadContext {
+struct DownloadContext
+{
   char *fn;
 
   struct GNUNET_FS_Uri *uri;
@@ -63,154 +65,155 @@ struct DownloadContext {
 
 
 static void
-do_stop(void *cls)
+do_stop (void *cls)
 {
   struct GNUNET_TIME_Relative del;
   char *fancy;
 
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
   if (0 ==
-      GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_add(start_time,
-                                                                  TIMEOUT)).rel_value_us)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Timeout during download, shutting down with error\n");
-      ok = 1;
-    }
+      GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
+                                                                    TIMEOUT)).
+      rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during download, shutting down with error\n");
+    ok = 1;
+  }
   else
-    {
-      del = GNUNET_TIME_absolute_get_duration(start_time);
-      if (del.rel_value_us == 0)
-        del.rel_value_us = 1;
-      fancy =
-        GNUNET_STRINGS_byte_size_fancy(((unsigned long long)FILESIZE) *
-                                       1000000LL / del.rel_value_us);
-      fprintf(stdout,
-              "Download speed was %s/s\n",
-              fancy);
-      GNUNET_free(fancy);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Finished download, shutting down\n");
-    }
+  {
+    del = GNUNET_TIME_absolute_get_duration (start_time);
+    if (del.rel_value_us == 0)
+      del.rel_value_us = 1;
+    fancy =
+      GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE)
+                                      * 1000000LL / del.rel_value_us);
+    fprintf (stdout,
+             "Download speed was %s/s\n",
+             fancy);
+    GNUNET_free (fancy);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished download, shutting down\n");
+  }
 }
 
 
 static void
-do_download(void *cls,
-            const char *emsg)
+do_download (void *cls,
+             const char *emsg)
 {
   struct DownloadContext *dc = cls;
   struct GNUNET_FS_Uri *uri = dc->uri;
 
-  GNUNET_TESTBED_operation_done(op);
+  GNUNET_TESTBED_operation_done (op);
   op = NULL;
   if (NULL != dc->fn)
-    {
-      GNUNET_DISK_directory_remove(dc->fn);
-      GNUNET_free(dc->fn);
-    }
-  GNUNET_free(dc);
+  {
+    GNUNET_DISK_directory_remove (dc->fn);
+    GNUNET_free (dc->fn);
+  }
+  GNUNET_free (dc);
   if (NULL != emsg)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Failed to stop source daemon: %s\n",
-                 emsg);
-      GNUNET_FS_uri_destroy(uri);
-      ok = 1;
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Downloading %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  start_time = GNUNET_TIME_absolute_get();
-  GNUNET_FS_TEST_download(daemons[0],
-                          TIMEOUT,
-                          1,
-                          SEED,
-                          uri,
-                          VERBOSE,
-                          &do_stop,
-                          NULL);
-  GNUNET_FS_uri_destroy(uri);
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to stop source daemon: %s\n",
+                emsg);
+    GNUNET_FS_uri_destroy (uri);
+    ok = 1;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Downloading %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  start_time = GNUNET_TIME_absolute_get ();
+  GNUNET_FS_TEST_download (daemons[0],
+                           TIMEOUT,
+                           1,
+                           SEED,
+                           uri,
+                           VERBOSE,
+                           &do_stop,
+                           NULL);
+  GNUNET_FS_uri_destroy (uri);
 }
 
 
 static void
-stop_source_peer(void *cls)
+stop_source_peer (void *cls)
 {
   struct DownloadContext *dc = cls;
 
   /* FIXME: We should not interact with testbed when shutting down */
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Stopping source peer\n");
-  op = GNUNET_TESTBED_peer_stop(NULL,
-                                daemons[1],
-                                &do_download, dc);
-  GNUNET_assert(NULL != op);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Stopping source peer\n");
+  op = GNUNET_TESTBED_peer_stop (NULL,
+                                 daemons[1],
+                                 &do_download, dc);
+  GNUNET_assert (NULL != op);
 }
 
 
 static void
-do_wait(void *cls,
-        const struct GNUNET_FS_Uri *uri,
-        const char *fn)
+do_wait (void *cls,
+         const struct GNUNET_FS_Uri *uri,
+         const char *fn)
 {
   struct DownloadContext *dc;
 
   if (NULL == uri)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Waiting to allow content to migrate\n");
-  dc = GNUNET_new(struct DownloadContext);
-  dc->uri = GNUNET_FS_uri_dup(uri);
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Waiting to allow content to migrate\n");
+  dc = GNUNET_new (struct DownloadContext);
+  dc->uri = GNUNET_FS_uri_dup (uri);
   if (NULL != fn)
-    dc->fn = GNUNET_strdup(fn);
-  (void)GNUNET_SCHEDULER_add_delayed(MIGRATION_DELAY,
-                                     &stop_source_peer,
-                                     dc);
+    dc->fn = GNUNET_strdup (fn);
+  (void) GNUNET_SCHEDULER_add_delayed (MIGRATION_DELAY,
+                                       &stop_source_peer,
+                                       dc);
 }
 
 
 static void
-do_publish(void *cls,
-           struct GNUNET_TESTBED_RunHandle *h,
-           unsigned int num_peers,
-           struct GNUNET_TESTBED_Peer **peers,
-           unsigned int links_succeeded,
-           unsigned int links_failed)
+do_publish (void *cls,
+            struct GNUNET_TESTBED_RunHandle *h,
+            unsigned int num_peers,
+            struct GNUNET_TESTBED_Peer **peers,
+            unsigned int links_succeeded,
+            unsigned int links_failed)
 {
   unsigned int i;
 
-  GNUNET_assert(2 == num_peers);
+  GNUNET_assert (2 == num_peers);
   for (i = 0; i < num_peers; i++)
     daemons[i] = peers[i];
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Publishing %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  GNUNET_FS_TEST_publish(daemons[1], TIMEOUT, 1, GNUNET_NO,
-                         FILESIZE, SEED,
-                         VERBOSE, &do_wait, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Publishing %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  GNUNET_FS_TEST_publish (daemons[1], TIMEOUT, 1, GNUNET_NO,
+                          FILESIZE, SEED,
+                          VERBOSE, &do_wait, NULL);
 }
 
 
 int
-main(int argc,
-     char *argv[])
+main (int argc,
+      char *argv[])
 {
-  (void)GNUNET_TESTBED_test_run("test-gnunet-service-fs-migration",
-                                "fs_test_lib_data.conf",
-                                2,
-                                0, NULL, NULL,
-                                &do_publish,
-                                NULL);
-  GNUNET_DISK_directory_remove("/tmp/test-gnunet-service-fs-migration/");
+  (void) GNUNET_TESTBED_test_run ("test-gnunet-service-fs-migration",
+                                  "fs_test_lib_data.conf",
+                                  2,
+                                  0, NULL, NULL,
+                                  &do_publish,
+                                  NULL);
+  GNUNET_DISK_directory_remove ("/tmp/test-gnunet-service-fs-migration/");
   return ok;
 }
 
diff --git a/src/fs/test_gnunet_service_fs_p2p.c b/src/fs/test_gnunet_service_fs_p2p.c
index eba4e112d..8d2ed144f 100644
--- a/src/fs/test_gnunet_service_fs_p2p.c
+++ b/src/fs/test_gnunet_service_fs_p2p.c
@@ -36,7 +36,7 @@
 /**
  * How long until we give up on the download?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300)
+#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
 
 #define NUM_DAEMONS 2
 
@@ -54,110 +54,111 @@ static struct GNUNET_TIME_Absolute start_time;
 
 
 static void
-do_stop(void *cls)
+do_stop (void *cls)
 {
   char *fn = cls;
   struct GNUNET_TIME_Relative del;
   char *fancy;
 
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_SCHEDULER_shutdown ();
   if (0 ==
-      GNUNET_TIME_absolute_get_remaining(GNUNET_TIME_absolute_add(start_time,
-                                                                  TIMEOUT)).rel_value_us)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Timeout during download, shutting down with error\n");
-      ok = 1;
-    }
+      GNUNET_TIME_absolute_get_remaining (GNUNET_TIME_absolute_add (start_time,
+                                                                    TIMEOUT)).
+      rel_value_us)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during download, shutting down with error\n");
+    ok = 1;
+  }
   else
-    {
-      del = GNUNET_TIME_absolute_get_duration(start_time);
-      if (0 == del.rel_value_us)
-        del.rel_value_us = 1;
-      fancy =
-        GNUNET_STRINGS_byte_size_fancy(((unsigned long long)FILESIZE) *
-                                       1000000LL / del.rel_value_us);
-      fprintf(stdout,
-              "Download speed was %s/s\n",
-              fancy);
-      GNUNET_free(fancy);
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Finished download, shutting down\n");
-    }
+  {
+    del = GNUNET_TIME_absolute_get_duration (start_time);
+    if (0 == del.rel_value_us)
+      del.rel_value_us = 1;
+    fancy =
+      GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE)
+                                      * 1000000LL / del.rel_value_us);
+    fprintf (stdout,
+             "Download speed was %s/s\n",
+             fancy);
+    GNUNET_free (fancy);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished download, shutting down\n");
+  }
   if (NULL != fn)
-    {
-      GNUNET_DISK_directory_remove(fn);
-      GNUNET_free(fn);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn);
+    GNUNET_free (fn);
+  }
 }
 
 
 static void
-do_download(void *cls, const struct GNUNET_FS_Uri *uri,
-            const char *fn)
+do_download (void *cls, const struct GNUNET_FS_Uri *uri,
+             const char *fn)
 {
   if (NULL == uri)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  start_time = GNUNET_TIME_absolute_get();
-  GNUNET_FS_TEST_download(daemons[0], TIMEOUT,
-                          anonymity_level, SEED, uri,
-                          VERBOSE, &do_stop,
-                          (NULL == fn)
-                          ? NULL
-                          : GNUNET_strdup(fn));
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Downloading %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  start_time = GNUNET_TIME_absolute_get ();
+  GNUNET_FS_TEST_download (daemons[0], TIMEOUT,
+                           anonymity_level, SEED, uri,
+                           VERBOSE, &do_stop,
+                           (NULL == fn)
+                           ? NULL
+                           : GNUNET_strdup (fn));
 }
 
 
 static void
-do_publish(void *cls,
-           struct GNUNET_TESTBED_RunHandle *h,
-           unsigned int num_peers,
-           struct GNUNET_TESTBED_Peer **peers,
-           unsigned int links_succeeded,
-           unsigned int links_failed)
+do_publish (void *cls,
+            struct GNUNET_TESTBED_RunHandle *h,
+            unsigned int num_peers,
+            struct GNUNET_TESTBED_Peer **peers,
+            unsigned int links_succeeded,
+            unsigned int links_failed)
 {
   unsigned int i;
 
-  if (NULL != strstr(progname, "cadet"))
+  if (NULL != strstr (progname, "cadet"))
     anonymity_level = 0;
   else
     anonymity_level = 1;
-  GNUNET_assert(NUM_DAEMONS == num_peers);
+  GNUNET_assert (NUM_DAEMONS == num_peers);
   for (i = 0; i < num_peers; i++)
     daemons[i] = peers[i];
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
-             (unsigned long long)FILESIZE);
-  GNUNET_FS_TEST_publish(daemons[1], TIMEOUT,
-                         anonymity_level, GNUNET_NO,
-                         FILESIZE, SEED,
-                         VERBOSE, &do_download, NULL);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publishing %llu bytes\n",
+              (unsigned long long) FILESIZE);
+  GNUNET_FS_TEST_publish (daemons[1], TIMEOUT,
+                          anonymity_level, GNUNET_NO,
+                          FILESIZE, SEED,
+                          VERBOSE, &do_download, NULL);
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   const char *config;
 
   progname = argv[0];
-  if (NULL != strstr(progname, "cadet"))
+  if (NULL != strstr (progname, "cadet"))
     config = "test_gnunet_service_fs_p2p_cadet.conf";
   else
     config = "fs_test_lib_data.conf";
-  (void)GNUNET_TESTBED_test_run("test-gnunet-service-fs-p2p",
-                                config,
-                                NUM_DAEMONS,
-                                0, NULL, NULL,
-                                &do_publish, NULL);
-  GNUNET_DISK_directory_remove("/tmp/gnunet-test-fs-lib/");
+  (void) GNUNET_TESTBED_test_run ("test-gnunet-service-fs-p2p",
+                                  config,
+                                  NUM_DAEMONS,
+                                  0, NULL, NULL,
+                                  &do_publish, NULL);
+  GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ok;
 }
 
diff --git a/src/fs/test_plugin_block_fs.c b/src/fs/test_plugin_block_fs.c
index 53f7304dd..305da2f18 100644
--- a/src/fs/test_plugin_block_fs.c
+++ b/src/fs/test_plugin_block_fs.c
@@ -27,64 +27,64 @@
 
 
 static int
-test_fs(struct GNUNET_BLOCK_Context *ctx)
+test_fs (struct GNUNET_BLOCK_Context *ctx)
 {
   struct GNUNET_HashCode key;
   char block[4];
 
-  memset(block, 1, sizeof(block));
+  memset (block, 1, sizeof(block));
   if (GNUNET_OK !=
-      GNUNET_BLOCK_get_key(ctx, GNUNET_BLOCK_TYPE_FS_DBLOCK, block,
-                           sizeof(block), &key))
+      GNUNET_BLOCK_get_key (ctx, GNUNET_BLOCK_TYPE_FS_DBLOCK, block,
+                            sizeof(block), &key))
     return 1;
   if (GNUNET_BLOCK_EVALUATION_OK_LAST !=
-      GNUNET_BLOCK_evaluate(ctx,
-                            GNUNET_BLOCK_TYPE_FS_DBLOCK,
-                            NULL,
-                            GNUNET_BLOCK_EO_NONE,
-                            &key,
-                            NULL, 0,
-                            block, sizeof(block)))
+      GNUNET_BLOCK_evaluate (ctx,
+                             GNUNET_BLOCK_TYPE_FS_DBLOCK,
+                             NULL,
+                             GNUNET_BLOCK_EO_NONE,
+                             &key,
+                             NULL, 0,
+                             block, sizeof(block)))
     return 2;
   if (GNUNET_BLOCK_EVALUATION_REQUEST_VALID !=
-      GNUNET_BLOCK_evaluate(ctx,
-                            GNUNET_BLOCK_TYPE_FS_DBLOCK,
-                            NULL,
-                            GNUNET_BLOCK_EO_NONE,
-                            &key,
-                            NULL, 0,
-                            NULL, 0))
+      GNUNET_BLOCK_evaluate (ctx,
+                             GNUNET_BLOCK_TYPE_FS_DBLOCK,
+                             NULL,
+                             GNUNET_BLOCK_EO_NONE,
+                             &key,
+                             NULL, 0,
+                             NULL, 0))
     return 4;
-  GNUNET_log_skip(1, GNUNET_NO);
+  GNUNET_log_skip (1, GNUNET_NO);
   if (GNUNET_BLOCK_EVALUATION_REQUEST_INVALID !=
-      GNUNET_BLOCK_evaluate(ctx,
-                            GNUNET_BLOCK_TYPE_FS_DBLOCK,
-                            NULL,
-                            GNUNET_BLOCK_EO_NONE,
-                            &key,
-                            "bogus", 5,
-                            NULL, 0))
+      GNUNET_BLOCK_evaluate (ctx,
+                             GNUNET_BLOCK_TYPE_FS_DBLOCK,
+                             NULL,
+                             GNUNET_BLOCK_EO_NONE,
+                             &key,
+                             "bogus", 5,
+                             NULL, 0))
     return 8;
-  GNUNET_log_skip(0, GNUNET_YES);
+  GNUNET_log_skip (0, GNUNET_YES);
   return 0;
 }
 
 
 int
-main(int argc, char *argv[])
+main (int argc, char *argv[])
 {
   int ret;
   struct GNUNET_BLOCK_Context *ctx;
   struct GNUNET_CONFIGURATION_Handle *cfg;
 
-  GNUNET_log_setup("test-block", "WARNING", NULL);
-  cfg = GNUNET_CONFIGURATION_create();
-  ctx = GNUNET_BLOCK_context_create(cfg);
-  ret = test_fs(ctx);
-  GNUNET_BLOCK_context_destroy(ctx);
-  GNUNET_CONFIGURATION_destroy(cfg);
+  GNUNET_log_setup ("test-block", "WARNING", NULL);
+  cfg = GNUNET_CONFIGURATION_create ();
+  ctx = GNUNET_BLOCK_context_create (cfg);
+  ret = test_fs (ctx);
+  GNUNET_BLOCK_context_destroy (ctx);
+  GNUNET_CONFIGURATION_destroy (cfg);
   if (ret != 0)
-    fprintf(stderr, "Tests failed: %d\n", ret);
+    fprintf (stderr, "Tests failed: %d\n", ret);
   return ret;
 }