indentation

64 files changed, 12336 insertions, 14241 deletions

diff --git a/src/fs/fs.c b/src/fs/fs.c
index 046c4dbb0..318b7088e 100644
--- a/src/fs/fs.c
+++ b/src/fs/fs.c
@@ -43,21 +43,18 @@ start_job (struct GNUNET_FS_QueueEntry *qe)
   GNUNET_assert (NULL == qe->client);
   qe->client = GNUNET_CLIENT_connect ("fs", qe->h->cfg);
   if (qe->client == NULL)
-    {
-      GNUNET_break (0);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    return;
+  }
   qe->start (qe->cls, qe->client);
   qe->start_times++;
   qe->h->active_blocks += qe->blocks;
   qe->start_time = GNUNET_TIME_absolute_get ();
-  GNUNET_CONTAINER_DLL_remove (qe->h->pending_head,
-                               qe->h->pending_tail,
-                               qe);
+  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->h->running_tail,
+                                     qe->h->running_tail, qe);
 }
 
 
@@ -75,14 +72,12 @@ stop_job (struct GNUNET_FS_QueueEntry *qe)
   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_CONTAINER_DLL_remove (qe->h->running_head,
-                               qe->h->running_tail,
-                               qe);
+                                           GNUNET_TIME_absolute_get_duration
+                                           (qe->start_time));
+  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->h->pending_tail,
+                                     qe->h->pending_tail, qe);
 }
 
 
@@ -94,8 +89,7 @@ stop_job (struct GNUNET_FS_QueueEntry *qe)
  * @param tc scheduler context
  */
 static void
-process_job_queue (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+process_job_queue (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_Handle *h = cls;
   struct GNUNET_FS_QueueEntry *qe;
@@ -108,40 +102,38 @@ process_job_queue (void *cls,
   h->queue_job = GNUNET_SCHEDULER_NO_TASK;
   next = h->pending_head;
   while (NULL != (qe = next))
+  {
+    next = qe->next;
+    if (h->running_head == NULL)
+    {
+      start_job (qe);
+      continue;
+    }
+    if ((qe->blocks + h->active_blocks <= h->max_parallel_requests) &&
+        (h->active_downloads + 1 <= h->max_parallel_downloads))
     {
-      next = qe->next;
-      if (h->running_head == NULL)
-        {
-          start_job (qe);
-          continue;
-        }
-      if ( (qe->blocks + h->active_blocks <= h->max_parallel_requests) &&
-           (h->active_downloads + 1 <= h->max_parallel_downloads) )
-        {
-          start_job (qe);
-          continue;
-        }
+      start_job (qe);
+      continue;
     }
+  }
   if (h->pending_head == NULL)
-    return; /* no need to stop anything */
+    return;                     /* no need to stop anything */
   restart_at = GNUNET_TIME_UNIT_FOREVER_REL;
   next = h->running_head;
   while (NULL != (qe = next))
-    {
-      next = qe->next;
-      run_time = GNUNET_TIME_relative_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);
-      restart_at = GNUNET_TIME_relative_min (rst, restart_at);
-      if (rst.rel_value > 0)
-        continue;       
-      stop_job (qe);
-    }
+  {
+    next = qe->next;
+    run_time = GNUNET_TIME_relative_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);
+    restart_at = GNUNET_TIME_relative_min (rst, restart_at);
+    if (rst.rel_value > 0)
+      continue;
+    stop_job (qe);
+  }
   h->queue_job = GNUNET_SCHEDULER_add_delayed (restart_at,
-                                               &process_job_queue,
-                                               h);
+                                               &process_job_queue, h);
 }
 
 
@@ -157,10 +149,8 @@ process_job_queue (void *cls,
  */
 struct GNUNET_FS_QueueEntry *
 GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
-                  GNUNET_FS_QueueStart start,
-                  GNUNET_FS_QueueStop stop,
-                  void *cls,
-                  unsigned int blocks)
+                  GNUNET_FS_QueueStart start,
+                  GNUNET_FS_QueueStop stop, void *cls, unsigned int blocks)
 {
   struct GNUNET_FS_QueueEntry *qe;
 
@@ -172,14 +162,10 @@ GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
   qe->queue_time = GNUNET_TIME_absolute_get ();
   qe->blocks = blocks;
   GNUNET_CONTAINER_DLL_insert_after (h->pending_head,
-                                     h->pending_tail,
-                                     h->pending_tail,
-                                     qe);
+                                     h->pending_tail, h->pending_tail, qe);
   if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (h->queue_job);
-  h->queue_job 
-    = GNUNET_SCHEDULER_add_now (&process_job_queue,
-                                h);
+  h->queue_job = GNUNET_SCHEDULER_add_now (&process_job_queue, h);
   return qe;
 }
 
@@ -194,17 +180,13 @@ GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qh)
   struct GNUNET_FS_Handle *h;
 
   h = qh->h;
-  if (qh->client != NULL)    
-    stop_job (qh);    
-  GNUNET_CONTAINER_DLL_remove (h->pending_head,
-                               h->pending_tail,
-                               qh);
+  if (qh->client != NULL)
+    stop_job (qh);
+  GNUNET_CONTAINER_DLL_remove (h->pending_head, h->pending_tail, qh);
   GNUNET_free (qh);
   if (h->queue_job != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (h->queue_job);
-  h->queue_job 
-    = GNUNET_SCHEDULER_add_now (&process_job_queue,
-                                h);
+  h->queue_job = GNUNET_SCHEDULER_add_now (&process_job_queue, h);
 }
 
 
@@ -218,17 +200,14 @@ GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qh)
  */
 struct TopLevelActivity *
 GNUNET_FS_make_top (struct GNUNET_FS_Handle *h,
-                    SuspendSignalFunction ssf,
-                    void *ssf_cls)
+                    SuspendSignalFunction ssf, void *ssf_cls)
 {
   struct TopLevelActivity *ret;
 
   ret = GNUNET_malloc (sizeof (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;
 }
 
@@ -240,12 +219,9 @@ 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_CONTAINER_DLL_remove (h->top_head, h->top_tail, top);
   GNUNET_free (top);
 }
 
@@ -285,54 +261,49 @@ struct FileInfo
  * @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)
 {
   struct FileInfo *fi = cls;
   ssize_t ret;
 
   if (max == 0)
-    {
-      if (fi->fd != NULL)
-        GNUNET_DISK_file_close (fi->fd);
-      GNUNET_free (fi->filename);
-      GNUNET_free (fi);
-      return 0;
-    }  
+  {
+    if (fi->fd != NULL)
+      GNUNET_DISK_file_close (fi->fd);
+    GNUNET_free (fi->filename);
+    GNUNET_free (fi);
+    return 0;
+  }
   if (fi->fd == NULL)
-    {
-      fi->fd = GNUNET_DISK_file_open (fi->filename,
-                                      GNUNET_DISK_OPEN_READ,
-                                      GNUNET_DISK_PERM_NONE);
-      if (fi->fd == NULL)
-        {
-          GNUNET_asprintf (emsg, 
-                           _("Could not open file `%s': %s"),
-                           fi->filename,
-                           STRERROR (errno));
-          return 0;
-        }
+  {
+    fi->fd = GNUNET_DISK_file_open (fi->filename,
+                                    GNUNET_DISK_OPEN_READ,
+                                    GNUNET_DISK_PERM_NONE);
+    if (fi->fd == NULL)
+    {
+      GNUNET_asprintf (emsg,
+                       _("Could not open file `%s': %s"),
+                       fi->filename, STRERROR (errno));
+      return 0;
     }
+  }
   GNUNET_DISK_file_seek (fi->fd, offset, GNUNET_DISK_SEEK_SET);
   ret = GNUNET_DISK_file_read (fi->fd, buf, max);
   if (ret == -1)
-    {
-      GNUNET_asprintf (emsg, 
-                       _("Could not read file `%s': %s"),
-                       fi->filename,
-                       STRERROR (errno));
-      return 0;
-    }
+  {
+    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;
 }
 
@@ -348,13 +319,13 @@ GNUNET_FS_make_file_reader_context_ (const char *filename)
 {
   struct FileInfo *fi;
 
-  fi = GNUNET_malloc (sizeof(struct FileInfo));
+  fi = GNUNET_malloc (sizeof (struct FileInfo));
   fi->filename = GNUNET_STRINGS_filename_expand (filename);
   if (fi->filename == NULL)
-    {
-      GNUNET_free (fi);
-      return NULL;
-    }
+  {
+    GNUNET_free (fi);
+    return NULL;
+  }
   return fi;
 }
 
@@ -376,19 +347,17 @@ GNUNET_FS_make_file_reader_context_ (const char *filename)
  * @return number of bytes written, usually "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 (max == 0)
-    {
-      GNUNET_free_non_null (data);
-      return 0;
-    }  
+  {
+    GNUNET_free_non_null (data);
+    return 0;
+  }
   memcpy (buf, &data[offset], max);
   return max;
 }
@@ -405,29 +374,23 @@ GNUNET_FS_data_reader_copy_ (void *cls,
  */
 static char *
 get_serialization_file_name (struct GNUNET_FS_Handle *h,
-                             const char *ext,
-                             const char *ent)
+                             const char *ext, const char *ent)
 {
   char *basename;
   char *ret;
 
   if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
-    return NULL; /* persistence not requested */
+    return NULL;                /* persistence not requested */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (h->cfg,
-                                               "fs",
-                                               "STATE_DIR",
-                                               &basename))
+                                               "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);
+                   "%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;
 }
@@ -446,32 +409,25 @@ get_serialization_file_name (struct GNUNET_FS_Handle *h,
  */
 static char *
 get_serialization_file_name_in_dir (struct GNUNET_FS_Handle *h,
-                                    const char *ext,
-                                    const char *uni,
-                                    const char *ent)
+                                    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 */
+    return NULL;                /* persistence not requested */
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (h->cfg,
-                                               "fs",
-                                               "STATE_DIR",
-                                               &basename))
+                                               "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);
+                   "%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;
 }
@@ -486,9 +442,7 @@ 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;
@@ -511,18 +465,16 @@ get_read_handle (struct GNUNET_FS_Handle *h,
  * @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);
   if (fn == NULL)
-    {
-      return NULL;
-    }
+  {
+    return NULL;
+  }
   ret = GNUNET_BIO_write_open (fn);
   if (ret == NULL)
     GNUNET_break (0);
@@ -542,9 +494,7 @@ get_write_handle (struct GNUNET_FS_Handle *h,
  */
 static struct GNUNET_BIO_WriteHandle *
 get_write_handle_in_dir (struct GNUNET_FS_Handle *h,
-                         const char *ext,
-                         const char *uni,
-                         const char *ent)
+                         const char *ext, const char *uni, const char *ent)
 {
   char *fn;
   struct GNUNET_BIO_WriteHandle *ret;
@@ -567,26 +517,22 @@ get_write_handle_in_dir (struct GNUNET_FS_Handle *h,
  */
 void
 GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
-                             const char *ext,
-                             const char *ent)
+                             const char *ext, const char *ent)
 {
   char *filename;
 
-  if ( (NULL == ent) ||
-       (0 == strlen (ent)) )
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if ((NULL == ent) || (0 == strlen (ent)))
+  {
+    GNUNET_break (0);
+    return;
+  }
   filename = get_serialization_file_name (h, ext, ent);
   if (filename != NULL)
-    {
-      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);
+  }
 }
 
 
@@ -600,27 +546,22 @@ GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
  */
 static void
 remove_sync_file_in_dir (struct GNUNET_FS_Handle *h,
-                         const char *ext,
-                         const char *uni,
-                         const char *ent)
+                         const char *ext, const char *uni, const char *ent)
 {
   char *filename;
 
-  if ( (NULL == ent) ||
-       (0 == strlen (ent)) )
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if ((NULL == ent) || (0 == strlen (ent)))
+  {
+    GNUNET_break (0);
+    return;
+  }
   filename = get_serialization_file_name_in_dir (h, ext, uni, ent);
   if (filename != NULL)
-    {
-      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);
+  }
 }
 
 
@@ -633,8 +574,7 @@ remove_sync_file_in_dir (struct GNUNET_FS_Handle *h,
  */
 void
 GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
-                            const char *ext,
-                            const char *uni)
+                            const char *ext, const char *uni)
 {
   char *dn;
 
@@ -643,11 +583,9 @@ GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
   dn = get_serialization_file_name_in_dir (h, ext, uni, "");
   if (dn == NULL)
     return;
-  if ( (GNUNET_OK == GNUNET_DISK_directory_test (dn)) &&
-       (GNUNET_OK != GNUNET_DISK_directory_remove (dn)) )
-    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                              "rmdir", 
-                              dn);
+  if ((GNUNET_OK == GNUNET_DISK_directory_test (dn)) &&
+      (GNUNET_OK != GNUNET_DISK_directory_remove (dn)))
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "rmdir", dn);
   GNUNET_free (dn);
 }
 
@@ -668,7 +606,7 @@ GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
  */
 static int
 write_start_time (struct GNUNET_BIO_WriteHandle *wh,
-                  struct GNUNET_TIME_Absolute timestamp)
+                  struct GNUNET_TIME_Absolute timestamp)
 {
   struct GNUNET_TIME_Relative dur;
 
@@ -693,14 +631,13 @@ write_start_time (struct GNUNET_BIO_WriteHandle *wh,
  */
 static int
 read_start_time (struct GNUNET_BIO_ReadHandle *rh,
-                 struct GNUNET_TIME_Absolute *timestamp)
+                 struct GNUNET_TIME_Absolute *timestamp)
 {
   struct GNUNET_TIME_Relative dur;
-  if (GNUNET_OK !=
-      GNUNET_BIO_read_int64 (rh, &dur.rel_value))
+
+  if (GNUNET_OK != GNUNET_BIO_read_int64 (rh, &dur.rel_value))
     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;
 }
 
@@ -714,9 +651,12 @@ read_start_time (struct GNUNET_BIO_ReadHandle *rh,
  *        the infromation
  * @return NULL on error
  */
-static struct GNUNET_FS_FileInformation *
-deserialize_file_information (struct GNUNET_FS_Handle *h,
-                              const char *filename);
+static struct GNUNET_FS_FileInformation *deserialize_file_information (struct
+                                                                       GNUNET_FS_Handle
+                                                                       *h,
+                                                                       const
+                                                                       char
+                                                                       *filename);
 
 
 /**
@@ -731,8 +671,7 @@ deserialize_file_information (struct GNUNET_FS_Handle *h,
  */
 static struct GNUNET_FS_FileInformation *
 deserialize_fi_node (struct GNUNET_FS_Handle *h,
-                     const char *fn,
-                     struct GNUNET_BIO_ReadHandle *rh)
+                     const char *fn, struct GNUNET_BIO_ReadHandle *rh)
 {
   struct GNUNET_FS_FileInformation *ret;
   struct GNUNET_FS_FileInformation *nxt;
@@ -742,195 +681,199 @@ 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;
-    }
+  if (GNUNET_OK != GNUNET_BIO_read (rh, "status flag", &b, sizeof (b)))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_FileInformation));
   ret->h = h;
   ksks = NULL;
   chks = 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)) ||
-       ( (ksks != NULL) &&
-         (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)) ||
-       ( (chks != NULL) &&
-         ( (NULL == 
-            (ret->chk_uri = GNUNET_FS_uri_parse (chks, NULL))) ||
-           (GNUNET_YES !=
-            GNUNET_FS_uri_test_chk (ret->chk_uri)) ) ) ||
-       (GNUNET_OK !=
-        read_start_time (rh, &ret->start_time)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_read_string (rh, "emsg", &ret->emsg, 16*1024)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_read_string (rh, "fn", &ret->filename, 16*1024)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_read_int64 (rh, &ret->bo.expiration_time.abs_value)) ||
-       (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)) )
+  if ((GNUNET_OK !=
+       GNUNET_BIO_read_meta_data (rh, "metadata", &ret->meta)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_read_string (rh, "ksk-uri", &ksks, 32 * 1024)) ||
+      ((ksks != NULL) &&
+       (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)) ||
+      ((chks != NULL) &&
+       ((NULL ==
+         (ret->chk_uri = GNUNET_FS_uri_parse (chks, NULL))) ||
+        (GNUNET_YES !=
+         GNUNET_FS_uri_test_chk (ret->chk_uri)))) ||
+      (GNUNET_OK !=
+       read_start_time (rh, &ret->start_time)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_read_string (rh, "emsg", &ret->emsg, 16 * 1024)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_read_string (rh, "fn", &ret->filename, 16 * 1024)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_read_int64 (rh, &ret->bo.expiration_time.abs_value)) ||
+      (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);               
-          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)
-        {
-          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 (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;
-    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 (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 4: /* directory */
-      ret->is_directory = GNUNET_YES;
-      if ( (GNUNET_OK !=
-            GNUNET_BIO_read_int32 (rh, &dsize)) ||
-           (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 (filename != NULL)
-        {
-          ret->data.dir.entries = deserialize_file_information (h, filename);
-          GNUNET_free (filename);
-          filename = NULL;
-          nxt = ret->data.dir.entries;
-          while (nxt != NULL)
-            {
-              nxt->dir = ret;
-              nxt = nxt->next;
-            }  
-        }
-      break;
-    default:
+      {
+        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);
       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_break (0);
-      goto cleanup;  
+      goto cleanup;
     }
-  if (filename != NULL)
+    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)
     {
-      ret->next = deserialize_file_information (h, 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 (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;
+  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 (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 4:                      /* directory */
+    ret->is_directory = GNUNET_YES;
+    if ((GNUNET_OK !=
+         GNUNET_BIO_read_int32 (rh, &dsize)) ||
+        (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 (filename != NULL)
+    {
+      ret->data.dir.entries = deserialize_file_information (h, filename);
       GNUNET_free (filename);
       filename = NULL;
-    }
+      nxt = ret->data.dir.entries;
+      while (nxt != NULL)
+      {
+        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 (filename != NULL)
+  {
+    ret->next = deserialize_file_information (h, filename);
+    GNUNET_free (filename);
+    filename = NULL;
+  }
   GNUNET_free_non_null (ksks);
   GNUNET_free_non_null (chks);
   return ret;
- cleanup:
+cleanup:
   GNUNET_free_non_null (ksks);
   GNUNET_free_non_null (chks);
   GNUNET_free_non_null (filename);
@@ -949,8 +892,7 @@ deserialize_fi_node (struct GNUNET_FS_Handle *h,
  * @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;
@@ -960,22 +902,18 @@ deserialize_file_information (struct GNUNET_FS_Handle *h,
   if (rh == NULL)
     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);
-    }
+  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 (ret == NULL)
-    {
-      if (0 != UNLINK (filename))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                  "unlink",
-                                  filename);
-    }
+  {
+    if (0 != UNLINK (filename))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
+  }
   return ret;
 }
 
@@ -997,21 +935,20 @@ get_serialization_short_name (const char *fullname)
   end = NULL;
   nxt = fullname;
   /* FIXME: we could do this faster since we know
-     the length of 'end'... */
+   * the length of 'end'... */
   while ('\0' != *nxt)
-    {
-      if (DIR_SEPARATOR == *nxt)
-        end = nxt + 1;
-      nxt++;
-    }
-  if ( (end == NULL) ||
-       (strlen (end) == 0) )
-    {
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+    if (DIR_SEPARATOR == *nxt)
+      end = nxt + 1;
+    nxt++;
+  }
+  if ((end == NULL) || (strlen (end) == 0))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   GNUNET_break (6 == strlen (end));
-  return GNUNET_strdup (end);  
+  return GNUNET_strdup (end);
 }
 
 
@@ -1024,28 +961,26 @@ 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;
   char *ret;
 
   if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
-    return NULL; /* persistence not requested */
+    return NULL;                /* persistence not requested */
   dn = get_serialization_file_name (h, ext, "");
   if (dn == NULL)
     return NULL;
-  if (GNUNET_OK !=
-      GNUNET_DISK_directory_create_for_file (dn))
-    {
-      GNUNET_free (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 (fn == NULL)
-    return NULL; /* epic fail */
+    return NULL;                /* epic fail */
   ret = get_serialization_short_name (fn);
   GNUNET_free (fn);
   return ret;
@@ -1063,28 +998,26 @@ make_serialization_file_name (struct GNUNET_FS_Handle *h,
  */
 static char *
 make_serialization_file_name_in_dir (struct GNUNET_FS_Handle *h,
-                                     const char *ext,
-                                     const char *uni)
+                                     const char *ext, const char *uni)
 {
   char *fn;
   char *dn;
   char *ret;
 
   if (0 == (h->flags & GNUNET_FS_FLAGS_PERSISTENCE))
-    return NULL; /* persistence not requested */
+    return NULL;                /* persistence not requested */
   dn = get_serialization_file_name_in_dir (h, ext, uni, "");
   if (dn == NULL)
     return NULL;
-  if (GNUNET_OK !=
-      GNUNET_DISK_directory_create_for_file (dn))
-    {
-      GNUNET_free (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 (fn == NULL)
-    return NULL; /* epic fail */
+    return NULL;                /* epic fail */
   ret = get_serialization_short_name (fn);
   GNUNET_free (fn);
   return ret;
@@ -1100,7 +1033,7 @@ make_serialization_file_name_in_dir (struct GNUNET_FS_Handle *h,
  */
 static int
 copy_from_reader (struct GNUNET_BIO_WriteHandle *wh,
-                  struct GNUNET_FS_FileInformation * fi)
+                  struct GNUNET_FS_FileInformation *fi)
 {
   char buf[32 * 1024];
   uint64_t off;
@@ -1111,22 +1044,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 (ret == 0)
     {
-      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 (ret == 0)
-        {
-          GNUNET_free (emsg);
-          return GNUNET_SYSERR;
-        }
-      if (GNUNET_OK != 
-          GNUNET_BIO_write (wh, buf, ret))
-        return GNUNET_SYSERR;
-      off += ret;
+      GNUNET_free (emsg);
+      return GNUNET_SYSERR;
     }
+    if (GNUNET_OK != GNUNET_BIO_write (wh, buf, ret))
+      return GNUNET_SYSERR;
+    off += ret;
+  }
   return GNUNET_OK;
 }
 
@@ -1138,7 +1068,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;
@@ -1146,17 +1076,19 @@ GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation * fi)
   char *ksks;
   char *chks;
 
-  if (NULL == fi->serialization)    
-    fi->serialization = make_serialization_file_name (fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO);
+  if (NULL == fi->serialization)
+    fi->serialization =
+        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);
+  wh = get_write_handle (fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO,
+                         fi->serialization);
   if (wh == NULL)
-    {
-      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)
@@ -1175,131 +1107,130 @@ GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation * fi)
     chks = GNUNET_FS_uri_to_string (fi->chk_uri);
   else
     chks = 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 != 
-        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)) ||
-       (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;
-    }
+  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 !=
+       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)) ||
+      (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);
   ksks = 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 (GNUNET_HashCode))) )
-        {
-          GNUNET_break (0);
-          goto cleanup;
-        }
-      break;
-    case 4: /* directory */
-      if ( (GNUNET_OK !=
-            GNUNET_BIO_write_int32 (wh, fi->data.dir.dir_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);
+      GNUNET_break (0);
       goto cleanup;
     }
-  if (GNUNET_OK !=
-      GNUNET_BIO_write_string (wh, (fi->next != NULL) ? fi->next->serialization : NULL))
+    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;  
+      GNUNET_break (0);
+      goto cleanup;
     }
-  if (GNUNET_OK !=
-      GNUNET_BIO_write_close (wh))
+    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)
     {
-      wh = NULL;
       GNUNET_break (0);
       goto cleanup;
     }
-  return; /* done! */
- 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 (GNUNET_HashCode))))
+    {
+      GNUNET_break (0);
+      goto cleanup;
+    }
+    break;
+  case 4:                      /* directory */
+    if ((GNUNET_OK !=
+         GNUNET_BIO_write_int32 (wh, fi->data.dir.dir_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 (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 (wh != NULL)
     (void) GNUNET_BIO_write_close (wh);
   GNUNET_free_non_null (chks);
   GNUNET_free_non_null (ksks);
-  fn = get_serialization_file_name (fi->h, GNUNET_FS_SYNC_PATH_FILE_INFO, fi->serialization);
+  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);
-    }
+  {
+    if (0 != UNLINK (fn))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", fn);
+    GNUNET_free (fn);
+  }
   GNUNET_free (fi->serialization);
-  fi->serialization = NULL;  
+  fi->serialization = NULL;
 }
 
 
@@ -1313,25 +1244,22 @@ GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation * fi)
  * @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 (pos != NULL)
+  {
+    if (0 == strcmp (srch, pos->serialization))
+      return pos;
+    if (pos->is_directory)
     {
-      if (0 == strcmp (srch,
-                       pos->serialization))
-        return pos;
-      if (pos->is_directory)
-        {
-          r = find_file_position (pos->data.dir.entries,
-                                  srch);
-          if (r != NULL)
-            return r;
-        }
-      pos = pos->next;
+      r = find_file_position (pos->data.dir.entries, srch);
+      if (r != NULL)
+        return r;
     }
+    pos = pos->next;
+  }
   return NULL;
 }
 
@@ -1351,14 +1279,13 @@ find_file_position (struct GNUNET_FS_FileInformation *pos,
  * @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 *sc = cls;
   struct GNUNET_FS_ProgressInfo pi;
@@ -1380,8 +1307,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;
@@ -1401,117 +1327,109 @@ deserialize_publish_file (void *cls,
   ns = NULL;
   rh = GNUNET_BIO_read_open (filename);
   if (rh == NULL)
-    {
-      GNUNET_break (0);
-      goto cleanup;
-    }
-  if ( (GNUNET_OK !=
-        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_string (rh, "publish-firoot", &fi_root, 128)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_read_string (rh, "publish-fipos", &fi_pos, 128)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_read_string (rh, "publish-ns", &ns, 1024)) )
-    {
-      GNUNET_break (0);
-      goto cleanup;      
-    }    
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  if ((GNUNET_OK !=
+       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_string (rh, "publish-firoot", &fi_root, 128)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_read_string (rh, "publish-fipos", &fi_pos, 128)) ||
+      (GNUNET_OK != GNUNET_BIO_read_string (rh, "publish-ns", &ns, 1024)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   pc->options = options;
   pc->all_done = all_done;
   if (NULL == fi_root)
-    {
-      GNUNET_break (0);
-      goto cleanup;    
-    }
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   pc->fi = deserialize_file_information (h, fi_root);
   if (pc->fi == NULL)
-    {
-      GNUNET_break (0);
-      goto cleanup;    
-    }
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
   if (ns != NULL)
+  {
+    pc->namespace = GNUNET_FS_namespace_create (h, ns);
+    if (pc->namespace == NULL)
     {
-      pc->namespace = GNUNET_FS_namespace_create (h, ns);
-      if (pc->namespace == NULL)
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                      _("Failed to recover namespace `%s', cannot resume publishing operation.\n"),
-                      ns);
-          goto cleanup;
-        }
+      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                  _
+                  ("Failed to recover namespace `%s', cannot resume publishing operation.\n"),
+                  ns);
+      goto cleanup;
     }
-  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;
-    } 
+  }
+  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;
+  }
   if (fi_pos != NULL)
+  {
+    pc->fi_pos = find_file_position (pc->fi, fi_pos);
+    GNUNET_free (fi_pos);
+    fi_pos = NULL;
+    if (pc->fi_pos == NULL)
     {
-      pc->fi_pos = find_file_position (pc->fi,
-                                       fi_pos);
-      GNUNET_free (fi_pos);
-      fi_pos = NULL;
-      if (pc->fi_pos == NULL)
-        {
-          /* failed to find position for resuming, outch! Will start from root! */
-          GNUNET_break (0);
-          if (pc->all_done != GNUNET_YES)
-            pc->fi_pos = pc->fi;
-        }
+      /* failed to find position for resuming, outch! Will start from root! */
+      GNUNET_break (0);
+      if (pc->all_done != GNUNET_YES)
+        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 (pc->all_done != GNUNET_YES)
-    {
-      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == 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);
-    }
+  {
+    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == 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);
+  }
   GNUNET_free_non_null (ns);
   pc->top = GNUNET_FS_make_top (h, &GNUNET_FS_publish_signal_suspend_, pc);
   return GNUNET_OK;
- cleanup:
+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);
   GNUNET_free_non_null (ns);
-  if ( (rh != NULL) &&
-       (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 ((rh != NULL) && (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 (pc->fi != NULL)
     GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
   if (0 != UNLINK (filename))
@@ -1532,59 +1450,64 @@ deserialize_publish_file (void *cls,
  */
 void
 GNUNET_FS_publish_sync_ (struct GNUNET_FS_PublishContext *pc)
-{  
+{
   struct GNUNET_BIO_WriteHandle *wh;
 
   if (NULL == pc->serialization)
     pc->serialization = make_serialization_file_name (pc->h,
-                                                      GNUNET_FS_SYNC_PATH_MASTER_PUBLISH);
+                                                      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 (wh == NULL)
-    {
-      GNUNET_break (0);
-      goto cleanup;
-    }
-  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_string (wh, pc->fi->serialization)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_write_string (wh, (pc->fi_pos == NULL) ? NULL : pc->fi_pos->serialization)) ||
-       (GNUNET_OK !=
-        GNUNET_BIO_write_string (wh, (pc->namespace == NULL) ? NULL : pc->namespace->name)) )
-   {
-     GNUNET_break (0);
-     goto cleanup;
-   }
- if (GNUNET_OK !=
-     GNUNET_BIO_write_close (wh))
-   {
-     wh = NULL;
-     GNUNET_break (0);
-     goto cleanup;
-   }
- return;
- cleanup:
- if (wh != NULL)
-     (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;
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  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_string (wh, pc->fi->serialization)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_write_string (wh,
+                                (pc->fi_pos ==
+                                 NULL) ? NULL : pc->fi_pos->serialization)) ||
+      (GNUNET_OK !=
+       GNUNET_BIO_write_string (wh,
+                                (pc->namespace ==
+                                 NULL) ? NULL : pc->namespace->name)))
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  return;
+cleanup:
+  if (wh != NULL)
+    (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;
 }
 
 
@@ -1603,45 +1526,45 @@ GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc)
 
   if (NULL == uc->serialization)
     uc->serialization = make_serialization_file_name (uc->h,
-                                                      GNUNET_FS_SYNC_PATH_MASTER_UNINDEX);
+                                                      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 (wh == NULL)
-    {
-      GNUNET_break (0);
-      goto cleanup;
-    }
-  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)) ||
-       ( (uc->state == UNINDEX_STATE_FS_NOTIFY) &&
-         (GNUNET_OK !=
-          GNUNET_BIO_write (wh, &uc->file_id, sizeof (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_break (0);
+    goto cleanup;
+  }
+  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)) ||
+      ((uc->state == UNINDEX_STATE_FS_NOTIFY) &&
+       (GNUNET_OK !=
+        GNUNET_BIO_write (wh, &uc->file_id, sizeof (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;
+  }
   return;
- cleanup:
+cleanup:
   if (wh != NULL)
     (void) GNUNET_BIO_write_close (wh);
-  GNUNET_FS_remove_sync_file_ (uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX, uc->serialization);
+  GNUNET_FS_remove_sync_file_ (uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
+                               uc->serialization);
   GNUNET_free (uc->serialization);
   uc->serialization = NULL;
 }
@@ -1656,26 +1579,24 @@ GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc)
  */
 static int
 write_download_request (struct GNUNET_BIO_WriteHandle *wh,
-                        struct DownloadRequest *dr)
-{ 
+                        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)) ) 
-    return GNUNET_NO;    
-  if ( (dr->state == BRS_CHK_SET) &&
-       (GNUNET_OK !=
-        GNUNET_BIO_write (wh, &dr->chk, sizeof (struct ContentHashKey))) )
+
+  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;
-  for (i=0;i<dr->num_children;i++)
-    if (GNUNET_NO == 
-        write_download_request (wh, dr->children[i]))
+  if ((dr->state == BRS_CHK_SET) &&
+      (GNUNET_OK !=
+       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]))
       return GNUNET_NO;
   return GNUNET_YES;
 }
@@ -1689,59 +1610,59 @@ write_download_request (struct GNUNET_BIO_WriteHandle *wh,
  */
 static struct DownloadRequest *
 read_download_request (struct GNUNET_BIO_ReadHandle *rh)
-{ 
+{
   struct DownloadRequest *dr;
   unsigned int i;
 
   dr = GNUNET_malloc (sizeof (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)) ||
-       ( (dr->depth == 0) && (dr->num_children > 0) ) ||
-       ( (dr->depth > 0) && (dr->num_children == 0) ) )
-    {
-      GNUNET_break (0);
-      dr->num_children = 0;
-      goto cleanup;        
-    }
+  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)) ||
+      ((dr->depth == 0) && (dr->num_children > 0)) ||
+      ((dr->depth > 0) && (dr->num_children == 0)))
+  {
+    GNUNET_break (0);
+    dr->num_children = 0;
+    goto cleanup;
+  }
   if (dr->num_children > 0)
     dr->children = GNUNET_malloc (dr->num_children *
-                                  sizeof (struct ContentHashKey));
+                                  sizeof (struct ContentHashKey));
   switch (dr->state)
-    {
-    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_DOWNLOAD_DOWN:
-    case BRS_DOWNLOAD_UP:
-    case BRS_ERROR:
-      break;
-    default:
-      GNUNET_break (0);
+  {
+  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;
-    }
-  for (i=0;i<dr->num_children;i++)
-    {
-      if (NULL == (dr->children[i] = read_download_request (rh)))
-        goto cleanup;
-      dr->children[i]->parent = dr;
-    }
+    break;
+  case BRS_DOWNLOAD_DOWN:
+  case BRS_DOWNLOAD_UP:
+  case BRS_ERROR:
+    break;
+  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;
+  }
   return dr;
- cleanup:
+cleanup:
   GNUNET_FS_free_download_request_ (dr);
   return NULL;
 }
@@ -1758,29 +1679,23 @@ read_download_request (struct GNUNET_BIO_ReadHandle *rh)
  */
 static char *
 get_download_sync_filename (struct GNUNET_FS_DownloadContext *dc,
-                            const char *uni,
-                            const char *ext)
+                            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);
+                                        (dc->search != NULL) ?
+                                        GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD :
+                                        GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
+                                        uni);
   if (dc->parent->serialization == NULL)
     return NULL;
   par = get_download_sync_filename (dc->parent, dc->parent->serialization, "");
   if (par == NULL)
     return NULL;
-  GNUNET_asprintf (&epar,
-                   "%s.dir%s%s%s",
-                   par,
-                   DIR_SEPARATOR_STR,
-                   uni,
-                   ext);
+  GNUNET_asprintf (&epar, "%s.dir%s%s%s", par, DIR_SEPARATOR_STR, uni, ext);
   GNUNET_free (par);
   return epar;
 }
@@ -1802,97 +1717,93 @@ GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc)
   char *fn;
   char *dir;
 
-  if (NULL == dc->serialization)    
+  if (NULL == dc->serialization)
+  {
+    dir = get_download_sync_filename (dc, "", "");
+    if (dir == NULL)
+      return;
+    if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (dir))
     {
-      dir = get_download_sync_filename (dc, "", "");
-      if (dir == NULL)
-        return;
-      if (GNUNET_OK !=
-          GNUNET_DISK_directory_create_for_file (dir))
-        {
-          GNUNET_free (dir);
-          return;
-        }
-      fn = GNUNET_DISK_mktemp (dir);
       GNUNET_free (dir);
-      if (fn == NULL)
-        return;
-      dc->serialization = get_serialization_short_name (fn);
+      return;
     }
+    fn = GNUNET_DISK_mktemp (dir);
+    GNUNET_free (dir);
+    if (fn == NULL)
+      return;
+    dc->serialization = get_serialization_short_name (fn);
+  }
   else
-    {
-      fn = get_download_sync_filename (dc, dc->serialization, "");
-      if (fn == NULL)
-        {
-          GNUNET_free (dc->serialization);
-          dc->serialization = NULL;
-          GNUNET_free (fn);
-          return;
-        }
-    }
-  wh = GNUNET_BIO_write_open (fn);
-  if (wh == NULL)
+  {
+    fn = get_download_sync_filename (dc, dc->serialization, "");
+    if (fn == NULL)
     {
       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)) );
+  }
+  wh = GNUNET_BIO_write_open (fn);
+  if (wh == NULL)
+  {
+    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 ((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);
       goto cleanup;
     }
+  }
+  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:
+cleanup:
   if (NULL != wh)
     (void) GNUNET_BIO_write_close (wh);
   GNUNET_free_non_null (uris);
@@ -1921,65 +1832,65 @@ 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->sc->h,
-                                                             (sr->sc->psearch_result == NULL) 
-                                                             ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                                             : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                                             sr->sc->serialization);
+                                                             (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->sc->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->sc->h,
+                                (sr->sc->psearch_result == NULL)
+                                ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                                : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                                sr->sc->serialization, sr->serialization);
   if (wh == NULL)
-    {
-      GNUNET_break (0);
-      goto cleanup;
-    }
+  {
+    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_OK !=
-        GNUNET_BIO_write (wh, &sr->key, sizeof (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 (GNUNET_OK !=
-      GNUNET_BIO_write_close (wh))
-    {
-      wh = NULL;
-      GNUNET_break (0);
-      goto cleanup;
-    }
+  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_OK != GNUNET_BIO_write (wh, &sr->key, sizeof (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 (GNUNET_OK != GNUNET_BIO_write_close (wh))
+  {
+    wh = NULL;
+    GNUNET_break (0);
+    goto cleanup;
+  }
   GNUNET_free_non_null (uris);
   return;
- cleanup:
+cleanup:
   GNUNET_free_non_null (uris);
   if (wh != NULL)
-    (void)  GNUNET_BIO_write_close (wh);
+    (void) GNUNET_BIO_write_close (wh);
   remove_sync_file_in_dir (sr->sc->h,
-                           (sr->sc->psearch_result == NULL) 
-                           ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                           : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                           sr->sc->serialization,
-                           sr->serialization);
+                           (sr->sc->psearch_result == NULL)
+                           ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                           : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                           sr->sc->serialization, sr->serialization);
   GNUNET_free (sr->serialization);
   sr->serialization = NULL;
 }
@@ -1995,58 +1906,54 @@ GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr)
  */
 void
 GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc)
-{  
+{
   struct GNUNET_BIO_WriteHandle *wh;
   char *uris;
   char in_pause;
   const char *category;
-  
-  category = (sc->psearch_result == NULL) 
-    ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH 
-    : GNUNET_FS_SYNC_PATH_CHILD_SEARCH;      
+
+  category = (sc->psearch_result == NULL)
+      ? 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);
   if (wh == NULL)
-    {
-      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)) );
+  {
+    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 != GNUNET_SCHEDULER_NO_TASK) ? '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;          
-    }
+  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:
+cleanup:
   if (wh != NULL)
     (void) GNUNET_BIO_write_close (wh);
   GNUNET_free_non_null (uris);
@@ -2065,8 +1972,7 @@ GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc)
  * @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;
@@ -2080,109 +1986,100 @@ deserialize_unindex_file (void *cls,
   uc->serialization = get_serialization_short_name (filename);
   rh = GNUNET_BIO_read_open (filename);
   if (rh == NULL)
+  {
+    GNUNET_break (0);
+    goto cleanup;
+  }
+  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_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 (GNUNET_HashCode)))
     {
-      GNUNET_break (0);     
+      GNUNET_break (0);
       goto cleanup;
     }
-  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)) )
+    break;
+  case UNINDEX_STATE_DS_REMOVE:
+    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;          
-    }
-  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 (GNUNET_HashCode)))
-        {
-          GNUNET_break (0);
-          goto cleanup;
-        }
-      break;
-    case UNINDEX_STATE_DS_REMOVE:
-      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);
       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);
+                                  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_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_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:
+cleanup:
   GNUNET_free_non_null (uc->filename);
-  if ( (rh != NULL) &&
-       (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 ((rh != NULL) && (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 (uc->serialization != NULL)
-    GNUNET_FS_remove_sync_file_ (h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX, 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);
   return GNUNET_OK;
@@ -2200,10 +2097,10 @@ deserialize_unindex_file (void *cls,
  */
 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);
+                      struct GNUNET_BIO_ReadHandle *rh,
+                      struct GNUNET_FS_DownloadContext *parent,
+                      struct GNUNET_FS_SearchResult *search,
+                      const char *serialization);
 
 
 /**
@@ -2214,11 +2111,16 @@ deserialize_download (struct GNUNET_FS_Handle *h,
  * @param psearch_result parent search result
  * @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);
+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);
 
 
 /**
@@ -2230,8 +2132,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;
@@ -2246,130 +2147,107 @@ deserialize_search_result (void *cls,
   ser = get_serialization_short_name (filename);
   rh = GNUNET_BIO_read_open (filename);
   if (rh == NULL)
-    {
-      if (ser != NULL)
-        {
-          remove_sync_file_in_dir (sc->h, 
-                                   (sc->psearch_result == NULL) 
-                                   ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                   : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                   sc->serialization,
-                                   ser);
-          GNUNET_free (ser);
-        }
-      return GNUNET_OK;
+  {
+    if (ser != NULL)
+    {
+      remove_sync_file_in_dir (sc->h,
+                               (sc->psearch_result == NULL)
+                               ? 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_malloc (sizeof (struct GNUNET_FS_SearchResult));
-  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_OK !=
-        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 (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;   
-    }
+  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_OK !=
+       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 (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_free (uris);
   if (download != NULL)
-    {
-      drh = get_read_handle (sc->h, 
-                             GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD,
-                             download);
-      if (drh != NULL)
-        {
-          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 (drh != NULL)
+    {
+      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 (update_srch != NULL)
-    {
-      drh = get_read_handle (sc->h, 
-                             GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                             update_srch);
-      if (drh != NULL)
-        {
-          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);     
-    }
+  {
+    drh = get_read_handle (sc->h,
+                           GNUNET_FS_SYNC_PATH_CHILD_SEARCH, update_srch);
+    if (drh != NULL)
+    {
+      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_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);
-    }
+                                     &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:
+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 (update_srch);
   if (sr->uri != NULL)
     GNUNET_FS_uri_destroy (sr->uri);
   if (sr->meta != NULL)
     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_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;
 }
 
@@ -2387,18 +2265,17 @@ signal_download_resume (struct GNUNET_FS_DownloadContext *dc)
 {
   struct GNUNET_FS_DownloadContext *dcc;
   struct GNUNET_FS_ProgressInfo pi;
-  
+
   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;
+  }
   if (dc->pending_head != NULL)
     GNUNET_FS_download_start_downloading_ (dc);
 }
@@ -2410,8 +2287,7 @@ signal_download_resume (struct GNUNET_FS_DownloadContext *dc)
  *
  * @param sc search being resumed
  */
-static void
-signal_search_resume (struct GNUNET_FS_SearchContext *sc);
+static void signal_search_resume (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -2424,34 +2300,34 @@ signal_search_resume (struct GNUNET_FS_SearchContext *sc);
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-signal_result_resume (void *cls,
-                      const GNUNET_HashCode * key,
-                      void *value)
+signal_result_resume (void *cls, const 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);
-    }
+  {
+    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);
+  }
   if (sr->download != NULL)
-    {
-      signal_download_resume (sr->download);
-    }
+  {
+    signal_download_resume (sr->download);
+  }
   else
-    {
-      GNUNET_FS_search_start_probe_ (sr);
-    }
+  {
+    GNUNET_FS_search_start_probe_ (sr);
+  }
   if (sr->update_search != NULL)
     signal_search_resume (sr->update_search);
   return GNUNET_YES;
@@ -2463,8 +2339,7 @@ signal_result_resume (void *cls,
  *
  * @param sc search context to free
  */
-static void
-free_search_context (struct GNUNET_FS_SearchContext *sc);
+static void free_search_context (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -2476,17 +2351,15 @@ free_search_context (struct GNUNET_FS_SearchContext *sc);
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-free_result (void *cls,
-             const GNUNET_HashCode * key,
-             void *value)
+free_result (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
   if (sr->update_search != NULL)
-    {
-      free_search_context (sr->update_search);
-      GNUNET_assert (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);
@@ -2503,29 +2376,28 @@ static void
 free_search_context (struct GNUNET_FS_SearchContext *sc)
 {
   if (sc->serialization != NULL)
-    {
-      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,
-                                   (sc->psearch_result == NULL) 
-                                   ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                   : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                  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,
+                                (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 (sc->uri != NULL)
     GNUNET_FS_uri_destroy (sc->uri);
   if (sc->master_result_map != NULL)
-    {
-      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                             &free_result,
-                                             sc);
-      GNUNET_CONTAINER_multihashmap_destroy (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);
 }
 
@@ -2539,8 +2411,7 @@ 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;
@@ -2550,28 +2421,21 @@ deserialize_subdownload (void *cls,
   ser = get_serialization_short_name (filename);
   rh = GNUNET_BIO_read_open (filename);
   if (rh == NULL)
-    {
-      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_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;
 }
@@ -2598,15 +2462,13 @@ free_download_context (struct GNUNET_FS_DownloadContext *dc)
   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_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);    
+  if (NULL != dc->active)
+    GNUNET_CONTAINER_multihashmap_destroy (dc->active);
   GNUNET_free (dc);
 }
 
@@ -2622,10 +2484,10 @@ free_download_context (struct GNUNET_FS_DownloadContext *dc)
  */
 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)
+                      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;
@@ -2640,89 +2502,77 @@ deserialize_download (struct GNUNET_FS_Handle *h,
   dc->parent = parent;
   dc->h = h;
   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_OK !=
-        GNUNET_BIO_read_meta_data (rh, "download-meta", &dc->meta)) ||
-       (GNUNET_OK !=
-        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;          
-    }
+  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_OK !=
+       GNUNET_BIO_read_meta_data (rh, "download-meta", &dc->meta)) ||
+      (GNUNET_OK !=
+       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;
-  dc->active = GNUNET_CONTAINER_multihashmap_create (1 + 2 * (dc->length / DBLOCK_SIZE));
+  dc->active =
+      GNUNET_CONTAINER_multihashmap_create (1 + 2 * (dc->length / DBLOCK_SIZE));
   dc->has_finished = (int) status;
-  dc->treedepth = GNUNET_FS_compute_depth (GNUNET_FS_uri_chk_get_file_size (dc->uri));
+  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_uri_loc_get_peer_identity (dc->uri, &dc->target));
   if (dc->emsg == NULL)
+  {
+    dc->top_request = read_download_request (rh);
+    if (dc->top_request == NULL)
     {
-      dc->top_request = read_download_request (rh);
-      if (dc->top_request == NULL)
-        {
-          GNUNET_break (0);
-          goto cleanup;
-        }
+      GNUNET_break (0);
+      goto cleanup;
     }
+  }
   dn = get_download_sync_filename (dc, dc->serialization, ".dir");
   if (dn != NULL)
-    {
-      if (GNUNET_YES ==
-          GNUNET_DISK_directory_test (dn))
-        GNUNET_DISK_directory_scan (dn, &deserialize_subdownload, dc);
-      GNUNET_free (dn);
-    }
+  {
+    if (GNUNET_YES == GNUNET_DISK_directory_test (dn))
+      GNUNET_DISK_directory_scan (dn, &deserialize_subdownload, dc);
+    GNUNET_free (dn);
+  }
   if (parent != NULL)
-    {
-      abort (); // for debugging for now
-      GNUNET_CONTAINER_DLL_insert (parent->child_head,
-                                   parent->child_tail,
-                                   dc);
-    }
+  {
+    abort ();                   // for debugging for now
+    GNUNET_CONTAINER_DLL_insert (parent->child_head, parent->child_tail, dc);
+  }
   if (search != NULL)
-    {
-      dc->search = search;
-      search->download = dc;
-    }
-  if ( (parent == NULL) &&
-       (search == NULL) )
-    {
-      dc->top = GNUNET_FS_make_top (dc->h,
-                                    &GNUNET_FS_download_signal_suspend_,
-                                    dc);      
-      signal_download_resume (dc);  
-    }
+  {
+    dc->search = search;
+    search->download = dc;
+  }
+  if ((parent == NULL) && (search == NULL))
+  {
+    dc->top = GNUNET_FS_make_top (dc->h,
+                                  &GNUNET_FS_download_signal_suspend_, dc);
+    signal_download_resume (dc);
+  }
   GNUNET_free (uris);
-  dc->task 
-    = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, dc);
+  dc->task = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, dc);
   return;
- cleanup:
+cleanup:
   GNUNET_free_non_null (uris);
   GNUNET_free_non_null (emsg);
   free_download_context (dc);
@@ -2742,12 +2592,11 @@ signal_search_resume (struct GNUNET_FS_SearchContext *sc)
 
   pi.status = GNUNET_FS_STATUS_SEARCH_RESUME;
   pi.value.search.specifics.resume.message = sc->emsg;
-  pi.value.search.specifics.resume.is_paused = (sc->client == NULL) ? GNUNET_YES : GNUNET_NO;
-  sc->client_info = GNUNET_FS_search_make_status_ (&pi,
-                                                   sc);
+  pi.value.search.specifics.resume.is_paused =
+      (sc->client == NULL) ? GNUNET_YES : GNUNET_NO;
+  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                         &signal_result_resume,
-                                         sc);
+                                         &signal_result_resume, sc);
 
 }
 
@@ -2762,9 +2611,9 @@ signal_search_resume (struct GNUNET_FS_SearchContext *sc)
  */
 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)
+                    struct GNUNET_BIO_ReadHandle *rh,
+                    struct GNUNET_FS_SearchResult *psearch_result,
+                    const char *serialization)
 {
   struct GNUNET_FS_SearchContext *sc;
   char *emsg;
@@ -2773,67 +2622,63 @@ deserialize_search (struct GNUNET_FS_Handle *h,
   uint32_t options;
   char in_pause;
 
-  if ( (psearch_result != NULL) &&
-       (psearch_result->update_search != NULL) )
-    {
-      GNUNET_break (0);
-      return NULL;
-    }
+  if ((psearch_result != NULL) && (psearch_result->update_search != NULL))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   uris = NULL;
   emsg = NULL;
   sc = GNUNET_malloc (sizeof (struct GNUNET_FS_SearchContext));
   if (psearch_result != NULL)
-    {
-      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);
-  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_OK !=
-        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;          
-    }
+  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_OK !=
+       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);
   dn = get_serialization_file_name_in_dir (h,
-                                           (sc->psearch_result == NULL) 
-                                           ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
-                                           : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
-                                           sc->serialization,
-                                           "");
+                                           (sc->psearch_result == NULL)
+                                           ? GNUNET_FS_SYNC_PATH_MASTER_SEARCH
+                                           : GNUNET_FS_SYNC_PATH_CHILD_SEARCH,
+                                           sc->serialization, "");
   if (dn != NULL)
-    {
-      if (GNUNET_YES ==
-          GNUNET_DISK_directory_test (dn))
-        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"));    
-    }
+  {
+    if (GNUNET_YES == GNUNET_DISK_directory_test (dn))
+      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);
   return sc;
- cleanup:
+cleanup:
   GNUNET_free_non_null (emsg);
   free_search_context (sc);
   GNUNET_free_non_null (uris);
@@ -2850,8 +2695,7 @@ deserialize_search (struct GNUNET_FS_Handle *h,
  * @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;
@@ -2862,27 +2706,25 @@ deserialize_search_file (void *cls,
   ser = get_serialization_short_name (filename);
   rh = GNUNET_BIO_read_open (filename);
   if (rh == NULL)
+  {
+    if (ser != NULL)
     {
-      if (ser != NULL)
-        {
-          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);
     }
+    return GNUNET_OK;
+  }
   sc = deserialize_search (h, rh, NULL, ser);
   if (sc != NULL)
     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);
-    }
+  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;
 }
 
@@ -2896,8 +2738,7 @@ deserialize_search_file (void *cls,
  * @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;
@@ -2907,25 +2748,21 @@ deserialize_download_file (void *cls,
   ser = get_serialization_short_name (filename);
   rh = GNUNET_BIO_read_open (filename);
   if (rh == NULL)
-    {
-       if (0 != UNLINK (filename))
-         GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                   "unlink", 
-                                   filename);
-      GNUNET_free (ser);
-      return GNUNET_OK;
-    }
+  {
+    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 (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;
 }
 
@@ -2939,18 +2776,17 @@ deserialize_download_file (void *cls,
  */
 static void
 deserialization_master (const char *master_path,
-                        GNUNET_FileNameCallback proc,
-                        struct GNUNET_FS_Handle *h)
+                        GNUNET_FileNameCallback proc,
+                        struct GNUNET_FS_Handle *h)
 {
   char *dn;
 
   dn = get_serialization_file_name (h, master_path, "");
   if (dn == NULL)
     return;
-  if (GNUNET_YES ==
-      GNUNET_DISK_directory_test (dn))
+  if (GNUNET_YES == GNUNET_DISK_directory_test (dn))
     GNUNET_DISK_directory_scan (dn, proc, h);
-  GNUNET_free (dn); 
+  GNUNET_free (dn);
 }
 
 
@@ -2967,11 +2803,9 @@ deserialization_master (const char *master_path,
  */
 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,
-                 ...)
+                 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;
@@ -2985,42 +2819,40 @@ GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
   ret->flags = flags;
   ret->max_parallel_downloads = 1;
   ret->max_parallel_requests = 1;
-  ret->avg_block_latency = GNUNET_TIME_UNIT_MINUTES; /* conservative starting point */
-  va_start (ap, flags);  
+  ret->avg_block_latency = GNUNET_TIME_UNIT_MINUTES;    /* conservative starting point */
+  va_start (ap, flags);
   while (GNUNET_FS_OPTIONS_END != (opt = va_arg (ap, enum GNUNET_FS_OPTIONS)))
+  {
+    switch (opt)
     {
-      switch (opt)
-        {
-        case GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM:
-          ret->max_parallel_downloads = va_arg (ap, unsigned int);
-          break;
-        case GNUNET_FS_OPTIONS_REQUEST_PARALLELISM:
-          ret->max_parallel_requests = va_arg (ap, unsigned int);
-          break;
-        default:
-          GNUNET_break (0);
-          GNUNET_free (ret->client_name);
-          GNUNET_free (ret);
-          va_end (ap);
-          return NULL;
-        }
+    case GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM:
+      ret->max_parallel_downloads = va_arg (ap, unsigned int);
+
+      break;
+    case GNUNET_FS_OPTIONS_REQUEST_PARALLELISM:
+      ret->max_parallel_requests = va_arg (ap, unsigned int);
+
+      break;
+    default:
+      GNUNET_break (0);
+      GNUNET_free (ret->client_name);
+      GNUNET_free (ret);
+      va_end (ap);
+      return NULL;
     }
+  }
   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;
 }
 
@@ -3031,8 +2863,8 @@ GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
  * called after this function returns.
  *
  * @param h handle that was returned from GNUNET_FS_start
- */                    
-void 
+ */
+void
 GNUNET_FS_stop (struct GNUNET_FS_Handle *h)
 {
   while (h->top_head != NULL)
diff --git a/src/fs/fs.h b/src/fs/fs.h
index 954fe0599..1d3fc6611 100644
--- a/src/fs/fs.h
+++ b/src/fs/fs.h
@@ -240,7 +240,7 @@
 /**
  * @brief content hash key
  */
-struct ContentHashKey 
+struct ContentHashKey
 {
   /**
    * Hash of the original content, used for encryption.
@@ -307,27 +307,27 @@ struct Location
  * Types of URIs.
  */
 enum uri_types
-  { 
+{
     /**
      * Content-hash-key (simple file).
      */
-    chk, 
+  chk,
 
     /**
      * Signed key space (file in namespace).
      */
-    sks,
+  sks,
 
     /**
      * Keyword search key (query with keywords).
      */
-    ksk,
+  ksk,
 
     /**
      * Location (chk with identity of hosting peer).
      */
-    loc 
-  };
+  loc
+};
 
 /**
  * A Universal Resource Identifier (URI), opaque.
@@ -356,7 +356,7 @@ struct GNUNET_FS_Uri
        * (only in URI-strings).
        */
       char **keywords;
-      
+
       /**
        * Size of the keywords array.
        */
@@ -453,7 +453,7 @@ struct GNUNET_FS_FileInformation
    * using 'mktemp'.
    */
   char *serialization;
-  
+
   /**
    * Encoder being used to publish this file.
    */
@@ -478,7 +478,8 @@ struct GNUNET_FS_FileInformation
     /**
      * Data for a file.
      */
-    struct {
+    struct
+    {
 
       /**
        * Function that can be used to read the data for the file.
@@ -524,8 +525,9 @@ struct GNUNET_FS_FileInformation
     /**
      * Data for a directory.
      */
-    struct {
-      
+    struct
+    {
+
       /**
        * Linked list of entries in the directory.
        */
@@ -567,15 +569,15 @@ struct GNUNET_FS_FileInformation
  * @param cls closure
  * @param client handle to use for FS communication
  */
-typedef void (*GNUNET_FS_QueueStart)(void *cls,
-                                     struct GNUNET_CLIENT_Connection *client);
+typedef void (*GNUNET_FS_QueueStart) (void *cls,
+                                      struct GNUNET_CLIENT_Connection * client);
 
 
 /**
  * The job must now stop to run and should destry the client handle as
  * soon as possible (ideally prior to returning).
  */
-typedef void (*GNUNET_FS_QueueStop)(void *cls);
+typedef void (*GNUNET_FS_QueueStop) (void *cls);
 
 
 /**
@@ -610,7 +612,7 @@ struct GNUNET_FS_QueueEntry
 
   /**
    * Handle to FS primary context.
-   */ 
+   */
   struct GNUNET_FS_Handle *h;
 
   /**
@@ -757,20 +759,17 @@ struct GNUNET_FS_SearchResult
  * @param blocks number of blocks this download has
  * @return queue handle
  */
-struct GNUNET_FS_QueueEntry *
-GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
-                  GNUNET_FS_QueueStart start,
-                  GNUNET_FS_QueueStop stop,
-                  void *cls,
-                  unsigned int blocks);
+struct GNUNET_FS_QueueEntry *GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
+                                               GNUNET_FS_QueueStart start,
+                                               GNUNET_FS_QueueStop stop,
+                                               void *cls, unsigned int blocks);
 
 
 /**
  * Dequeue a job from the queue.
  * @param qh handle for the job
  */
-void
-GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qh);
+void GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qh);
 
 
 /**
@@ -790,11 +789,16 @@ GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qh);
  * @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);
 
 
 /**
@@ -803,8 +807,7 @@ GNUNET_FS_data_reader_file_(void *cls,
  * @param filename file to read
  * @return closure to use
  */
-void *
-GNUNET_FS_make_file_reader_context_ (const char *filename);
+void *GNUNET_FS_make_file_reader_context_ (const char *filename);
 
 
 
@@ -825,11 +828,9 @@ GNUNET_FS_make_file_reader_context_ (const char *filename);
  * @return number of bytes written, usually "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);
 
 /**
  * Notification of FS that a search probe has made progress.
@@ -846,9 +847,9 @@ GNUNET_FS_data_reader_copy_(void *cls,
  *         will be passed to future callbacks in the respective
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
-void*
-GNUNET_FS_search_probe_progress_ (void *cls,
-                                  const struct GNUNET_FS_ProgressInfo *info);
+void *GNUNET_FS_search_probe_progress_ (void *cls,
+                                        const struct GNUNET_FS_ProgressInfo
+                                        *info);
 
 
 /**
@@ -859,7 +860,7 @@ GNUNET_FS_search_probe_progress_ (void *cls,
  */
 void
 GNUNET_FS_publish_main_ (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc);
+                         const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -869,9 +870,8 @@ GNUNET_FS_publish_main_ (void *cls,
  * @param cls closure, unindex context
  * @param file_id computed hash, NULL on error
  */
-void 
-GNUNET_FS_unindex_process_hash_ (void *cls,
-                                 const GNUNET_HashCode *file_id);
+void
+GNUNET_FS_unindex_process_hash_ (void *cls, const GNUNET_HashCode * file_id);
 
 
 /**
@@ -884,11 +884,10 @@ GNUNET_FS_unindex_process_hash_ (void *cls,
  * @param offset where in the file are we so far
  * @return value returned from callback
  */
-void *
-GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
-                                struct GNUNET_FS_PublishContext *sc,
-                                const struct GNUNET_FS_FileInformation *p,
-                                uint64_t offset);
+void *GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                      struct GNUNET_FS_PublishContext *sc,
+                                      const struct GNUNET_FS_FileInformation *p,
+                                      uint64_t offset);
 
 
 /**
@@ -900,7 +899,7 @@ GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  */
 void
 GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
-                                 struct GNUNET_FS_DownloadContext *dc);
+                                 struct GNUNET_FS_DownloadContext *dc);
 
 
 /**
@@ -912,7 +911,7 @@ GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  */
 void
 GNUNET_FS_download_start_task_ (void *cls,
-                                const struct GNUNET_SCHEDULER_TaskContext *tc);
+                                const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 
@@ -926,8 +925,8 @@ GNUNET_FS_download_start_task_ (void *cls,
  */
 void
 GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
-                                struct GNUNET_FS_UnindexContext *uc,
-                                uint64_t offset);
+                                struct GNUNET_FS_UnindexContext *uc,
+                                uint64_t offset);
 
 /**
  * Fill in all of the generic fields for a search event and
@@ -937,9 +936,8 @@ GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  * @param sc overall search context
  * @return value returned by the callback
  */
-void *
-GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
-                               struct GNUNET_FS_SearchContext *sc);
+void *GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
+                                     struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -947,8 +945,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);
+void GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc);
 
 /**
  * Build the request and actually initiate the search using the
@@ -957,8 +954,7 @@ GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc);
  * @param sc search context
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
-int
-GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc);
+int GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc);
 
 /**
  * Start the downloading process (by entering the queue).
@@ -974,8 +970,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);
+void GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr);
 
 /**
  * Remove serialization/deserialization file from disk.
@@ -986,8 +981,7 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr);
  */
 void
 GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
-                             const char *ext,
-                             const char *ent);
+                             const char *ext, const char *ent);
 
 
 /**
@@ -999,8 +993,7 @@ GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
  */
 void
 GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
-                            const char *ext,
-                            const char *uni);
+                            const char *ext, const char *uni);
 
 
 /**
@@ -1011,8 +1004,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);
+void GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *f);
 
 /**
  * Synchronize this publishing struct with its mirror
@@ -1022,8 +1014,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);
+void GNUNET_FS_publish_sync_ (struct GNUNET_FS_PublishContext *pc);
 
 /**
  * Synchronize this unindex struct with its mirror
@@ -1033,8 +1024,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);
+void GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc);
 
 /**
  * Synchronize this search struct with its mirror
@@ -1044,8 +1034,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);
+void GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc);
 
 /**
  * Synchronize this search result with its mirror
@@ -1055,8 +1044,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);
+void GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr);
 
 /**
  * Synchronize this download struct with its mirror
@@ -1066,8 +1054,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);
+void GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc);
 
 /**
  * Create SUSPEND event for the given publish operation
@@ -1075,8 +1062,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);
+void GNUNET_FS_publish_signal_suspend_ (void *cls);
 
 /**
  * Create SUSPEND event for the given search operation
@@ -1084,8 +1070,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);
+void GNUNET_FS_search_signal_suspend_ (void *cls);
 
 /**
  * Create SUSPEND event for the given download operation
@@ -1093,8 +1078,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);
+void GNUNET_FS_download_signal_suspend_ (void *cls);
 
 /**
  * Create SUSPEND event for the given unindex operation
@@ -1102,8 +1086,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);
+void GNUNET_FS_unindex_signal_suspend_ (void *cls);
 
 /**
  * Function signature of the functions that can be called
@@ -1112,7 +1095,7 @@ GNUNET_FS_unindex_signal_suspend_ (void *cls);
  *
  * @param cls closure
  */
-typedef void (*SuspendSignalFunction)(void *cls);                                     
+typedef void (*SuspendSignalFunction) (void *cls);
 
 /**
  * We track all of the top-level activities of FS
@@ -1122,12 +1105,12 @@ struct TopLevelActivity
 {
   /**
    * This is a doubly-linked list.
-   */ 
+   */
   struct TopLevelActivity *next;
 
   /**
    * This is a doubly-linked list.
-   */  
+   */
   struct TopLevelActivity *prev;
 
   /**
@@ -1150,10 +1133,9 @@ struct TopLevelActivity
  * @param ssf_cls closure for ssf
  * @return fresh top-level activity handle
  */
-struct TopLevelActivity *
-GNUNET_FS_make_top (struct GNUNET_FS_Handle *h,
-                    SuspendSignalFunction ssf,
-                    void *ssf_cls);
+struct TopLevelActivity *GNUNET_FS_make_top (struct GNUNET_FS_Handle *h,
+                                             SuspendSignalFunction ssf,
+                                             void *ssf_cls);
 
 
 /**
@@ -1163,8 +1145,7 @@ 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);
 
 
 
@@ -1270,7 +1251,7 @@ struct GNUNET_FS_PublishContext
 {
   /**
    * Handle to the global fs context.
-   */ 
+   */
   struct GNUNET_FS_Handle *h;
 
   /**
@@ -1378,37 +1359,36 @@ struct GNUNET_FS_PublishContext
 
 /**
  * Phases of unindex processing (state machine).
- */ 
+ */
 enum UnindexState
-  {
+{
     /**
      * We're currently hashing the file.
      */
-    UNINDEX_STATE_HASHING = 0,
+  UNINDEX_STATE_HASHING = 0,
 
     /**
      * We're telling the datastore to delete
      * the respective entries.
      */
-    UNINDEX_STATE_DS_REMOVE = 1,
+  UNINDEX_STATE_DS_REMOVE = 1,
 
     /**
      * We're notifying the FS service about
      * the unindexing.
      */
-    UNINDEX_STATE_FS_NOTIFY = 2,
+  UNINDEX_STATE_FS_NOTIFY = 2,
 
     /**
      * We're done.
      */
-    UNINDEX_STATE_COMPLETE = 3,
+  UNINDEX_STATE_COMPLETE = 3,
 
     /**
      * We've encountered a fatal error.
      */
-    UNINDEX_STATE_ERROR = 4
-
-  };
+  UNINDEX_STATE_ERROR = 4
+};
 
 
 /**
@@ -1416,7 +1396,7 @@ enum UnindexState
  */
 struct GNUNET_FS_UnindexContext
 {
-  
+
   /**
    * Global FS context.
    */
@@ -1476,7 +1456,7 @@ struct GNUNET_FS_UnindexContext
 
   /**
    * Overall size of the file.
-   */ 
+   */
   uint64_t file_size;
 
   /**
@@ -1488,11 +1468,11 @@ struct GNUNET_FS_UnindexContext
    * Hash of the file's contents (once computed).
    */
   GNUNET_HashCode file_id;
- 
+
   /**
    * Current operatinonal phase.
    */
-  enum UnindexState state; 
+  enum UnindexState state;
 
 };
 
@@ -1512,7 +1492,7 @@ struct SearchRequestEntry
   /**
    * Hash of the public key, also known as the query.
    */
-  GNUNET_HashCode query;  
+  GNUNET_HashCode query;
 
   /**
    * Map that contains a "struct GNUNET_FS_SearchResult" for each result that
@@ -1592,7 +1572,7 @@ struct GNUNET_FS_SearchContext
    * have exactly as many entries as there were keywords.
    */
   struct SearchRequestEntry *requests;
-  
+
   /**
    * When did we start?
    */
@@ -1617,7 +1597,7 @@ struct GNUNET_FS_SearchContext
    * map have been passed to the service so far?
    */
   unsigned int keyword_offset;
-  
+
   /**
    * Anonymity level for the search.
    */
@@ -1631,7 +1611,7 @@ struct GNUNET_FS_SearchContext
   /**
    * Options for the search.
    */
-  enum GNUNET_FS_SearchOptions options;  
+  enum GNUNET_FS_SearchOptions options;
 };
 
 
@@ -1641,12 +1621,12 @@ struct GNUNET_FS_SearchContext
  * are documented in the comments.
  */
 enum BlockRequestState
-  {
+{
     /**
      * Initial state, block has only been allocated (since it is
      * relevant to the overall download request).
      */
-    BRS_INIT = 0,
+  BRS_INIT = 0,
 
     /**
      * We've checked the block on the path down the tree, and the
@@ -1654,7 +1634,7 @@ enum BlockRequestState
      * the way down, so at the bottom some blocks will still
      * need to be reconstructed).
      */
-    BRS_RECONSTRUCT_DOWN = 1,
+  BRS_RECONSTRUCT_DOWN = 1,
 
     /**
      * We've calculated the CHK bottom-up based on the meta data.
@@ -1662,7 +1642,7 @@ enum BlockRequestState
      * disk at the end (and we still need to check against the
      * CHK set on top).
      */
-    BRS_RECONSTRUCT_META_UP = 2,
+  BRS_RECONSTRUCT_META_UP = 2,
 
     /**
      * We've calculated the CHK bottom-up based on what we have on
@@ -1670,7 +1650,7 @@ enum BlockRequestState
      * reconstructed CHKs match whatever comes from above, we're
      * done with the respective subtree.
      */
-    BRS_RECONSTRUCT_UP = 3,
+  BRS_RECONSTRUCT_UP = 3,
 
     /**
      * We've determined the real, desired CHK for this block 
@@ -1679,7 +1659,7 @@ enum BlockRequestState
      * the top-level request, the state machine for the subtree
      * would have moved to BRS_DOWNLOAD_UP.
      */
-    BRS_CHK_SET = 4,
+  BRS_CHK_SET = 4,
 
     /**
      * We've successfully downloaded this block, but the children
@@ -1688,27 +1668,26 @@ enum BlockRequestState
      * state machine for this block may move to 
      * BRS_DOWNLOAD_ERROR instead.
      */
-    BRS_DOWNLOAD_DOWN = 5,
+  BRS_DOWNLOAD_DOWN = 5,
 
     /**
      * This block and all of its children have been downloaded
      * successfully (full completion propagates up).
      */
-    BRS_DOWNLOAD_UP = 6,
+  BRS_DOWNLOAD_UP = 6,
 
     /**
      * We got a block back that matched the query but did not hash to
      * the key (malicious publisher or hash collision); this block
      * can never be downloaded (error propagates up).
      */
-    BRS_ERROR = 7
-    
-  };
+  BRS_ERROR = 7
+};
 
 
 /**
  * Information about an active download request.
- */ 
+ */
 struct DownloadRequest
 {
   /**
@@ -1735,7 +1714,7 @@ struct DownloadRequest
    * CHK for the request for this block (set during reconstruction
    * to what we have on disk, later to what we want to have).
    */
-  struct ContentHashKey chk;  
+  struct ContentHashKey chk;
 
   /**
    * Offset of the corresponding block.  Specifically, first (!) byte of
@@ -1772,8 +1751,7 @@ struct DownloadRequest
  *
  * @param dr request to free
  */
-void
-GNUNET_FS_free_download_request_ (struct DownloadRequest *dr);
+void GNUNET_FS_free_download_request_ (struct DownloadRequest *dr);
 
 
 /**
@@ -1781,17 +1759,17 @@ GNUNET_FS_free_download_request_ (struct DownloadRequest *dr);
  */
 struct GNUNET_FS_DownloadContext
 {
-  
+
   /**
    * Global FS context.
-   */ 
+   */
   struct GNUNET_FS_Handle *h;
 
   /**
    * Our top-level activity entry (if we are top-level, otherwise NULL).
    */
   struct TopLevelActivity *top;
-  
+
   /**
    * Connection to the FS service.
    */
@@ -2019,7 +1997,7 @@ struct NamespaceUpdateNode
    * freshness of the tree_id.
    */
   unsigned int nug;
-  
+
   /**
    * TREE this entry belongs to (if nug is current).
    */
@@ -2035,7 +2013,7 @@ struct GNUNET_FS_Namespace
    * Handle to the FS service context.
    */
   struct GNUNET_FS_Handle *h;
-  
+
   /**
    * Array with information about nodes in the namespace.
    */
@@ -2059,7 +2037,7 @@ struct GNUNET_FS_Namespace
 
   /**
    * Name of the namespace.
-   */ 
+   */
   char *name;
 
   /**
@@ -2113,7 +2091,7 @@ struct IndexStartMessage
    * full hash recomputation.
    */
   uint64_t device GNUNET_PACKED;
-  
+
   /**
    * Inode of the file on the given device, as seen by the client
    * ("st_ino" field from "struct stat").  Use 0 if the OS does not
@@ -2128,8 +2106,8 @@ struct IndexStartMessage
   GNUNET_HashCode file_id;
 
   /* this is followed by a 0-terminated
-     filename of a file with the hash
-     "file_id" as seen by the client */
+   * filename of a file with the hash
+   * "file_id" as seen by the client */
 
 };
 
@@ -2157,9 +2135,9 @@ struct IndexInfoMessage
   GNUNET_HashCode file_id;
 
   /* this is followed by a 0-terminated
-     filename of a file with the hash
-     "file_id" as seen by the client */
-  
+   * filename of a file with the hash
+   * "file_id" as seen by the client */
+
 };
 
 
@@ -2245,10 +2223,10 @@ struct SearchMessage
   GNUNET_HashCode query;
 
   /* this is followed by the hash codes of already-known
-     results (which should hence be excluded from what
-     the service returns); naturally, this only applies
-     to queries that can have multiple results, such as
-     those for KBLOCKS (KSK) and SBLOCKS (SKS) */
+   * results (which should hence be excluded from what
+   * the service returns); naturally, this only applies
+   * to queries that can have multiple results, such as
+   * those for KBLOCKS (KSK) and SBLOCKS (SKS) */
 };
 
 
@@ -2333,10 +2311,10 @@ struct GetMessage
   GNUNET_HashCode query GNUNET_PACKED;
 
   /* this is followed by hash codes
-     as specified in the  "hash_bitmap";
-     after that, an optional bloomfilter
-     (with bits set for replies that should
-     be suppressed) can be present */
+   * as specified in the  "hash_bitmap";
+   * after that, an optional bloomfilter
+   * (with bits set for replies that should
+   * be suppressed) can be present */
 };
 
 
diff --git a/src/fs/fs_directory.c b/src/fs/fs_directory.c
index dbd10c35e..f22480d5f 100644
--- a/src/fs/fs_directory.c
+++ b/src/fs/fs_directory.c
@@ -50,20 +50,22 @@
  * @return GNUNET_YES if it is, GNUNET_NO if it is not, GNUNET_SYSERR if
  *  we have no mime-type information (treat as 'GNUNET_NO')
  */
-int 
-GNUNET_FS_meta_data_test_for_directory (const struct GNUNET_CONTAINER_MetaData *md)
+int
+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 (mime == NULL)
     return GNUNET_SYSERR;
   ret = (0 == strcmp (mime, GNUNET_FS_DIRECTORY_MIME)) ? GNUNET_YES : GNUNET_NO;
   GNUNET_free (mime);
-  return ret; 
+  return ret;
 }
 
 
@@ -77,29 +79,29 @@ void
 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);
+
+  mime =
+      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
 {
 
   /**
@@ -130,30 +132,26 @@ struct GetFullDataClosure
  * @param data actual meta-data found
  * @param data_len number of bytes in data
  * @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)
+                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);
-          memcpy (gfdc->data,
-                  data,
-                  data_len);
-        }
-      return 1;
+      gfdc->data = GNUNET_malloc (data_len);
+      memcpy (gfdc->data, data, data_len);
     }
+    return 1;
+  }
   return 0;
 }
 
@@ -183,12 +181,12 @@ find_full_data (void *cls,
  *         GNUNET_NO if this could be part of a directory (but not 100% OK)
  *         GNUNET_SYSERR if 'data' does not represent a directory
  */
-int 
+int
 GNUNET_FS_directory_list_contents (size_t size,
-                                   const void *data,
-                                   uint64_t offset,
-                                   GNUNET_FS_DirectoryEntryProcessor dep, 
-                                   void *dep_cls)
+                                   const void *data,
+                                   uint64_t offset,
+                                   GNUNET_FS_DirectoryEntryProcessor dep,
+                                   void *dep_cls)
 {
   struct GetFullDataClosure full_data;
   const char *cdata = data;
@@ -201,123 +199,110 @@ GNUNET_FS_directory_list_contents (size_t size,
   struct GNUNET_CONTAINER_MetaData *md;
   char *filename;
 
-  if ( (offset == 0) &&
-       ( (size < 8 + sizeof (uint32_t)) ||
-         (0 != memcmp (cdata, GNUNET_FS_DIRECTORY_MAGIC, 8)) ) )
+  if ((offset == 0) &&
+      ((size < 8 + sizeof (uint32_t)) ||
+       (0 != memcmp (cdata, GNUNET_FS_DIRECTORY_MAGIC, 8))))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("MAGIC mismatch.  This is not a GNUnet directory.\n"));
+    return GNUNET_SYSERR;
+  }
+  pos = offset;
+  if (offset == 0)
+  {
+    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"));
+                  _("MAGIC mismatch.  This is not a GNUnet directory.\n"));
       return GNUNET_SYSERR;
     }
-  pos = offset;
-  if (offset == 0) 
+    md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[8 +
+                                                        sizeof (uint32_t)],
+                                                 mdSize);
+    if (md == NULL)
     {
-      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;
+      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 (uri == NULL)
-        {
-          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 (uri == NULL)
+    {
+      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! */
+    }
 
-      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 */
-        }
+    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 (md == NULL)
-        {
-          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 (dep != NULL) 
-        {
-          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);
+    md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[pos], mdSize);
+    if (md == NULL)
+    {
       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 (dep != NULL)
+    {
+      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;
 }
 
@@ -330,7 +315,7 @@ struct BuilderEntry
    * This is a linked list.
    */
   struct BuilderEntry *next;
-  
+
   /**
    * Length of this entry.
    */
@@ -365,11 +350,12 @@ 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_malloc(sizeof(struct GNUNET_FS_DirectoryBuilder));
+  ret = GNUNET_malloc (sizeof (struct GNUNET_FS_DirectoryBuilder));
   if (mdir != NULL)
     ret->meta = GNUNET_CONTAINER_meta_data_duplicate (mdir);
   else
@@ -391,9 +377,9 @@ GNUNET_FS_directory_builder_create (const struct GNUNET_CONTAINER_MetaData *mdir
  */
 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)
+                                 const struct GNUNET_FS_Uri *uri,
+                                 const struct GNUNET_CONTAINER_MetaData *md,
+                                 const void *data)
 {
   struct GNUNET_FS_Uri *curi;
   struct BuilderEntry *e;
@@ -409,68 +395,64 @@ 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 */
+    fsize = 0;                  /* too large */
   uris = GNUNET_FS_uri_to_string (uri);
   slen = strlen (uris) + 1;
-  mds =
-    GNUNET_CONTAINER_meta_data_get_serialized_size (md);  
+  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];
+  e = GNUNET_malloc (sizeof (struct BuilderEntry) +
+                     slen + mds + sizeof (uint32_t));
+  ser = (char *) &e[1];
   memcpy (ser, uris, slen);
   GNUNET_free (uris);
-  sptr = &ser[slen + sizeof(uint32_t)];
+  sptr = &ser[slen + sizeof (uint32_t)];
   ret = GNUNET_CONTAINER_meta_data_serialize (meta_use,
-                                              &sptr,
-                                              mds,
-                                              GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+                                              &sptr,
+                                              mds,
+                                              GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (NULL != meta)
     GNUNET_CONTAINER_meta_data_destroy (meta);
   if (ret == -1)
@@ -492,11 +474,10 @@ 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;
-  
+
   align = (end_position / DBLOCK_SIZE) * DBLOCK_SIZE;
   if ((start_position < align) && (end_position > align))
     return align + end_position - start_position;
@@ -515,9 +496,7 @@ do_align (size_t start_position,
  */
 static void
 block_align (size_t start,
-             unsigned int count, 
-             const size_t *sizes,
-             unsigned int *perm)
+             unsigned int count, const size_t * sizes, unsigned int *perm)
 {
   unsigned int i;
   unsigned int j;
@@ -531,51 +510,46 @@ block_align (size_t start,
 
   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);
+  }
 }
 
 
@@ -591,8 +565,7 @@ block_align (size_t start,
  */
 int
 GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
-                                    size_t *rsize,
-                                    void **rdata)
+                                    size_t * rsize, void **rdata)
 {
   char *data;
   char *sptr;
@@ -614,71 +587,65 @@ GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
   perm = NULL;
   bes = NULL;
   if (0 < bld->count)
+  {
+    sizes = GNUNET_malloc (bld->count * sizeof (size_t));
+    perm = GNUNET_malloc (bld->count * sizeof (unsigned int));
+    bes = GNUNET_malloc (bld->count * sizeof (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++)
     {
-      sizes = GNUNET_malloc (bld->count * sizeof (size_t));
-      perm = GNUNET_malloc (bld->count * sizeof (unsigned int));
-      bes = GNUNET_malloc (bld->count * sizeof (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);
-        }
+      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;
-    }
+  {
+    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;
   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);
+                                              &sptr,
+                                              size - off - sizeof (uint32_t),
+                                              GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
   GNUNET_assert (ret != -1);
-  big = htonl (ret);  
+  big = htonl (ret);
   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);
-      memcpy (&data[off - sizes[i]], 
-              &(bes[i])[1],
-              sizes[i]);
-      GNUNET_free (bes[i]);
-    }
+  {
+    i = perm[j];
+    psize = off;
+    off += sizes[i];
+    off = do_align (psize, off);
+    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_assert (off == size);
   GNUNET_CONTAINER_meta_data_destroy (bld->meta);
   GNUNET_free (bld);
   return GNUNET_OK;
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index e515b147d..6b72b4e56 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -40,14 +40,15 @@
 static int
 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)) ||
-      ( (dc->meta == NULL) &&
-        ( (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)) ) ) ) );              
+  return (0 != (dc->options & GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE)) &&
+      ((GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (dc->meta)) ||
+       ((dc->meta == NULL) &&
+        ((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))))));
 }
 
 
@@ -68,31 +69,31 @@ 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"? */
-  uint64_t loff; /* where do IBlocks for depth "i" start? */
-  unsigned int ioff; /* which IBlock corresponds to "off" at depth "i"? */
-  
+  uint64_t lsize;               /* what is the size of all IBlocks for depth "i"? */
+  uint64_t loff;                /* where do IBlocks for depth "i" start? */
+  unsigned int ioff;            /* which IBlock corresponds to "off" at depth "i"? */
+
   if (depth == 0)
     return off;
   /* first IBlocks start at the end of file, rounded up
-     to full DBLOCK_SIZE */
+   * to full DBLOCK_SIZE */
   loff = ((fsize + DBLOCK_SIZE - 1) / DBLOCK_SIZE) * DBLOCK_SIZE;
-  lsize = ( (fsize + DBLOCK_SIZE - 1) / DBLOCK_SIZE) * sizeof (struct ContentHashKey);
+  lsize =
+      ((fsize + DBLOCK_SIZE -
+        1) / DBLOCK_SIZE) * sizeof (struct ContentHashKey);
   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;
-    }
+  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;
+  }
   return loff + ioff * sizeof (struct ContentHashKey);
 }
 
@@ -106,38 +107,28 @@ compute_disk_offset (uint64_t fsize,
  */
 void
 GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
-                                 struct GNUNET_FS_DownloadContext *dc)
+                                 struct GNUNET_FS_DownloadContext *dc)
 {
   pi->value.download.dc = dc;
-  pi->value.download.cctx
-    = dc->client_info;
+  pi->value.download.cctx = dc->client_info;
   pi->value.download.pctx
-    = (dc->parent == NULL) ? NULL : dc->parent->client_info;
+      = (dc->parent == NULL) ? NULL : dc->parent->client_info;
   pi->value.download.sctx
-    = (dc->search == NULL) ? NULL : dc->search->client_info;
-  pi->value.download.uri 
-    = dc->uri;
-  pi->value.download.filename
-    = dc->filename;
-  pi->value.download.size
-    = dc->length;
+      = (dc->search == NULL) ? NULL : dc->search->client_info;
+  pi->value.download.uri = dc->uri;
+  pi->value.download.filename = dc->filename;
+  pi->value.download.size = dc->length;
   pi->value.download.duration
-    = GNUNET_TIME_absolute_get_duration (dc->start_time);
-  pi->value.download.completed
-    = dc->completed;
-  pi->value.download.anonymity
-    = dc->anonymity;
+      = 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 = (dc->client == NULL) ? GNUNET_NO : GNUNET_YES;
   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);
 }
 
 
@@ -152,10 +143,7 @@ GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  * @param buf where the callee should write the message
  * @return number of bytes written to buf
  */
-static size_t
-transmit_download_request (void *cls,
-                           size_t size, 
-                           void *buf);
+static size_t transmit_download_request (void *cls, size_t size, void *buf);
 
 
 /**
@@ -163,7 +151,7 @@ transmit_download_request (void *cls,
  */
 struct ProcessResultClosure
 {
-  
+
   /**
    * Hash of data.
    */
@@ -171,14 +159,14 @@ struct ProcessResultClosure
 
   /**
    * Data found in P2P network.
-   */ 
+   */
   const void *data;
 
   /**
    * Our download context.
    */
   struct GNUNET_FS_DownloadContext *dc;
-                
+
   /**
    * Number of bytes in data.
    */
@@ -193,7 +181,7 @@ struct ProcessResultClosure
    * Flag to indicate if this block should be stored on disk.
    */
   int do_store;
-  
+
 };
 
 
@@ -208,8 +196,7 @@ struct ProcessResultClosure
  */
 static int
 process_result_with_request (void *cls,
-                             const GNUNET_HashCode * key,
-                             void *value);
+                             const GNUNET_HashCode * key, void *value);
 
 
 /**
@@ -227,53 +214,42 @@ process_result_with_request (void *cls,
  */
 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)
+                        const struct ContentHashKey *chk,
+                        struct DownloadRequest *dr,
+                        const char *block, size_t len, int do_store)
 {
   struct ProcessResultClosure prc;
   char enc[len];
   struct GNUNET_CRYPTO_AesSessionKey sk;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
   GNUNET_HashCode query;
-  
+
   GNUNET_CRYPTO_hash_to_aes_key (&chk->key, &sk, &iv);
-  if (-1 == GNUNET_CRYPTO_aes_encrypt (block, len,
-                                       &sk,
-                                       &iv,
-                                       enc))
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+  if (-1 == GNUNET_CRYPTO_aes_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 (GNUNET_HashCode)))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+  if (0 != memcmp (&query, &chk->query, sizeof (GNUNET_HashCode)))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Matching block for `%s' at offset %llu already present, no need for download!\n",
-              dc->filename,
-              (unsigned long long) dr->offset);
+              "Matching block for `%s' at offset %llu already present, no need for download!\n",
+              dc->filename, (unsigned long long) dr->offset);
 #endif
   /* already got it! */
   prc.dc = dc;
   prc.data = enc;
   prc.size = len;
-  prc.type = (0 == dr->depth) 
-    ? GNUNET_BLOCK_TYPE_FS_DBLOCK 
-    : GNUNET_BLOCK_TYPE_FS_IBLOCK;
+  prc.type = (0 == dr->depth)
+      ? GNUNET_BLOCK_TYPE_FS_DBLOCK : GNUNET_BLOCK_TYPE_FS_IBLOCK;
   prc.query = chk->query;
   prc.do_store = do_store;
-  process_result_with_request (&prc,
-                               &chk->key,
-                               dr);
+  process_result_with_request (&prc, &chk->key, dr);
   return GNUNET_OK;
 }
 
@@ -285,8 +261,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);
+static void try_reconnect (struct GNUNET_FS_DownloadContext *dc);
 
 
 /**
@@ -300,13 +275,12 @@ try_reconnect (struct GNUNET_FS_DownloadContext *dc);
  * @param length number of bytes in data
  * @param data contents of the file (or NULL if they were not inlined)
  */
-static void 
+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);
+                            const char *filename,
+                            const struct GNUNET_FS_Uri *uri,
+                            const struct GNUNET_CONTAINER_MetaData *meta,
+                            size_t length, const void *data);
 
 
 /**
@@ -323,55 +297,51 @@ full_recursive_download (struct GNUNET_FS_DownloadContext *dc)
   void *data;
   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;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Recursive downloads of directories larger than 4 GB are not supported on 32-bit systems\n"));
+    return;
+  }
   if (dc->filename != NULL)
-    {
-      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 (dc->temp_filename != NULL);
-      h = GNUNET_DISK_file_open (dc->temp_filename,
-                                 GNUNET_DISK_OPEN_READ,
-                                 GNUNET_DISK_PERM_NONE);
-    }
+  {
+    GNUNET_assert (dc->temp_filename != NULL);
+    h = GNUNET_DISK_file_open (dc->temp_filename,
+                               GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE);
+  }
   if (h == NULL)
-    return; /* oops */
+    return;                     /* oops */
   data = GNUNET_DISK_file_map (h, &m, GNUNET_DISK_MAP_TYPE_READ, size);
   if (data == NULL)
-    {
-      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
-    {
-      GNUNET_FS_directory_list_contents (size,
-                                         data,
-                                         0,
-                                         &trigger_recursive_download,
-                                         dc);         
-      GNUNET_DISK_file_unmap (m);
-    }
+  {
+    GNUNET_FS_directory_list_contents (size,
+                                       data,
+                                       0, &trigger_recursive_download, dc);
+    GNUNET_DISK_file_unmap (m);
+  }
   GNUNET_DISK_file_close (h);
   if (dc->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;
-    }
+  {
+    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;
+  }
 }
 
 
@@ -392,28 +362,25 @@ check_completed (struct GNUNET_FS_DownloadContext *dc)
   struct GNUNET_FS_DownloadContext *pos;
 
   /* first, check if we need to download children */
-  if ( (dc->child_head == NULL) &&
-       (is_recursive_download (dc)) )
-    full_recursive_download (dc);  
+  if ((dc->child_head == NULL) && (is_recursive_download (dc)))
+    full_recursive_download (dc);
   /* then, check if children are done already */
   pos = dc->child_head;
   while (pos != NULL)
-    {
-      if ( (pos->emsg == NULL) &&
-           (pos->completed < pos->length) )
-        return; /* not done yet */
-      if ( (pos->child_head != NULL) &&
-           (pos->has_finished != GNUNET_YES) )
-        return; /* not transitively done yet */
-      pos = pos->next;
-    }
+  {
+    if ((pos->emsg == NULL) && (pos->completed < pos->length))
+      return;                   /* not done yet */
+    if ((pos->child_head != NULL) && (pos->has_finished != GNUNET_YES))
+      return;                   /* not transitively done yet */
+    pos = pos->next;
+  }
   /* All of our children are done, so mark this download done */
   dc->has_finished = GNUNET_YES;
   if (dc->job_queue != NULL)
-    {
-      GNUNET_FS_dequeue_ (dc->job_queue);
-      dc->job_queue = NULL;
-    }
+  {
+    GNUNET_FS_dequeue_ (dc->job_queue);
+    dc->job_queue = NULL;
+  }
   GNUNET_FS_download_sync_ (dc);
 
   /* signal completion */
@@ -422,7 +389,7 @@ check_completed (struct GNUNET_FS_DownloadContext *dc)
 
   /* let parent know */
   if (dc->parent != NULL)
-    check_completed (dc->parent);  
+    check_completed (dc->parent);
 }
 
 
@@ -435,12 +402,10 @@ check_completed (struct GNUNET_FS_DownloadContext *dc)
  * @param dr download request to match against
  * @param data plaintext data, starting from the beginning of the file
  * @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)
+                 struct DownloadRequest *dr, const char *data, size_t data_len)
 {
   struct GNUNET_FS_ProgressInfo pi;
   unsigned int i;
@@ -456,134 +421,112 @@ try_match_block (struct GNUNET_FS_DownloadContext *dc,
   const char *fn;
   const char *odata;
   size_t odata_len;
-  
+
   odata = data;
   odata_len = data_len;
   if (BRS_DOWNLOAD_UP == dr->state)
     return;
   if (dr->depth > 0)
+  {
+    complete = GNUNET_YES;
+    for (i = 0; i < dr->num_children; i++)
     {
-      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);
+      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);
+  }
   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);
+  {
+    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_aes_encrypt (&data[dr->offset], dlen,
-                                       &sk,
-                                       &iv,
-                                       enc))
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if (-1 == GNUNET_CRYPTO_aes_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;
+  {
+  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;
-    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 = dc->filename != NULL 
-        ? dc->filename 
-        : dc->temp_filename;
-      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 (fh == NULL)
-        {
-          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;
-        }
+    }
+    /* write block to disk */
+    fn = dc->filename != NULL ? dc->filename : dc->temp_filename;
+    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 (fh == NULL)
+    {
+      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);
-      /* 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;
+      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);
-      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;
+      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;
+    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;
+  }
 }
 
 
@@ -604,34 +547,28 @@ try_match_block (struct GNUNET_FS_DownloadContext *dc,
  * @param data actual meta-data found
  * @param data_len number of bytes in data
  * @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)
+                 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 (type != EXTRACTOR_METATYPE_GNUNET_FULL_DATA) 
+  if (type != EXTRACTOR_METATYPE_GNUNET_FULL_DATA)
     return 0;
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Found %u bytes of FD!\n",
-              (unsigned int) data_len);
+              "Found %u bytes of FD!\n", (unsigned int) data_len);
 #endif
   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_break_op (0);
+    return 1;                   /* bogus meta data */
+  }
+  try_match_block (dc, dc->top_request, data, data_len);
   return 1;
 }
 
@@ -648,15 +585,15 @@ propagate_up (struct DownloadRequest *dr)
   unsigned int i;
 
   do
-    {
-      dr->state = BRS_DOWNLOAD_UP;
-      dr = dr->parent;
-      if (dr == NULL)
-        break;
-      for (i=0;i<dr->num_children;i++)
-        if (dr->children[i]->state != BRS_DOWNLOAD_UP)
-          break;
-    }
+  {
+    dr->state = BRS_DOWNLOAD_UP;
+    dr = dr->parent;
+    if (dr == NULL)
+      break;
+    for (i = 0; i < dr->num_children; i++)
+      if (dr->children[i]->state != BRS_DOWNLOAD_UP)
+        break;
+  }
   while (i == dr->num_children);
 }
 
@@ -673,7 +610,7 @@ propagate_up (struct DownloadRequest *dr)
  */
 static void
 try_top_down_reconstruction (struct GNUNET_FS_DownloadContext *dc,
-                             struct DownloadRequest *dr)
+                             struct DownloadRequest *dr)
 {
   uint64_t off;
   char block[DBLOCK_SIZE];
@@ -686,87 +623,66 @@ try_top_down_reconstruction (struct GNUNET_FS_DownloadContext *dc,
   uint64_t child_block_size;
   const struct ContentHashKey *chks;
   int up_done;
-  
+
   GNUNET_assert (dc->rfh != NULL);
   GNUNET_assert (dr->state == BRS_CHK_SET);
   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);
+  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 */
-    }
+  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 (GNUNET_HashCode)))
-    return; /* mismatch */
+  if (0 != memcmp (&key, &dr->chk.key, sizeof (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 (dr->parent != NULL)
     {
-      /* hash matches but encrypted block does not, really bad */
+      dr = dr->parent;
       dr->state = BRS_ERROR;
-      /* propagate up */
-      while (dr->parent != NULL)
-        {
-          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;
-  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);
-      chk_off = (drc->offset - dr->offset) / child_block_size;
-      if (drc->state == BRS_INIT)       
-        {
-          drc->state = BRS_CHK_SET;
-          drc->chk = chks[chk_off];
-          try_top_down_reconstruction (dc, drc);
-        }
-      if (drc->state != BRS_DOWNLOAD_UP)
-        up_done = GNUNET_NO; /* children not all done */
-    } 
+  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);
+    chk_off = (drc->offset - dr->offset) / child_block_size;
+    if (drc->state == BRS_INIT)
+    {
+      drc->state = BRS_CHK_SET;
+      drc->chk = chks[chk_off];
+      try_top_down_reconstruction (dc, drc);
+    }
+    if (drc->state != BRS_DOWNLOAD_UP)
+      up_done = GNUNET_NO;      /* children not all done */
+  }
   if (up_done == GNUNET_YES)
-    propagate_up (dr); /* children all done (or no children...) */
+    propagate_up (dr);          /* children all done (or no children...) */
 }
 
 
@@ -778,67 +694,63 @@ try_top_down_reconstruction (struct GNUNET_FS_DownloadContext *dc,
  */
 static void
 schedule_block_download (struct GNUNET_FS_DownloadContext *dc,
-                         struct DownloadRequest *dr)
+                         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_DOWNLOAD_UP:
-      /* We're done! */
-      return;
-    case BRS_ERROR:
-      GNUNET_break (0);
-      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_ERROR:
+    GNUNET_break (0);
+    return;
+  }
 #if DEBUG_DOWNLOAD
   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));
+              "Scheduling download at offset %llu and depth %u for `%s'\n",
+              (unsigned long long) dr->offset,
+              dr->depth, GNUNET_h2s (&dr->chk.query));
 #endif
   if (GNUNET_NO !=
       GNUNET_CONTAINER_multihashmap_contains_value (dc->active,
-                                                    &dr->chk.query,
-                                                    dr))
-    return; /* already active */
+                                                    &dr->chk.query, dr))
+    return;                     /* already active */
   GNUNET_CONTAINER_multihashmap_put (dc->active,
-                                     &dr->chk.query,
-                                     dr,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+                                     &dr->chk.query,
+                                     dr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   if (dc->client == NULL)
-    return; /* download not active */
-  GNUNET_CONTAINER_DLL_insert (dc->pending_head,
-                               dc->pending_tail,
-                               dr);
+    return;                     /* download not active */
+  GNUNET_CONTAINER_DLL_insert (dc->pending_head, dc->pending_tail, dr);
   dr->is_pending = GNUNET_YES;
   if (NULL == dc->th)
     dc->th = GNUNET_CLIENT_notify_transmit_ready (dc->client,
-                                                  sizeof (struct SearchMessage),
-                                                  GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                  GNUNET_NO,
-                                                  &transmit_download_request,
-                                                  dc);
+                                                  sizeof (struct SearchMessage),
+                                                  GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                                  GNUNET_NO,
+                                                  &transmit_download_request,
+                                                  dc);
 }
 
 
@@ -855,15 +767,14 @@ schedule_block_download (struct GNUNET_FS_DownloadContext *dc,
  * @param length number of bytes in data
  * @param data contents of the file (or NULL if they were not inlined)
  */
-static void 
+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)
+                            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 *dc = cls;
   struct GNUNET_FS_DownloadContext *cpos;
   char *temp_name;
   char *fn;
@@ -875,129 +786,116 @@ trigger_recursive_download (void *cls,
   char *sfn;
 
   if (NULL == uri)
-    return; /* entry for the directory itself */
+    return;                     /* entry for the directory itself */
   cpos = dc->child_head;
   while (cpos != NULL)
-    {
-      if ( (GNUNET_FS_uri_test_equal (uri,
-                                      cpos->uri)) ||
-           ( (filename != NULL) &&
-             (0 == strcmp (cpos->filename,
-                           filename)) ) )
-        break;  
-      cpos = cpos->next;
-    }
+  {
+    if ((GNUNET_FS_uri_test_equal (uri,
+                                   cpos->uri)) ||
+        ((filename != NULL) && (0 == strcmp (cpos->filename, filename))))
+      break;
+    cpos = cpos->next;
+  }
   if (cpos != NULL)
-    return; /* already exists */
+    return;                     /* already exists */
   fn = NULL;
   if (NULL == filename)
-    {
-      fn = GNUNET_FS_meta_data_suggest_filename (meta);
-      if (fn == NULL)
-        {
-          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 (fn == NULL)
+    {
+      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 (dc->filename == NULL)
-    {
-      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);
-    }
-  if ( (full_name != NULL) &&
-       (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;
-    }
+  {
+    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 ((full_name != NULL) &&
+      (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;
 #if DEBUG_DOWNLOAD
   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));
+              "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));
 #endif
   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);
+                            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);
@@ -1016,7 +914,7 @@ GNUNET_FS_free_download_request_ (struct DownloadRequest *dr)
 
   if (dr == NULL)
     return;
-  for (i=0;i<dr->num_children;i++)
+  for (i = 0; i < dr->num_children; i++)
     GNUNET_FS_free_download_request_ (dr->children[i]);
   GNUNET_free_non_null (dr->children);
   GNUNET_free (dr);
@@ -1034,8 +932,7 @@ GNUNET_FS_free_download_request_ (struct DownloadRequest *dr)
  */
 static int
 process_result_with_request (void *cls,
-                             const GNUNET_HashCode *key,
-                             void *value)
+                             const GNUNET_HashCode * key, void *value)
 {
   struct ProcessResultClosure *prc = cls;
   struct DownloadRequest *dr = value;
@@ -1054,152 +951,132 @@ process_result_with_request (void *cls,
 
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received block `%s' matching pending request at depth %u and offset %llu/%llu\n",
-              GNUNET_h2s (key),
-              dr->depth,
-              (unsigned long long) dr->offset,
-              (unsigned long long) GNUNET_ntohll (dc->uri->data.chk.file_length));
-              
+              "Received block `%s' matching pending request at depth %u and offset %llu/%llu\n",
+              GNUNET_h2s (key),
+              dr->depth,
+              (unsigned long long) dr->offset,
+              (unsigned long long) GNUNET_ntohll (dc->uri->data.
+                                                  chk.file_length));
+
 #endif
-  bs = GNUNET_FS_tree_calculate_block_size (GNUNET_ntohll (dc->uri->data.chk.file_length),
-                                            dr->offset,
-                                            dr->depth);
+  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)\n"),
+                     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", dc->emsg);
+    while (dr->parent != NULL)
     {
-      GNUNET_asprintf (&dc->emsg,
-                       _("Internal error or bogus download URI (expected %u bytes at depth %u and offset %llu/%llu, got %u bytes)\n"),
-                       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", 
-                  dc->emsg);
-      while (dr->parent != NULL)
-        {
-          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);
+  (void) GNUNET_CONTAINER_multihashmap_remove (dc->active, &prc->query, dr);
   if (GNUNET_YES == dr->is_pending)
-    {
-      GNUNET_CONTAINER_DLL_remove (dc->pending_head,
-                                   dc->pending_tail,
-                                   dr);
-      dr->is_pending = GNUNET_NO;
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (dc->pending_head, dc->pending_tail, dr);
+    dr->is_pending = GNUNET_NO;
+  }
 
 
   GNUNET_CRYPTO_hash_to_aes_key (&dr->chk.key, &skey, &iv);
-  if (-1 == GNUNET_CRYPTO_aes_decrypt (prc->data,
-                                       prc->size,
-                                       &skey,
-                                       &iv,
-                                       pt))
-    {
-      GNUNET_break (0);
-      dc->emsg = GNUNET_strdup (_("internal error decrypting content"));
-      goto signal_error;
-    }
+  if (-1 == GNUNET_CRYPTO_aes_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);
+                             dr->offset, dr->depth);
   /* save to disk */
-  if ( ( GNUNET_YES == prc->do_store) &&
-       ( (dc->filename != NULL) ||
-         (is_recursive_download (dc)) ) &&
-       ( (dr->depth == dc->treedepth) ||
-         (0 == (dc->options & GNUNET_FS_DOWNLOAD_NO_TEMPORARIES)) ) )
+  if ((GNUNET_YES == prc->do_store) &&
+      ((dc->filename != NULL) ||
+       (is_recursive_download (dc))) &&
+      ((dr->depth == dc->treedepth) ||
+       (0 == (dc->options & GNUNET_FS_DOWNLOAD_NO_TEMPORARIES))))
+  {
+    fh = GNUNET_DISK_file_open (dc->filename != NULL
+                                ? 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)
     {
-      fh = GNUNET_DISK_file_open (dc->filename != NULL 
-                                  ? 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\n"),
-                           dc->filename,
-                           STRERROR (errno));
-          goto signal_error;
-        }      
+      GNUNET_asprintf (&dc->emsg,
+                       _("Download failed: could not open file `%s': %s\n"),
+                       dc->filename, STRERROR (errno));
+      goto signal_error;
+    }
 #if DEBUG_DOWNLOAD
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Saving decrypted block to disk at offset %llu\n",
-                  (unsigned long long) off);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Saving decrypted block to disk at offset %llu\n",
+                (unsigned long long) off);
 #endif
-      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\n"),
-                           (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\n"),
-                           (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;
+    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\n"),
+                       (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\n"),
+                       (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;
+  }
 
-  if (dr->depth == 0) 
+  if (dr->depth == 0)
+  {
+    /* DBLOCK, update progress and try recursion if applicable */
+    app = prc->size;
+    if (dr->offset < dc->offset)
     {
-      /* 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);         
-            
+      /* 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);
+
+  }
   dr->state = BRS_DOWNLOAD_DOWN;
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_PROGRESS;
   pi.value.download.specifics.progress.data = pt;
@@ -1208,84 +1085,83 @@ process_result_with_request (void *cls,
   pi.value.download.specifics.progress.depth = dr->depth;
   GNUNET_FS_download_make_status_ (&pi, dc);
   GNUNET_assert (dc->completed <= dc->length);
-  if (dr->depth == 0) 
+  if (dr->depth == 0)
     propagate_up (dr);
 
   if (dc->completed == dc->length)
-    {
-      /* download completed, signal */
+  {
+    /* download completed, signal */
 #if DEBUG_DOWNLOAD
-      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));
+    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));
 #endif
-      /* truncate file to size (since we store IBlocks at the end) */
-      if (dc->filename != NULL)
-        {
-          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 (dr->depth == 0);
-      check_completed (dc);
-    }
-  if (dr->depth == 0) 
+    /* truncate file to size (since we store IBlocks at the end) */
+    if (dc->filename != NULL)
     {
-      /* bottom of the tree, no child downloads possible, just sync */
-      GNUNET_FS_download_sync_ (dc);
-      return GNUNET_YES;
+      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 (dr->depth == 0);
+    check_completed (dc);
+  }
+  if (dr->depth == 0)
+  {
+    /* bottom of the tree, no child downloads possible, just sync */
+    GNUNET_FS_download_sync_ (dc);
+    return GNUNET_YES;
+  }
 
 #if DEBUG_DOWNLOAD
   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);
+              "Triggering downloads of children (this block was at depth %u and offset %llu)\n",
+              dr->depth, (unsigned long long) dr->offset);
 #endif
-  GNUNET_assert (0 == (prc->size % sizeof(struct ContentHashKey)));
-  chkarr = (struct ContentHashKey*) pt;
-  for (i=(prc->size / sizeof(struct ContentHashKey))-1;i>=0;i--)
+  GNUNET_assert (0 == (prc->size % sizeof (struct ContentHashKey)));
+  chkarr = (struct ContentHashKey *) pt;
+  for (i = (prc->size / sizeof (struct ContentHashKey)) - 1; i >= 0; i--)
+  {
+    drc = dr->children[i];
+    switch (drc->state)
     {
-      drc = dr->children[i];
-      switch (drc->state)
-        {
-        case BRS_INIT:
-          drc->chk = chkarr[i];
-          drc->state = BRS_CHK_SET;
-          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:
+      drc->chk = chkarr[i];
+      drc->state = BRS_CHK_SET;
+      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);
   return GNUNET_YES;
 
- signal_error:
+signal_error:
   if (fh != NULL)
     GNUNET_DISK_file_close (fh);
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_ERROR;
@@ -1293,10 +1169,10 @@ process_result_with_request (void *cls,
   GNUNET_FS_download_make_status_ (&pi, dc);
   /* abort all pending requests */
   if (NULL != dc->th)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
-      dc->th = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
+    dc->th = NULL;
+  }
   GNUNET_CLIENT_disconnect (dc->client, GNUNET_NO);
   dc->in_receive = GNUNET_NO;
   dc->client = NULL;
@@ -1321,9 +1197,7 @@ process_result_with_request (void *cls,
  */
 static void
 process_result (struct GNUNET_FS_DownloadContext *dc,
-                enum GNUNET_BLOCK_Type type,
-                const void *data,
-                size_t size)
+                enum GNUNET_BLOCK_Type type, const void *data, size_t size)
 {
   struct ProcessResultClosure prc;
 
@@ -1335,14 +1209,13 @@ process_result (struct GNUNET_FS_DownloadContext *dc,
   GNUNET_CRYPTO_hash (data, size, &prc.query);
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received result for query `%s' from `%s'-service\n",
-              GNUNET_h2s (&prc.query),
-              "FS");
+              "Received result for query `%s' from `%s'-service\n",
+              GNUNET_h2s (&prc.query), "FS");
 #endif
   GNUNET_CONTAINER_multihashmap_get_multiple (dc->active,
-                                              &prc.query,
-                                              &process_result_with_request,
-                                              &prc);
+                                              &prc.query,
+                                              &process_result_with_request,
+                                              &prc);
 }
 
 
@@ -1353,35 +1226,30 @@ process_result (struct GNUNET_FS_DownloadContext *dc,
  * @param cls closure
  * @param msg message received, NULL on timeout or fatal error
  */
-static void 
-receive_results (void *cls,
-                 const struct GNUNET_MessageHeader * msg)
+static void
+receive_results (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   const struct PutMessage *cm;
   uint16_t msize;
 
-  if ( (NULL == msg) ||
-       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_PUT) ||
-       (sizeof (struct PutMessage) > ntohs(msg->size)) )
-    {
-      GNUNET_break (msg == NULL);       
-      try_reconnect (dc);
-      return;
-    }
-  msize = ntohs(msg->size);
-  cm = (const struct PutMessage*) msg;
-  process_result (dc, 
-                  ntohl (cm->type),
-                  &cm[1],
-                  msize - sizeof (struct PutMessage));
+  if ((NULL == msg) ||
+      (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_PUT) ||
+      (sizeof (struct PutMessage) > ntohs (msg->size)))
+  {
+    GNUNET_break (msg == NULL);
+    try_reconnect (dc);
+    return;
+  }
+  msize = ntohs (msg->size);
+  cm = (const struct PutMessage *) msg;
+  process_result (dc,
+                  ntohl (cm->type), &cm[1], msize - sizeof (struct PutMessage));
   if (dc->client == NULL)
-    return; /* fatal error */
+    return;                     /* fatal error */
   /* continue receiving */
   GNUNET_CLIENT_receive (dc->client,
-                         &receive_results,
-                         dc,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &receive_results, dc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -1398,9 +1266,7 @@ receive_results (void *cls,
  * @return number of bytes written to buf
  */
 static size_t
-transmit_download_request (void *cls,
-                           size_t size, 
-                           void *buf)
+transmit_download_request (void *cls, size_t size, void *buf)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   size_t msize;
@@ -1409,65 +1275,60 @@ transmit_download_request (void *cls,
 
   dc->th = NULL;
   if (NULL == buf)
-    {
+  {
 #if DEBUG_DOWNLOAD
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting download request failed, trying to reconnect\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting download request failed, trying to reconnect\n");
 #endif
-      try_reconnect (dc);
-      return 0;
-    }
+    try_reconnect (dc);
+    return 0;
+  }
   GNUNET_assert (size >= sizeof (struct SearchMessage));
   msize = 0;
   sm = buf;
-  while ( (NULL != (dr = dc->pending_head)) &&
-          (size >= msize + sizeof (struct SearchMessage)) )
-    {
+  while ((NULL != (dr = dc->pending_head)) &&
+         (size >= msize + sizeof (struct SearchMessage)))
+  {
 #if DEBUG_DOWNLOAD
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Transmitting download request for `%s' to `%s'-service\n",
-                  GNUNET_h2s (&dr->chk.query),
-                  "FS");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Transmitting download request for `%s' to `%s'-service\n",
+                GNUNET_h2s (&dr->chk.query), "FS");
 #endif
-      memset (sm, 0, sizeof (struct SearchMessage));
-      sm->header.size = htons (sizeof (struct SearchMessage));
-      sm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
-      if (0 != (dc->options & GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY))
-        sm->options = htonl (1);
-      else
-        sm->options = htonl (0);      
-      if (dr->depth == 0)
-        sm->type = htonl (GNUNET_BLOCK_TYPE_FS_DBLOCK);
-      else
-        sm->type = htonl (GNUNET_BLOCK_TYPE_FS_IBLOCK);
-      sm->anonymity_level = htonl (dc->anonymity);
-      sm->target = dc->target.hashPubKey;
-      sm->query = dr->chk.query;
-      GNUNET_CONTAINER_DLL_remove (dc->pending_head,
-                                   dc->pending_tail,
-                                   dr);
-      dr->is_pending = GNUNET_NO;
-      msize += sizeof (struct SearchMessage);
-      sm++;
-    }
+    memset (sm, 0, sizeof (struct SearchMessage));
+    sm->header.size = htons (sizeof (struct SearchMessage));
+    sm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
+    if (0 != (dc->options & GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY))
+      sm->options = htonl (1);
+    else
+      sm->options = htonl (0);
+    if (dr->depth == 0)
+      sm->type = htonl (GNUNET_BLOCK_TYPE_FS_DBLOCK);
+    else
+      sm->type = htonl (GNUNET_BLOCK_TYPE_FS_IBLOCK);
+    sm->anonymity_level = htonl (dc->anonymity);
+    sm->target = dc->target.hashPubKey;
+    sm->query = dr->chk.query;
+    GNUNET_CONTAINER_DLL_remove (dc->pending_head, dc->pending_tail, dr);
+    dr->is_pending = GNUNET_NO;
+    msize += sizeof (struct SearchMessage);
+    sm++;
+  }
   if (dc->pending_head != NULL)
-    {
-      dc->th = GNUNET_CLIENT_notify_transmit_ready (dc->client,
-                                                    sizeof (struct SearchMessage),
-                                                    GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                    GNUNET_NO,
-                                                    &transmit_download_request,
-                                                    dc); 
-      GNUNET_assert (dc->th != NULL);
-    }
+  {
+    dc->th = GNUNET_CLIENT_notify_transmit_ready (dc->client,
+                                                  sizeof (struct SearchMessage),
+                                                  GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                                  GNUNET_NO,
+                                                  &transmit_download_request,
+                                                  dc);
+    GNUNET_assert (dc->th != NULL);
+  }
   if (GNUNET_NO == dc->in_receive)
-    {
-      dc->in_receive = GNUNET_YES;
-      GNUNET_CLIENT_receive (dc->client,
-                             &receive_results,
-                             dc,
-                             GNUNET_TIME_UNIT_FOREVER_REL);
-    }
+  {
+    dc->in_receive = GNUNET_YES;
+    GNUNET_CLIENT_receive (dc->client,
+                           &receive_results, dc, GNUNET_TIME_UNIT_FOREVER_REL);
+  }
   return msize;
 }
 
@@ -1479,34 +1340,31 @@ transmit_download_request (void *cls,
  * @param tc unused
  */
 static void
-do_reconnect (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_CLIENT_Connection *client;
-  
+
   dc->task = GNUNET_SCHEDULER_NO_TASK;
-  client = GNUNET_CLIENT_connect ("fs",
-                                  dc->h->cfg);
+  client = GNUNET_CLIENT_connect ("fs", dc->h->cfg);
   if (NULL == client)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  "Connecting to `%s'-service failed, will try again.\n",
-                  "FS");
-      try_reconnect (dc);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Connecting to `%s'-service failed, will try again.\n", "FS");
+    try_reconnect (dc);
+    return;
+  }
   dc->client = client;
   if (dc->pending_head != NULL)
-    {
-      dc->th = GNUNET_CLIENT_notify_transmit_ready (client,
-                                                    sizeof (struct SearchMessage),
-                                                    GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                    GNUNET_NO,
-                                                    &transmit_download_request,
-                                                    dc);
-      GNUNET_assert (dc->th != NULL);
-    }
+  {
+    dc->th = GNUNET_CLIENT_notify_transmit_ready (client,
+                                                  sizeof (struct SearchMessage),
+                                                  GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                                  GNUNET_NO,
+                                                  &transmit_download_request,
+                                                  dc);
+    GNUNET_assert (dc->th != NULL);
+  }
 }
 
 
@@ -1519,18 +1377,14 @@ do_reconnect (void *cls,
  * @return GNUNET_OK
  */
 static int
-retry_entry (void *cls,
-             const GNUNET_HashCode *key,
-             void *entry)
+retry_entry (void *cls, const GNUNET_HashCode * key, void *entry)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct DownloadRequest *dr = entry;
 
   dr->next = NULL;
   dr->prev = NULL;
-  GNUNET_CONTAINER_DLL_insert (dc->pending_head,
-                               dc->pending_tail,
-                               dr);
+  GNUNET_CONTAINER_DLL_insert (dc->pending_head, dc->pending_tail, dr);
   dr->is_pending = GNUNET_YES;
   return GNUNET_OK;
 }
@@ -1546,36 +1400,32 @@ retry_entry (void *cls,
 static void
 try_reconnect (struct GNUNET_FS_DownloadContext *dc)
 {
-  
+
   if (NULL != dc->client)
-    {
+  {
 #if DEBUG_DOWNLOAD
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Moving all requests back to pending list\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Moving all requests back to pending list\n");
 #endif
-      if (NULL != dc->th)
-        {
-          GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
-          dc->th = NULL;
-        }
-      /* full reset of the pending list */
-      dc->pending_head = NULL;
-      dc->pending_tail = NULL;
-      GNUNET_CONTAINER_multihashmap_iterate (dc->active,
-                                             &retry_entry,
-                                             dc);
-      GNUNET_CLIENT_disconnect (dc->client, GNUNET_NO);
-      dc->in_receive = GNUNET_NO;
-      dc->client = NULL;
+    if (NULL != dc->th)
+    {
+      GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
+      dc->th = NULL;
     }
+    /* full reset of the pending list */
+    dc->pending_head = NULL;
+    dc->pending_tail = NULL;
+    GNUNET_CONTAINER_multihashmap_iterate (dc->active, &retry_entry, dc);
+    GNUNET_CLIENT_disconnect (dc->client, GNUNET_NO);
+    dc->in_receive = GNUNET_NO;
+    dc->client = NULL;
+  }
 #if DEBUG_DOWNLOAD
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Will try to reconnect in 1s\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Will try to reconnect in 1s\n");
 #endif
   dc->task
-    = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                    &do_reconnect,
-                                    dc);
+      = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                      &do_reconnect, dc);
 }
 
 
@@ -1586,15 +1436,13 @@ try_reconnect (struct GNUNET_FS_DownloadContext *dc)
  * @param client handle to use for communcation with FS (we must destroy it!)
  */
 static void
-activate_fs_download (void *cls,
-                      struct GNUNET_CLIENT_Connection *client)
+activate_fs_download (void *cls, struct GNUNET_CLIENT_Connection *client)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
 #if DEBUG_DOWNLOAD
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Download activated\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download activated\n");
 #endif
   GNUNET_assert (NULL != client);
   GNUNET_assert (dc->client == NULL);
@@ -1604,23 +1452,21 @@ activate_fs_download (void *cls,
   GNUNET_FS_download_make_status_ (&pi, dc);
   dc->pending_head = NULL;
   dc->pending_tail = NULL;
-  GNUNET_CONTAINER_multihashmap_iterate (dc->active,
-                                         &retry_entry,
-                                         dc);
+  GNUNET_CONTAINER_multihashmap_iterate (dc->active, &retry_entry, dc);
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking for transmission to FS service\n");
+              "Asking for transmission to FS service\n");
 #endif
   if (dc->pending_head != NULL)
-    {
-      dc->th = GNUNET_CLIENT_notify_transmit_ready (dc->client,
-                                                    sizeof (struct SearchMessage),
-                                                    GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                    GNUNET_NO,
-                                                    &transmit_download_request,
-                                                    dc);    
-      GNUNET_assert (dc->th != NULL);
-    }
+  {
+    dc->th = GNUNET_CLIENT_notify_transmit_ready (dc->client,
+                                                  sizeof (struct SearchMessage),
+                                                  GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                                  GNUNET_NO,
+                                                  &transmit_download_request,
+                                                  dc);
+    GNUNET_assert (dc->th != NULL);
+  }
 }
 
 
@@ -1636,20 +1482,19 @@ deactivate_fs_download (void *cls)
   struct GNUNET_FS_ProgressInfo pi;
 
 #if DEBUG_DOWNLOAD
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Download deactivated\n");
-#endif  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Download deactivated\n");
+#endif
   if (NULL != dc->th)
-    {
-      GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
-      dc->th = NULL;
-    }
+  {
+    GNUNET_CLIENT_notify_transmit_ready_cancel (dc->th);
+    dc->th = NULL;
+  }
   if (NULL != dc->client)
-    {
-      GNUNET_CLIENT_disconnect (dc->client, GNUNET_NO);
-      dc->in_receive = GNUNET_NO;
-      dc->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (dc->client, GNUNET_NO);
+    dc->in_receive = GNUNET_NO;
+    dc->client = NULL;
+  }
   dc->pending_head = NULL;
   dc->pending_tail = NULL;
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_INACTIVE;
@@ -1677,54 +1522,55 @@ deactivate_fs_download (void *cls)
  */
 static struct DownloadRequest *
 create_download_request (struct DownloadRequest *parent,
-                         unsigned int depth,
-                         uint64_t dr_offset,
-                         uint64_t file_start_offset,
-                         uint64_t desired_length)
+                         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_malloc (sizeof (struct DownloadRequest));
   dr->parent = parent;
   dr->depth = depth;
   dr->offset = dr_offset;
   if (depth > 0)
-    {
-      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 / child_block_size;       
-      else
-        head_skip = dr_offset / child_block_size;       
-
-      /* calculate index of last block at this level that is interesting (rounded up) */
-      dr->num_children = file_start_offset + desired_length / child_block_size;
-      if (dr->num_children * child_block_size < file_start_offset + desired_length)
-        dr->num_children++; /* round up */
-
-      /* now we can get the total number of children for this block */
-      dr->num_children -= head_skip;
-      if (dr->num_children > CHK_PER_INODE)
-        dr->num_children = CHK_PER_INODE; /* cap at max */
-
-      /* why else would we have gotten here to begin with? (that'd be a bad logic error) */
-      GNUNET_assert (dr->num_children > 0); 
-
-      dr->children = GNUNET_malloc (dr->num_children * 
-                                    sizeof (struct DownloadRequest *));
-      for (i=0;i<dr->num_children;i++)
-        dr->children[i] = create_download_request (dr,
-                                                   depth - 1,
-                                                   dr_offset + i * child_block_size,
-                                                   file_start_offset,
-                                                   desired_length);      
-    }
+  {
+    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 / child_block_size;
+    else
+      head_skip = dr_offset / child_block_size;
+
+    /* calculate index of last block at this level that is interesting (rounded up) */
+    dr->num_children = file_start_offset + desired_length / child_block_size;
+    if (dr->num_children * child_block_size <
+        file_start_offset + desired_length)
+      dr->num_children++;       /* round up */
+
+    /* now we can get the total number of children for this block */
+    dr->num_children -= head_skip;
+    if (dr->num_children > CHK_PER_INODE)
+      dr->num_children = CHK_PER_INODE; /* cap at max */
+
+    /* why else would we have gotten here to begin with? (that'd be a bad logic error) */
+    GNUNET_assert (dr->num_children > 0);
+
+    dr->children = GNUNET_malloc (dr->num_children *
+                                  sizeof (struct DownloadRequest *));
+    for (i = 0; i < dr->num_children; i++)
+      dr->children[i] = create_download_request (dr,
+                                                 depth - 1,
+                                                 dr_offset +
+                                                 i * child_block_size,
+                                                 file_start_offset,
+                                                 desired_length);
+  }
   return dr;
 }
 
@@ -1737,30 +1583,28 @@ create_download_request (struct DownloadRequest *parent,
  * @param tc scheduler context
  */
 static void
-reconstruct_cont (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+reconstruct_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
 
   /* clean up state from tree encoder */
   if (dc->te != NULL)
-    {
-      GNUNET_FS_tree_encoder_finish (dc->te, NULL, NULL);
-      dc->te = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (dc->te, NULL, NULL);
+    dc->te = NULL;
+  }
   if (dc->task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (dc->task);
-      dc->task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (dc->task);
+    dc->task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (dc->rfh != NULL)
-    {
-      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 */
-  schedule_block_download (dc, 
-                           dc->top_request);
+  schedule_block_download (dc, dc->top_request);
 }
 
 
@@ -1771,8 +1615,7 @@ reconstruct_cont (void *cls,
  * @param tc task context
  */
 static void
-get_next_block (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+get_next_block (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_DownloadContext *dc = cls;
 
@@ -1799,14 +1642,13 @@ get_next_block (void *cls,
  * @param block the (encrypted) block
  * @param block_size size of block (in bytes)
  */
-static void 
+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)
+                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;
@@ -1817,67 +1659,62 @@ reconstruct_cb (void *cls,
   /* find corresponding request entry */
   dr = dc->top_request;
   while (dr->depth > depth)
-    {
-      blen = GNUNET_FS_tree_compute_tree_size (dr->depth);
-      chld = (offset - dr->offset) / blen;
-      GNUNET_assert (chld < dr->num_children);
-      dr = dr->children[chld];
-    }
+  {
+    blen = GNUNET_FS_tree_compute_tree_size (dr->depth);
+    chld = (offset - dr->offset) / blen;
+    GNUNET_assert (chld < dr->num_children);
+    dr = dr->children[chld];
+  }
   switch (dr->state)
-    {
-    case BRS_INIT:
-      break;
-    case BRS_RECONSTRUCT_DOWN:
-      break;
-    case BRS_RECONSTRUCT_META_UP:
-      break;
-    case BRS_RECONSTRUCT_UP:
-      break;
-    case BRS_CHK_SET:
-      if (0 == memcmp (chk,
-                       &dr->chk,
-                       sizeof (struct ContentHashKey)))
-        {
-          /* block matches, hence tree below matches; 
-             this request is done! */
-          dr->state = BRS_DOWNLOAD_UP;
-          /* 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;
-          GNUNET_FS_download_make_status_ (&pi, dc);             
-        }
-      else
-        {
-        }
-      break; 
-    case BRS_DOWNLOAD_DOWN:
-      break; 
-    case BRS_DOWNLOAD_UP:
-      break;
-    case BRS_ERROR:
-      break;
-    default:
-      GNUNET_assert (0);
-      break;
-    }
-  if ( (dr == dc->top_request) &&
-       (dr->state == BRS_DOWNLOAD_UP) )
-    {
-      check_completed (dc);
-      return;
+  {
+  case BRS_INIT:
+    break;
+  case BRS_RECONSTRUCT_DOWN:
+    break;
+  case BRS_RECONSTRUCT_META_UP:
+    break;
+  case BRS_RECONSTRUCT_UP:
+    break;
+  case BRS_CHK_SET:
+    if (0 == memcmp (chk, &dr->chk, sizeof (struct ContentHashKey)))
+    {
+      /* block matches, hence tree below matches; 
+       * this request is done! */
+      dr->state = BRS_DOWNLOAD_UP;
+      /* 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;
+      GNUNET_FS_download_make_status_ (&pi, dc);
     }
-  dc->task = GNUNET_SCHEDULER_add_now (&get_next_block,
-                                       dc);
+    else
+    {
+    }
+    break;
+  case BRS_DOWNLOAD_DOWN:
+    break;
+  case BRS_DOWNLOAD_UP:
+    break;
+  case BRS_ERROR:
+    break;
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+  if ((dr == dc->top_request) && (dr->state == BRS_DOWNLOAD_UP))
+  {
+    check_completed (dc);
+    return;
+  }
+  dc->task = GNUNET_SCHEDULER_add_now (&get_next_block, dc);
 }
 
 
@@ -1894,31 +1731,24 @@ 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;
   ssize_t ret;
 
   *emsg = NULL;
-  if (offset !=
-      GNUNET_DISK_file_seek (fh,
-                             offset,
-                             GNUNET_DISK_SEEK_SET))
-    {
-      *emsg = GNUNET_strdup (strerror (errno));
-      return 0;
-    }
+  if (offset != GNUNET_DISK_file_seek (fh, offset, GNUNET_DISK_SEEK_SET))
+  {
+    *emsg = GNUNET_strdup (strerror (errno));
+    return 0;
+  }
   ret = GNUNET_DISK_file_read (fh, buf, max);
   if (ret < 0)
-    {
-      *emsg = GNUNET_strdup (strerror (errno));
-      return 0;
-    }
+  {
+    *emsg = GNUNET_strdup (strerror (errno));
+    return 0;
+  }
   return ret;
 }
 
@@ -1932,149 +1762,141 @@ fh_reader (void *cls,
  */
 void
 GNUNET_FS_download_start_task_ (void *cls,
-                                const struct GNUNET_SCHEDULER_TaskContext *tc)
+                                const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  struct GNUNET_FS_DownloadContext *dc = cls;  
+  struct GNUNET_FS_DownloadContext *dc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   struct GNUNET_DISK_FileHandle *fh;
 
 #if DEBUG_DOWNLOAD
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Start task running...\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Start task running...\n");
 #endif
   dc->task = GNUNET_SCHEDULER_NO_TASK;
   if (dc->length == 0)
-    {
-      /* no bytes required! */
-      if (dc->filename != NULL) 
-        {
-          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);
-      check_completed (dc);
-      return;
+  {
+    /* no bytes required! */
+    if (dc->filename != NULL)
+    {
+      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);
     }
-  if (dc->emsg != NULL) 
+    GNUNET_FS_download_sync_ (dc);
+    check_completed (dc);
+    return;
+  }
+  if (dc->emsg != NULL)
     return;
   if (dc->top_request == NULL)
-    {
-      dc->top_request = create_download_request (NULL, dc->treedepth - 1, 0,
-                                                 dc->offset, dc->length);
-      dc->top_request->state = BRS_CHK_SET;
-      dc->top_request->chk = (dc->uri->type == chk) 
-        ? dc->uri->data.chk.chk
-        : dc->uri->data.loc.fi.chk;
-      /* signal start */
-      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);
-    }
+  {
+    dc->top_request = create_download_request (NULL, dc->treedepth - 1, 0,
+                                               dc->offset, dc->length);
+    dc->top_request->state = BRS_CHK_SET;
+    dc->top_request->chk = (dc->uri->type == chk)
+        ? dc->uri->data.chk.chk : dc->uri->data.loc.fi.chk;
+    /* signal start */
+    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);
+  }
   GNUNET_FS_download_start_downloading_ (dc);
   /* attempt reconstruction from disk */
-  if (GNUNET_YES == GNUNET_DISK_file_test (dc->filename))    
+  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);    
+                                     GNUNET_DISK_OPEN_READ,
+                                     GNUNET_DISK_PERM_NONE);
   if (dc->top_request->state == BRS_CHK_SET)
+  {
+    if (dc->rfh != NULL)
     {
-      if (dc->rfh != NULL)
-        {
-          /* first, try top-down */
+      /* first, try top-down */
 #if DEBUG_DOWNLOAD
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Trying top-down reconstruction for `%s'\n",
-                      dc->filename);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Trying top-down reconstruction for `%s'\n", dc->filename);
 #endif
-          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 (dc->rfh != NULL)
-                {
-                  /* 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;
-            }
-        }
-    }
+      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 (dc->rfh != NULL)
+        {
+          /* 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) &&
-       (NULL != dc->meta) )
-    {
+  if ((GNUNET_FS_uri_chk_get_file_size (dc->uri) <= MAX_INLINE_SIZE) &&
+      (NULL != dc->meta))
+  {
 #if DEBUG_DOWNLOAD
-      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_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));
 #endif
-      GNUNET_CONTAINER_meta_data_iterate (dc->meta,
-                                          &match_full_data,
-                                          dc);
-      if (dc->top_request->state == BRS_DOWNLOAD_UP)
-        {
-          if (dc->rfh != NULL)
-            {
-              /* 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 (dc->rfh != NULL)
+    GNUNET_CONTAINER_meta_data_iterate (dc->meta, &match_full_data, dc);
+    if (dc->top_request->state == BRS_DOWNLOAD_UP)
     {
-      /* finally, try bottom-up */
+      if (dc->rfh != NULL)
+      {
+        /* 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 (dc->rfh != NULL)
+  {
+    /* finally, try bottom-up */
 #if DEBUG_DOWNLOAD
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Trying bottom-up reconstruction of file `%s'\n",
-                  dc->filename);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Trying bottom-up reconstruction of file `%s'\n", dc->filename);
 #endif
-      dc->te = GNUNET_FS_tree_encoder_create (dc->h,
-                                              dc->old_file_size,
-                                              dc,
-                                              &fh_reader,
-                                              &reconstruct_cb,
-                                              NULL,
-                                              &reconstruct_cont);     
-      dc->task = GNUNET_SCHEDULER_add_now (&get_next_block,
-                                           dc);
-    }
+    dc->te = GNUNET_FS_tree_encoder_create (dc->h,
+                                            dc->old_file_size,
+                                            dc,
+                                            &fh_reader,
+                                            &reconstruct_cb,
+                                            NULL, &reconstruct_cont);
+    dc->task = GNUNET_SCHEDULER_add_now (&get_next_block, dc);
+  }
   else
-    {
-      /* simple, top-level download */
-        schedule_block_download (dc, 
-                                 dc->top_request);
-    }
+  {
+    /* simple, top-level download */
+    schedule_block_download (dc, dc->top_request);
+  }
   if (dc->top_request->state == BRS_DOWNLOAD_UP)
     check_completed (dc);
 }
@@ -2095,44 +1917,43 @@ GNUNET_FS_download_signal_suspend_ (void *cls)
   if (dc->top != NULL)
     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 (dc->search != NULL)
-    {
-      dc->search->download = NULL;
-      dc->search = NULL;
-    }
+  {
+    dc->search->download = NULL;
+    dc->search = NULL;
+  }
   if (dc->job_queue != NULL)
-    {
-      GNUNET_FS_dequeue_ (dc->job_queue);
-      dc->job_queue = NULL;
-    }
+  {
+    GNUNET_FS_dequeue_ (dc->job_queue);
+    dc->job_queue = NULL;
+  }
   if (dc->parent != NULL)
     GNUNET_CONTAINER_DLL_remove (dc->parent->child_head,
-                                 dc->parent->child_tail,
-                                 dc);  
+                                 dc->parent->child_tail, dc);
   if (dc->task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (dc->task);
-      dc->task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (dc->task);
+    dc->task = GNUNET_SCHEDULER_NO_TASK;
+  }
   pi.status = GNUNET_FS_STATUS_DOWNLOAD_SUSPEND;
   GNUNET_FS_download_make_status_ (&pi, dc);
   if (dc->te != NULL)
-    {
-      GNUNET_FS_tree_encoder_finish (dc->te, NULL, NULL);       
-      dc->te = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (dc->te, NULL, NULL);
+    dc->te = NULL;
+  }
   if (dc->rfh != NULL)
-    {
-      GNUNET_DISK_file_close (dc->rfh);
-      dc->rfh = NULL;
-    }
+  {
+    GNUNET_DISK_file_close (dc->rfh);
+    dc->rfh = NULL;
+  }
   GNUNET_FS_free_download_request_ (dc->top_request);
   if (dc->active != NULL)
-    {
-      GNUNET_CONTAINER_multihashmap_destroy (dc->active);
-      dc->active = NULL;
-    }
+  {
+    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);
@@ -2174,87 +1995,77 @@ GNUNET_FS_download_signal_suspend_ (void *cls)
  */
 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)
+                          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;
 
-  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;
-    }
+  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;
+  }
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting download `%s' of %llu bytes\n",
-              filename,
-              (unsigned long long) length);
+              "Starting download `%s' of %llu bytes\n",
+              filename, (unsigned long long) length);
 #endif
-  dc = GNUNET_malloc (sizeof(struct GNUNET_FS_DownloadContext));
+  dc = GNUNET_malloc (sizeof (struct GNUNET_FS_DownloadContext));
   dc->h = h;
   dc->parent = parent;
   if (parent != NULL)
-    {
-      GNUNET_CONTAINER_DLL_insert (parent->child_head,
-                                   parent->child_tail,
-                                   dc);
-    }
+  {
+    GNUNET_CONTAINER_DLL_insert (parent->child_head, parent->child_tail, dc);
+  }
   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 ();
   if (NULL != filename)
-    {
-      dc->filename = GNUNET_strdup (filename);
-      if (GNUNET_YES == GNUNET_DISK_file_test (filename))
-        GNUNET_DISK_file_size (filename,
-                               &dc->old_file_size,
-                               GNUNET_YES);
-    }
+  {
+    dc->filename = GNUNET_strdup (filename);
+    if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+      GNUNET_DISK_file_size (filename, &dc->old_file_size, 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));
+                   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));
-  dc->treedepth = GNUNET_FS_compute_depth (GNUNET_FS_uri_chk_get_file_size(dc->uri));
-  if ( (filename == NULL) &&
-       (is_recursive_download (dc) ) )
-    {
-      if (tempname != NULL)
-        dc->temp_filename = GNUNET_strdup (tempname);
-      else
-        dc->temp_filename = GNUNET_DISK_mktemp ("gnunet-directory-download-tmp");    
-    }
+  dc->active =
+      GNUNET_CONTAINER_multihashmap_create (1 + 2 * (length / DBLOCK_SIZE));
+  dc->treedepth =
+      GNUNET_FS_compute_depth (GNUNET_FS_uri_chk_get_file_size (dc->uri));
+  if ((filename == NULL) && (is_recursive_download (dc)))
+  {
+    if (tempname != NULL)
+      dc->temp_filename = GNUNET_strdup (tempname);
+    else
+      dc->temp_filename = GNUNET_DISK_mktemp ("gnunet-directory-download-tmp");
+  }
 
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Download tree has depth %u\n",
-              dc->treedepth);
+              "Download tree has depth %u\n", dc->treedepth);
 #endif
   if (parent == NULL)
-    {
-      dc->top = GNUNET_FS_make_top (dc->h,
-                                    &GNUNET_FS_download_signal_suspend_,
-                                    dc);
-    }
-  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);
+  }
+  dc->task = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, dc);
   return dc;
 }
 
@@ -2295,85 +2106,79 @@ GNUNET_FS_download_start (struct GNUNET_FS_Handle *h,
  */
 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)
+                                      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 ( (sr == NULL) ||
-       (sr->download != NULL) )
-    {
-      GNUNET_break (0);
-      return NULL;
-    }
+  if ((sr == NULL) || (sr->download != NULL))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   GNUNET_assert (GNUNET_FS_uri_test_chk (sr->uri) ||
-                 GNUNET_FS_uri_test_loc (sr->uri) );             
-  if ( (offset + length < offset) ||
-       (offset + length > sr->uri->data.chk.file_length) )
-    {      
-      GNUNET_break (0);
-      return NULL;
-    }
+                 GNUNET_FS_uri_test_loc (sr->uri));
+  if ((offset + length < offset) ||
+      (offset + length > sr->uri->data.chk.file_length))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting download `%s' of %llu bytes\n",
-              filename,
-              (unsigned long long) length);
+              "Starting download `%s' of %llu bytes\n",
+              filename, (unsigned long long) length);
 #endif
-  dc = GNUNET_malloc (sizeof(struct GNUNET_FS_DownloadContext));
+  dc = GNUNET_malloc (sizeof (struct GNUNET_FS_DownloadContext));
   dc->h = h;
   dc->search = sr;
   sr->download = dc;
   if (sr->probe_ctx != NULL)
-    {
-      GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
-      sr->probe_ctx = NULL;      
-    }
+  {
+    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
+    sr->probe_ctx = NULL;
+  }
   dc->uri = GNUNET_FS_uri_dup (sr->uri);
   dc->meta = GNUNET_CONTAINER_meta_data_duplicate (sr->meta);
   dc->client_info = cctx;
   dc->start_time = GNUNET_TIME_absolute_get ();
   if (NULL != filename)
-    {
-      dc->filename = GNUNET_strdup (filename);
-      if (GNUNET_YES == GNUNET_DISK_file_test (filename))
-        GNUNET_DISK_file_size (filename,
-                               &dc->old_file_size,
-                               GNUNET_YES);
-    }
+  {
+    dc->filename = GNUNET_strdup (filename);
+    if (GNUNET_YES == GNUNET_DISK_file_test (filename))
+      GNUNET_DISK_file_size (filename, &dc->old_file_size, 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));
+                   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));
-  dc->treedepth = GNUNET_FS_compute_depth (GNUNET_ntohll(dc->uri->data.chk.file_length));
-  if ( (filename == NULL) &&
-       (is_recursive_download (dc) ) )
-    {
-      if (tempname != NULL)
-        dc->temp_filename = GNUNET_strdup (tempname);
-      else
-        dc->temp_filename = GNUNET_DISK_mktemp ("gnunet-directory-download-tmp");    
-    }
+  dc->active =
+      GNUNET_CONTAINER_multihashmap_create (1 + 2 * (length / DBLOCK_SIZE));
+  dc->treedepth =
+      GNUNET_FS_compute_depth (GNUNET_ntohll (dc->uri->data.chk.file_length));
+  if ((filename == NULL) && (is_recursive_download (dc)))
+  {
+    if (tempname != NULL)
+      dc->temp_filename = GNUNET_strdup (tempname);
+    else
+      dc->temp_filename = GNUNET_DISK_mktemp ("gnunet-directory-download-tmp");
+  }
 
 #if DEBUG_DOWNLOAD
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Download tree has depth %u\n",
-              dc->treedepth);
+              "Download tree has depth %u\n", dc->treedepth);
 #endif
-  dc->task = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, 
-                                       dc);
-  return dc;  
+  dc->task = GNUNET_SCHEDULER_add_now (&GNUNET_FS_download_start_task_, dc);
+  return dc;
 }
 
 
@@ -2388,11 +2193,12 @@ GNUNET_FS_download_start_downloading_ (struct GNUNET_FS_DownloadContext *dc)
   if (dc->completed == dc->length)
     return;
   GNUNET_assert (dc->job_queue == NULL);
-  dc->job_queue = GNUNET_FS_queue_ (dc->h, 
-                                    &activate_fs_download,
-                                    &deactivate_fs_download,
-                                    dc,
-                                    (dc->length + DBLOCK_SIZE-1) / DBLOCK_SIZE);
+  dc->job_queue = GNUNET_FS_queue_ (dc->h,
+                                    &activate_fs_download,
+                                    &deactivate_fs_download,
+                                    dc,
+                                    (dc->length + DBLOCK_SIZE -
+                                     1) / DBLOCK_SIZE);
 }
 
 
@@ -2403,8 +2209,7 @@ GNUNET_FS_download_start_downloading_ (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;
@@ -2414,77 +2219,71 @@ GNUNET_FS_download_stop (struct GNUNET_FS_DownloadContext *dc,
 
 
   if (dc->task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (dc->task);
-      dc->task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (dc->task);
+    dc->task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (dc->search != NULL)
-    {
-      dc->search->download = NULL;
-      dc->search = NULL;
-    }
+  {
+    dc->search->download = NULL;
+    dc->search = NULL;
+  }
   if (dc->job_queue != NULL)
-    {
-      GNUNET_FS_dequeue_ (dc->job_queue);
-      dc->job_queue = NULL;
-    }
+  {
+    GNUNET_FS_dequeue_ (dc->job_queue);
+    dc->job_queue = NULL;
+  }
   if (dc->te != NULL)
-    {
-      GNUNET_FS_tree_encoder_finish (dc->te, NULL, NULL);
-      dc->te = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (dc->te, NULL, 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 (dc->parent != NULL)
     GNUNET_CONTAINER_DLL_remove (dc->parent->child_head,
-                                 dc->parent->child_tail,
-                                 dc);  
+                                 dc->parent->child_tail, dc);
   if (dc->serialization != NULL)
     GNUNET_FS_remove_sync_file_ (dc->h,
-                                 ( (dc->parent != NULL)  || (dc->search != NULL) )
-                                 ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD 
-                                 : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD , 
-                                 dc->serialization);
-  if ( (GNUNET_YES == have_children) &&
-       (dc->parent == NULL) )
-    GNUNET_FS_remove_sync_dir_ (dc->h, 
-                                (dc->search != NULL) 
-                                ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD 
-                                : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
-                                dc->serialization);  
+                                 ((dc->parent != NULL) || (dc->search != NULL))
+                                 ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
+                                 : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
+                                 dc->serialization);
+  if ((GNUNET_YES == have_children) && (dc->parent == NULL))
+    GNUNET_FS_remove_sync_dir_ (dc->h,
+                                (dc->search != 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);
   dc->top_request = NULL;
   if (dc->active != NULL)
-    {
-      GNUNET_CONTAINER_multihashmap_destroy (dc->active);
-      dc->active = NULL;
-    }
+  {
+    GNUNET_CONTAINER_multihashmap_destroy (dc->active);
+    dc->active = NULL;
+  }
   if (dc->filename != NULL)
+  {
+    if ((dc->completed != dc->length) && (GNUNET_YES == do_delete))
     {
-      if ( (dc->completed != dc->length) &&
-           (GNUNET_YES == do_delete) )
-        {
-          if (0 != UNLINK (dc->filename))
-            GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                      "unlink",
-                                      dc->filename);
-        }
-      GNUNET_free (dc->filename);
+      if (0 != UNLINK (dc->filename))
+        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);
-    }
+  {
+    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_free (dc);
 }
diff --git a/src/fs/fs_file_information.c b/src/fs/fs_file_information.c
index 62ae285d8..bb323bbbc 100644
--- a/src/fs/fs_file_information.c
+++ b/src/fs/fs_file_information.c
@@ -52,22 +52,19 @@
  * @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;
+
   (void) GNUNET_CONTAINER_meta_data_insert (md,
-                                            plugin_name,
-                                            type,
-                                            format,
-                                            data_mime_type,
-                                            data,
-                                            data_len);
+                                            plugin_name,
+                                            type,
+                                            format,
+                                            data_mime_type, data, data_len);
   return 0;
 }
 
@@ -80,9 +77,8 @@ add_to_md(void *cls,
  */
 int
 GNUNET_FS_meta_data_extract_from_file (struct GNUNET_CONTAINER_MetaData
-                                       *md, const char *filename,
-                                       struct EXTRACTOR_PluginList *
-                                       extractors)
+                                       *md, const char *filename,
+                                       struct EXTRACTOR_PluginList *extractors)
 {
   int old;
 
@@ -92,11 +88,7 @@ GNUNET_FS_meta_data_extract_from_file (struct GNUNET_CONTAINER_MetaData
     return 0;
   old = GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL);
   GNUNET_assert (old >= 0);
-  EXTRACTOR_extract (extractors, 
-                     filename,
-                     NULL, 0,
-                     &add_to_md,
-                     md);
+  EXTRACTOR_extract (extractors, filename, NULL, 0, &add_to_md, md);
   return (GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL) - old);
 }
 
@@ -137,44 +129,44 @@ GNUNET_FS_file_information_get_id (struct GNUNET_FS_FileInformation *s)
  */
 struct GNUNET_FS_FileInformation *
 GNUNET_FS_file_information_create_from_file (struct GNUNET_FS_Handle *h,
-                                             void *client_info,
-                                             const char *filename,
-                                             const struct GNUNET_FS_Uri *keywords,
-                                             const struct GNUNET_CONTAINER_MetaData *meta,
-                                             int do_index,
-                                             const struct GNUNET_FS_BlockOptions *bo)
+                                             void *client_info,
+                                             const char *filename,
+                                             const struct GNUNET_FS_Uri
+                                             *keywords,
+                                             const struct
+                                             GNUNET_CONTAINER_MetaData *meta,
+                                             int do_index,
+                                             const struct GNUNET_FS_BlockOptions
+                                             *bo)
 {
   struct FileInfo *fi;
   struct stat sbuf;
   struct GNUNET_FS_FileInformation *ret;
   const char *fn;
   const char *ss;
+
 #if WINDOWS
   char fn_conv[MAX_PATH];
 #endif
 
   if (0 != STAT (filename, &sbuf))
-    {
-      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                "stat",
-                                filename);
-      return NULL;
-    }
+  {
+    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
+    return NULL;
+  }
   fi = GNUNET_FS_make_file_reader_context_ (filename);
   if (fi == NULL)
-    {
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   ret = GNUNET_FS_file_information_create_from_reader (h,
-                                                       client_info,
-                                                       sbuf.st_size,
-                                                       &GNUNET_FS_data_reader_file_,
-                                                       fi,
-                                                       keywords,
-                                                       meta,
-                                                       do_index,
-                                                       bo);
+                                                       client_info,
+                                                       sbuf.st_size,
+                                                       &GNUNET_FS_data_reader_file_,
+                                                       fi,
+                                                       keywords,
+                                                       meta, do_index, bo);
   if (ret == NULL)
     return NULL;
   ret->h = h;
@@ -185,16 +177,13 @@ GNUNET_FS_file_information_create_from_file (struct GNUNET_FS_Handle *h,
   plibc_conv_to_win_path (filename, fn_conv);
   fn = fn_conv;
 #endif
-  while (NULL != (ss = strstr (fn,
-                               DIR_SEPARATOR_STR)))
+  while (NULL != (ss = strstr (fn, DIR_SEPARATOR_STR)))
     fn = ss + 1;
   GNUNET_CONTAINER_meta_data_insert (ret->meta,
-                                     "<gnunet>",
-                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                     EXTRACTOR_METAFORMAT_C_STRING,
-                                     "text/plain",
-                                     fn,
-                                     strlen (fn) + 1);
+                                     "<gnunet>",
+                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                                     EXTRACTOR_METAFORMAT_C_STRING,
+                                     "text/plain", fn, strlen (fn) + 1);
   return ret;
 }
 
@@ -217,28 +206,29 @@ GNUNET_FS_file_information_create_from_file (struct GNUNET_FS_Handle *h,
  */
 struct GNUNET_FS_FileInformation *
 GNUNET_FS_file_information_create_from_data (struct GNUNET_FS_Handle *h,
-                                             void *client_info,
-                                             uint64_t length,
-                                             void *data,
-                                             const struct GNUNET_FS_Uri *keywords,
-                                             const struct GNUNET_CONTAINER_MetaData *meta,
-                                             int do_index,
-                                             const struct GNUNET_FS_BlockOptions *bo)
+                                             void *client_info,
+                                             uint64_t length,
+                                             void *data,
+                                             const struct GNUNET_FS_Uri
+                                             *keywords,
+                                             const struct
+                                             GNUNET_CONTAINER_MetaData *meta,
+                                             int do_index,
+                                             const struct GNUNET_FS_BlockOptions
+                                             *bo)
 {
-  if (GNUNET_YES == do_index)        
-    {
-      GNUNET_break (0);
-      return NULL;
-    }
+  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);
+                                                        client_info,
+                                                        length,
+                                                        &GNUNET_FS_data_reader_copy_,
+                                                        data,
+                                                        keywords,
+                                                        meta, do_index, bo);
 }
 
 
@@ -260,31 +250,33 @@ GNUNET_FS_file_information_create_from_data (struct GNUNET_FS_Handle *h,
  */
 struct GNUNET_FS_FileInformation *
 GNUNET_FS_file_information_create_from_reader (struct GNUNET_FS_Handle *h,
-                                               void *client_info,
-                                               uint64_t length,
-                                               GNUNET_FS_DataReader reader,
-                                               void *reader_cls,
-                                               const struct GNUNET_FS_Uri *keywords,
-                                               const struct GNUNET_CONTAINER_MetaData *meta,
-                                               int do_index,
-                                               const struct GNUNET_FS_BlockOptions *bo)
+                                               void *client_info,
+                                               uint64_t length,
+                                               GNUNET_FS_DataReader reader,
+                                               void *reader_cls,
+                                               const struct GNUNET_FS_Uri
+                                               *keywords,
+                                               const struct
+                                               GNUNET_CONTAINER_MetaData *meta,
+                                               int do_index,
+                                               const struct
+                                               GNUNET_FS_BlockOptions *bo)
 {
   struct GNUNET_FS_FileInformation *ret;
 
-  if ( (GNUNET_YES == do_index) &&
-       (reader != &GNUNET_FS_data_reader_file_) )
-    {
-      GNUNET_break (0);
-      return NULL;
-    }
+  if ((GNUNET_YES == do_index) && (reader != &GNUNET_FS_data_reader_file_))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_FileInformation));
   ret->h = h;
-  ret->client_info = client_info;  
+  ret->client_info = client_info;
   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->data.file.reader = reader; 
+  ret->data.file.reader = reader;
   ret->data.file.reader_cls = reader_cls;
   ret->data.file.do_index = do_index;
   ret->data.file.file_size = length;
@@ -296,7 +288,7 @@ GNUNET_FS_file_information_create_from_reader (struct GNUNET_FS_Handle *h,
 /**
  * Closure for "dir_scan_cb".
  */
-struct DirScanCls 
+struct DirScanCls
 {
   /**
    * Metadata extractors to use.
@@ -305,14 +297,14 @@ struct DirScanCls
 
   /**
    * Master context.
-   */ 
+   */
   struct GNUNET_FS_Handle *h;
 
   /**
    * Function to call on each directory entry.
    */
   GNUNET_FS_FileProcessor proc;
-  
+
   /**
    * Closure for proc.
    */
@@ -331,7 +323,7 @@ struct DirScanCls
   /**
    * Set to an error message (if any).
    */
-  char *emsg; 
+  char *emsg;
 
   /**
    * Block options.
@@ -340,7 +332,7 @@ struct DirScanCls
 
   /**
    * Should files be indexed?
-   */ 
+   */
   int do_index;
 
 };
@@ -354,10 +346,9 @@ struct DirScanCls
  * @return GNUNET_OK on success, GNUNET_SYSERR to abort
  */
 static int
-dir_scan_cb (void *cls,
-             const char *filename)
+dir_scan_cb (void *cls, const char *filename)
 {
-  struct DirScanCls *dsc = cls;  
+  struct DirScanCls *dsc = cls;
   struct stat sbuf;
   struct GNUNET_FS_FileInformation *fi;
   struct GNUNET_FS_Uri *ksk_uri;
@@ -365,52 +356,44 @@ dir_scan_cb (void *cls,
   struct GNUNET_CONTAINER_MetaData *meta;
 
   if (0 != STAT (filename, &sbuf))
-    {
-      GNUNET_asprintf (&dsc->emsg,
-                       _("`%s' failed on file `%s': %s"),
-                       "stat",
-                       filename,
-                       STRERROR (errno));
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_asprintf (&dsc->emsg,
+                     _("`%s' failed on file `%s': %s"),
+                     "stat", filename, STRERROR (errno));
+    return GNUNET_SYSERR;
+  }
   if (S_ISDIR (sbuf.st_mode))
+  {
+    fi = GNUNET_FS_file_information_create_from_directory (dsc->h,
+                                                           NULL,
+                                                           filename,
+                                                           dsc->scanner,
+                                                           dsc->scanner_cls,
+                                                           dsc->do_index,
+                                                           dsc->bo, &dsc->emsg);
+    if (NULL == fi)
     {
-      fi = GNUNET_FS_file_information_create_from_directory (dsc->h,
-                                                             NULL,
-                                                             filename,
-                                                             dsc->scanner,
-                                                             dsc->scanner_cls,
-                                                             dsc->do_index,
-                                                             dsc->bo,
-                                                             &dsc->emsg);
-      if (NULL == fi)
-        {
-          GNUNET_assert (NULL != dsc->emsg);
-          return GNUNET_SYSERR;
-        }
+      GNUNET_assert (NULL != dsc->emsg);
+      return GNUNET_SYSERR;
     }
+  }
   else
-    {
-      meta = GNUNET_CONTAINER_meta_data_create ();
-      GNUNET_FS_meta_data_extract_from_file (meta,
-                                             filename,
-                                             dsc->extractors);
-      keywords = GNUNET_FS_uri_ksk_create_from_meta_data (meta);
-      ksk_uri = GNUNET_FS_uri_ksk_canonicalize (keywords);
-      fi = GNUNET_FS_file_information_create_from_file (dsc->h,
-                                                        NULL,
-                                                        filename,
-                                                        ksk_uri,
-                                                        meta,
-                                                        dsc->do_index,
-                                                        dsc->bo);
-      GNUNET_CONTAINER_meta_data_destroy (meta);
-      GNUNET_FS_uri_destroy (keywords);
-      GNUNET_FS_uri_destroy (ksk_uri);
-    }
-  dsc->proc (dsc->proc_cls,
-             filename,
-             fi);
+  {
+    meta = GNUNET_CONTAINER_meta_data_create ();
+    GNUNET_FS_meta_data_extract_from_file (meta, filename, dsc->extractors);
+    keywords = GNUNET_FS_uri_ksk_create_from_meta_data (meta);
+    ksk_uri = GNUNET_FS_uri_ksk_canonicalize (keywords);
+    fi = GNUNET_FS_file_information_create_from_file (dsc->h,
+                                                      NULL,
+                                                      filename,
+                                                      ksk_uri,
+                                                      meta,
+                                                      dsc->do_index, dsc->bo);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    GNUNET_FS_uri_destroy (keywords);
+    GNUNET_FS_uri_destroy (ksk_uri);
+  }
+  dsc->proc (dsc->proc_cls, filename, fi);
   return GNUNET_OK;
 }
 
@@ -438,13 +421,12 @@ dir_scan_cb (void *cls,
  */
 int
 GNUNET_FS_directory_scanner_default (void *cls,
-                                     struct GNUNET_FS_Handle *h,
-                                     const char *dirname,
-                                     int do_index,
-                                     const struct GNUNET_FS_BlockOptions *bo,
-                                     GNUNET_FS_FileProcessor proc,
-                                     void *proc_cls,
-                                     char **emsg)
+                                     struct GNUNET_FS_Handle *h,
+                                     const char *dirname,
+                                     int do_index,
+                                     const struct GNUNET_FS_BlockOptions *bo,
+                                     GNUNET_FS_FileProcessor proc,
+                                     void *proc_cls, char **emsg)
 {
   struct EXTRACTOR_PluginList *ex = cls;
   struct DirScanCls dsc;
@@ -457,14 +439,12 @@ GNUNET_FS_directory_scanner_default (void *cls,
   dsc.scanner_cls = cls;
   dsc.do_index = do_index;
   dsc.bo = bo;
-  if (-1 == GNUNET_DISK_directory_scan (dirname,
-                                        &dir_scan_cb,
-                                        &dsc))
-    {
-      GNUNET_assert (NULL != dsc.emsg);
-      *emsg = dsc.emsg;
-      return GNUNET_SYSERR;
-    }
+  if (-1 == GNUNET_DISK_directory_scan (dirname, &dir_scan_cb, &dsc))
+  {
+    GNUNET_assert (NULL != dsc.emsg);
+    *emsg = dsc.emsg;
+    return GNUNET_SYSERR;
+  }
   return GNUNET_OK;
 }
 
@@ -491,9 +471,7 @@ struct EntryProcCls
  * @param fi information for publishing the file
  */
 static void
-dirproc (void *cls,
-         const char *filename,
-         struct GNUNET_FS_FileInformation *fi)
+dirproc (void *cls, const char *filename, struct GNUNET_FS_FileInformation *fi)
 {
   struct EntryProcCls *dc = cls;
 
@@ -526,13 +504,14 @@ dirproc (void *cls,
  */
 struct GNUNET_FS_FileInformation *
 GNUNET_FS_file_information_create_from_directory (struct GNUNET_FS_Handle *h,
-                                                  void *client_info,
-                                                  const char *filename,
-                                                  GNUNET_FS_DirectoryScanner scanner,
-                                                  void *scanner_cls,
-                                                  int do_index,
-                                                  const struct GNUNET_FS_BlockOptions *bo,
-                                                  char **emsg)
+                                                  void *client_info,
+                                                  const char *filename,
+                                                  GNUNET_FS_DirectoryScanner
+                                                  scanner, void *scanner_cls,
+                                                  int do_index,
+                                                  const struct
+                                                  GNUNET_FS_BlockOptions *bo,
+                                                  char **emsg)
 {
   struct GNUNET_FS_FileInformation *ret;
   struct EntryProcCls dc;
@@ -545,43 +524,28 @@ GNUNET_FS_file_information_create_from_directory (struct GNUNET_FS_Handle *h,
   dc.entries = NULL;
   meta = GNUNET_CONTAINER_meta_data_create ();
   GNUNET_FS_meta_data_make_directory (meta);
-  scanner (scanner_cls,
-           h,
-           filename,
-           do_index,
-           bo,
-           &dirproc,
-           &dc,
-           emsg);
-  ksk = NULL; // FIXME...
+  scanner (scanner_cls, h, filename, do_index, bo, &dirproc, &dc, emsg);
+  ksk = NULL;                   // FIXME...
   // FIXME: create meta!
   ret = GNUNET_FS_file_information_create_empty_directory (h,
-                                                           client_info,
-                                                           ksk,
-                                                           meta,
-                                                           bo);
+                                                           client_info,
+                                                           ksk, meta, bo);
   GNUNET_CONTAINER_meta_data_destroy (meta);
   ret->data.dir.entries = dc.entries;
   while (dc.entries != NULL)
-    {
-      dc.entries->dir = ret;
-      dc.entries = dc.entries->next;
-    }
+  {
+    dc.entries->dir = ret;
+    dc.entries = dc.entries->next;
+  }
   fn = filename;
-  while ( (NULL != (ss = strstr (fn,
-                                 DIR_SEPARATOR_STR))) &&
-          (strlen (ss) > 1) )
+  while ((NULL != (ss = strstr (fn, DIR_SEPARATOR_STR))) && (strlen (ss) > 1))
     fn = ss + 1;
-  GNUNET_asprintf (&dn,
-                   "%s/", 
-                   fn);
+  GNUNET_asprintf (&dn, "%s/", fn);
   GNUNET_CONTAINER_meta_data_insert (ret->meta,
-                                     "<gnunet>",
-                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
-                                     EXTRACTOR_METAFORMAT_C_STRING,
-                                     "text/plain",
-                                     dn,
-                                     strlen (dn) + 1);
+                                     "<gnunet>",
+                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
+                                     EXTRACTOR_METAFORMAT_C_STRING,
+                                     "text/plain", dn, strlen (dn) + 1);
   GNUNET_free (dn);
   ret->filename = GNUNET_strdup (filename);
   return ret;
@@ -595,7 +559,8 @@ GNUNET_FS_file_information_create_from_directory (struct GNUNET_FS_Handle *h,
  * @return GNUNET_YES if so, GNUNET_NO if not
  */
 int
-GNUNET_FS_file_information_is_directory (const struct GNUNET_FS_FileInformation *ent)
+GNUNET_FS_file_information_is_directory (const struct GNUNET_FS_FileInformation
+                                         *ent)
 {
   return ent->is_directory;
 }
@@ -617,10 +582,14 @@ GNUNET_FS_file_information_is_directory (const struct GNUNET_FS_FileInformation
  */
 struct GNUNET_FS_FileInformation *
 GNUNET_FS_file_information_create_empty_directory (struct GNUNET_FS_Handle *h,
-                                                   void *client_info,
-                                                   const struct GNUNET_FS_Uri *keywords,
-                                                   const struct GNUNET_CONTAINER_MetaData *meta,
-                                                   const struct GNUNET_FS_BlockOptions *bo)
+                                                   void *client_info,
+                                                   const struct GNUNET_FS_Uri
+                                                   *keywords,
+                                                   const struct
+                                                   GNUNET_CONTAINER_MetaData
+                                                   *meta,
+                                                   const struct
+                                                   GNUNET_FS_BlockOptions *bo)
 {
   struct GNUNET_FS_FileInformation *ret;
 
@@ -648,15 +617,13 @@ GNUNET_FS_file_information_create_empty_directory (struct GNUNET_FS_Handle *h,
  */
 int
 GNUNET_FS_file_information_add (struct GNUNET_FS_FileInformation *dir,
-                                struct GNUNET_FS_FileInformation *ent)
+                                struct GNUNET_FS_FileInformation *ent)
 {
-  if ( (ent->dir != NULL) ||
-       (ent->next != NULL) ||
-       (! dir->is_directory) )
-    {
-      GNUNET_break (0);
-      return GNUNET_SYSERR;
-    }
+  if ((ent->dir != NULL) || (ent->next != NULL) || (!dir->is_directory))
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
   ent->dir = dir;
   ent->next = dir->data.dir.entries;
   dir->data.dir.entries = ent;
@@ -681,41 +648,37 @@ GNUNET_FS_file_information_add (struct GNUNET_FS_FileInformation *dir,
  */
 void
 GNUNET_FS_file_information_inspect (struct GNUNET_FS_FileInformation *dir,
-                                    GNUNET_FS_FileInformationProcessor proc,
-                                    void *proc_cls)
+                                    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) ? dir->data.dir.dir_size : dir->data.file.file_size,
-            dir->meta,
-            &dir->keywords,
-            &dir->bo,
-            (dir->is_directory) ? &no : &dir->data.file.do_index,
-            &dir->client_info))
+      proc (proc_cls,
+            dir,
+            (dir->is_directory) ? dir->data.dir.dir_size : dir->data.
+            file.file_size, dir->meta, &dir->keywords, &dir->bo,
+            (dir->is_directory) ? &no : &dir->data.file.do_index,
+            &dir->client_info))
     return;
-  if (! dir->is_directory)
+  if (!dir->is_directory)
     return;
   pos = dir->data.dir.entries;
   while (pos != NULL)
-    {
-      no = GNUNET_NO;
-      if (GNUNET_OK != 
-          proc (proc_cls, 
-                pos,
-                (pos->is_directory) ? pos->data.dir.dir_size : pos->data.file.file_size,
-                pos->meta,
-                &pos->keywords,
-                &pos->bo,
-                (dir->is_directory) ? &no : &dir->data.file.do_index,
-                &pos->client_info))
-        break;
-      pos = pos->next;
-    }
+  {
+    no = GNUNET_NO;
+    if (GNUNET_OK !=
+        proc (proc_cls,
+              pos,
+              (pos->is_directory) ? pos->data.dir.dir_size : pos->data.
+              file.file_size, pos->meta, &pos->keywords, &pos->bo,
+              (dir->is_directory) ? &no : &dir->data.file.do_index,
+              &pos->client_info))
+      break;
+    pos = pos->next;
+  }
 }
 
 
@@ -731,70 +694,60 @@ GNUNET_FS_file_information_inspect (struct GNUNET_FS_FileInformation *dir,
  */
 void
 GNUNET_FS_file_information_destroy (struct GNUNET_FS_FileInformation *fi,
-                                    GNUNET_FS_FileInformationProcessor cleaner,
-                                    void *cleaner_cls)
+                                    GNUNET_FS_FileInformationProcessor cleaner,
+                                    void *cleaner_cls)
 {
   struct GNUNET_FS_FileInformation *pos;
   int no;
 
   no = GNUNET_NO;
   if (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 (fi->data.file.reader != NULL)
-        fi->data.file.reader (fi->data.file.reader_cls, 0, 0, 
-                              NULL, 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);
-    }
+  {
+    /* call clean-up function of the reader */
+    if (fi->data.file.reader != NULL)
+      fi->data.file.reader (fi->data.file.reader_cls, 0, 0, NULL, 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);
+  }
   GNUNET_free_non_null (fi->filename);
   GNUNET_free_non_null (fi->emsg);
   GNUNET_free_non_null (fi->chk_uri);
   /* clean up serialization */
-  if ( (NULL != fi->serialization) &&
-       (0 != UNLINK (fi->serialization)) )
+  if ((NULL != fi->serialization) && (0 != UNLINK (fi->serialization)))
     GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                              "unlink",
-                              fi->serialization);
+                              "unlink", fi->serialization);
   if (NULL != 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);
   if (fi->te != NULL)
-    {
-      GNUNET_FS_tree_encoder_finish (fi->te,
-                                     NULL, NULL);
-      fi->te = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (fi->te, NULL, NULL);
+    fi->te = NULL;
+  }
   GNUNET_free (fi);
 }
 
diff --git a/src/fs/fs_getopt.c b/src/fs/fs_getopt.c
index 0db7237f7..6c54fd69b 100644
--- a/src/fs/fs_getopt.c
+++ b/src/fs/fs_getopt.c
@@ -42,10 +42,9 @@
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
-                                         void *scls,
-                                         const char *option,
-                                         const char *value)
+GNUNET_FS_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;
@@ -53,60 +52,58 @@ GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext*
   size_t slen;
 
   if (u == NULL)
-    {
-      u = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
-      *uri = u;
-      u->type = ksk;
-      u->data.ksk.keywordCount = 0;
-      u->data.ksk.keywords = NULL;
-    }
+  {
+    u = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
+    *uri = u;
+    u->type = ksk;
+    u->data.ksk.keywordCount = 0;
+    u->data.ksk.keywords = NULL;
+  }
   else
-    {
-      GNUNET_assert (u->type == ksk);
-    }
+  {
+    GNUNET_assert (u->type == ksk);
+  }
   slen = strlen (value);
   if (slen == 0)
     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] = '+';
-          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] = '+';
+      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] = ' ';
+      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] = ' ';
-          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;
 }
 
@@ -124,11 +121,9 @@ GNUNET_FS_getopt_set_keywords (struct GNUNET_GETOPT_CommandLineProcessorContext*
  * @return GNUNET_OK on success
  */
 int
-GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx, 
-                                         void *scls,
-                                         const char *option,
-                                         const char *value)
-
+GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext
+                               *ctx, void *scls, const char *option,
+                               const char *value)
 {
   struct GNUNET_CONTAINER_MetaData **mm = scls;
   enum EXTRACTOR_MetaType type;
@@ -139,69 +134,68 @@ GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext*
 
   meta = *mm;
   if (meta == NULL)
-    {
-      meta = GNUNET_CONTAINER_meta_data_create ();
-      *mm = meta;
-    }
+  {
+    meta = GNUNET_CONTAINER_meta_data_create ();
+    *mm = meta;
+  }
 
 #if ENABLE_NLS
-  tmp = GNUNET_STRINGS_to_utf8 (value, strlen (value),
-                                nl_langinfo (CODESET));
+  tmp = GNUNET_STRINGS_to_utf8 (value, strlen (value), nl_langinfo (CODESET));
 #else
-  tmp = GNUNET_STRINGS_to_utf8 (value, strlen (value),
-                                "utf-8");
+  tmp = GNUNET_STRINGS_to_utf8 (value, strlen (value), "utf-8");
 #endif
   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 (tmp != NULL)
+    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>",
-                                         EXTRACTOR_METATYPE_UNKNOWN, 
-                                         EXTRACTOR_METAFORMAT_UTF8,
-                                         "text/plain",
-                                         tmp,
-                                         strlen(tmp) + 1);
+      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);
-      printf (_
-              ("Unknown metadata type in metadata option `%s'.  Using metadata type `unknown' instead.\n"),
-              value);
+      tmp = NULL;
+      break;
     }
+  }
+  if (tmp != NULL)
+  {
+    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;
 }
 
diff --git a/src/fs/fs_list_indexed.c b/src/fs/fs_list_indexed.c
index fec127763..1eb290f11 100644
--- a/src/fs/fs_list_indexed.c
+++ b/src/fs/fs_list_indexed.c
@@ -76,8 +76,7 @@ struct GetIndexedContext
  * @param msg message with indexing information
  */
 static void
-handle_index_info (void *cls,
-                   const struct GNUNET_MessageHeader *msg)
+handle_index_info (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GetIndexedContext *gic = cls;
   const struct IndexInfoMessage *iim;
@@ -85,64 +84,58 @@ handle_index_info (void *cls,
   const char *filename;
 
   if (NULL == msg)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to receive response for `%s' request from `%s' service.\n"),
-                  "GET_INDEXED",
-                  "fs");
-      GNUNET_SCHEDULER_add_continuation (gic->cont,
-                                         gic->cont_cls,
-                                         GNUNET_SCHEDULER_REASON_TIMEOUT);
-      GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
-      GNUNET_free (gic);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("Failed to receive response for `%s' request from `%s' service.\n"),
+                "GET_INDEXED", "fs");
+    GNUNET_SCHEDULER_add_continuation (gic->cont, gic->cont_cls,
+                                       GNUNET_SCHEDULER_REASON_TIMEOUT);
+    GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
+    GNUNET_free (gic);
+    return;
+  }
   if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END)
-    {
-      /* normal end-of-list */
-      GNUNET_SCHEDULER_add_continuation (gic->cont,
-                                         gic->cont_cls,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
-      GNUNET_free (gic);
-      return;
-    }
+  {
+    /* normal end-of-list */
+    GNUNET_SCHEDULER_add_continuation (gic->cont,
+                                       gic->cont_cls,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
+    GNUNET_free (gic);
+    return;
+  }
   msize = ntohs (msg->size);
-  iim = (const struct IndexInfoMessage*) msg;
-  filename = (const char*) &iim[1];
-  if ( (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY) ||
-       (msize <= sizeof (struct IndexInfoMessage)) ||
-       (filename[msize-sizeof (struct IndexInfoMessage) -1] != '\0') )
-    {
-      /* bogus reply */
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to receive valid response for `%s' request from `%s' service.\n"),
-                  "GET_INDEXED",
-                  "fs");
-      GNUNET_SCHEDULER_add_continuation (gic->cont,
-                                         gic->cont_cls,
-                                         GNUNET_SCHEDULER_REASON_TIMEOUT);
-      GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
-      GNUNET_free (gic);
-      return;
-    }
-  if (GNUNET_OK !=
-      gic->iterator (gic->iterator_cls,
-                     filename,
-                     &iim->file_id))
-    {
-      GNUNET_SCHEDULER_add_continuation (gic->cont,
-                                         gic->cont_cls,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
-      GNUNET_free (gic);
-      return;
-    }
+  iim = (const struct IndexInfoMessage *) msg;
+  filename = (const char *) &iim[1];
+  if ((ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY) ||
+      (msize <= sizeof (struct IndexInfoMessage)) ||
+      (filename[msize - sizeof (struct IndexInfoMessage) - 1] != '\0'))
+  {
+    /* bogus reply */
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("Failed to receive valid response for `%s' request from `%s' service.\n"),
+                "GET_INDEXED", "fs");
+    GNUNET_SCHEDULER_add_continuation (gic->cont, gic->cont_cls,
+                                       GNUNET_SCHEDULER_REASON_TIMEOUT);
+    GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
+    GNUNET_free (gic);
+    return;
+  }
+  if (GNUNET_OK != gic->iterator (gic->iterator_cls, filename, &iim->file_id))
+  {
+    GNUNET_SCHEDULER_add_continuation (gic->cont,
+                                       gic->cont_cls,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    GNUNET_CLIENT_disconnect (gic->client, GNUNET_NO);
+    GNUNET_free (gic);
+    return;
+  }
   /* get more */
   GNUNET_CLIENT_receive (gic->client,
-                         &handle_index_info,
-                         gic,
-                         GNUNET_CONSTANTS_SERVICE_TIMEOUT);  
+                         &handle_index_info,
+                         gic, GNUNET_CONSTANTS_SERVICE_TIMEOUT);
 }
 
 
@@ -157,29 +150,26 @@ handle_index_info (void *cls,
  *             error) or  "PREREQ_DONE" (on success)
  * @param cont_cls closure for cont
  */
-void 
+void
 GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h,
-                             GNUNET_FS_IndexedFileProcessor iterator,
-                             void *iterator_cls,
-                             GNUNET_SCHEDULER_Task cont,
-                             void *cont_cls)
+                             GNUNET_FS_IndexedFileProcessor iterator,
+                             void *iterator_cls,
+                             GNUNET_SCHEDULER_Task cont, void *cont_cls)
 {
   struct GNUNET_CLIENT_Connection *client;
   struct GetIndexedContext *gic;
   struct GNUNET_MessageHeader msg;
 
-  client = GNUNET_CLIENT_connect ("fs",
-                                  h->cfg);
+  client = GNUNET_CLIENT_connect ("fs", h->cfg);
   if (NULL == client)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Failed to not connect to `%s' service.\n"),
-                  "fs");
-      GNUNET_SCHEDULER_add_continuation (cont,
-                                         cont_cls,
-                                         GNUNET_SCHEDULER_REASON_TIMEOUT);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _("Failed to not connect to `%s' service.\n"), "fs");
+    GNUNET_SCHEDULER_add_continuation (cont,
+                                       cont_cls,
+                                       GNUNET_SCHEDULER_REASON_TIMEOUT);
+    return;
+  }
 
   gic = GNUNET_malloc (sizeof (struct GetIndexedContext));
   gic->h = h;
@@ -191,12 +181,12 @@ GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h,
   msg.size = htons (sizeof (struct GNUNET_MessageHeader));
   msg.type = htons (GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET);
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CLIENT_transmit_and_get_response (client,
-                                                          &msg,
-                                                          GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                          GNUNET_YES,
-                                                          &handle_index_info,
-                                                          gic));
+                 GNUNET_CLIENT_transmit_and_get_response (client,
+                                                          &msg,
+                                                          GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                                          GNUNET_YES,
+                                                          &handle_index_info,
+                                                          gic));
 }
 
 /* end of fs_list_indexed.c */
diff --git a/src/fs/fs_misc.c b/src/fs/fs_misc.c
index 73dcd4e36..9fa86a5c4 100644
--- a/src/fs/fs_misc.c
+++ b/src/fs/fs_misc.c
@@ -35,7 +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"},
@@ -65,12 +66,12 @@ GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md
     {"application/x-xcf", ".xcf"},
     {"application/x-xfig", ".xfig"},
     {"application/zip", ".zip"},
-    
+
     {"audio/midi", ".midi"},
     {"audio/mpeg", ".mp3"},
     {"audio/real", ".rm"},
     {"audio/x-wav", ".wav"},
-    
+
     {"image/gif", ".gif"},
     {"image/jpeg", ".jpg"},
     {"image/pcx", ".pcx"},
@@ -78,7 +79,7 @@ GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md
     {"image/tiff", ".tiff"},
     {"image/x-ms-bmp", ".bmp"},
     {"image/x-xpixmap", ".xpm"},
-    
+
     {"text/css", ".css"},
     {"text/html", ".html"},
     {"text/plain", ".txt"},
@@ -93,7 +94,7 @@ GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md
     {"text/x-perl", ".pl"},
     {"text/x-python", ".py"},
     {"text/x-tex", ".tex"},
-    
+
     {"video/avi", ".avi"},
     {"video/mpeg", ".mpeg"},
     {"video/quicktime", ".qt"},
@@ -108,56 +109,50 @@ GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md
   const char *ext;
 
   ret = GNUNET_CONTAINER_meta_data_get_by_type (md,
-                                                EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+                                                EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
   if (ret != NULL)
-    return ret;  
+    return ret;
   ext = NULL;
   mime = GNUNET_CONTAINER_meta_data_get_by_type (md,
-                                                 EXTRACTOR_METATYPE_MIMETYPE);
+                                                 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);
-  if ( (base == NULL) &&
-       (ext == NULL) )
+                                                        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);
   if (ext == NULL)
     return base;
-  GNUNET_asprintf (&ret,
-                   "%s%s",
-                   base,
-                   ext);
+  GNUNET_asprintf (&ret, "%s%s", base, ext);
   GNUNET_free (base);
   return ret;
 }
@@ -168,7 +163,7 @@ GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md
  */
 unsigned int
 GNUNET_FS_get_current_year ()
-{ 
+{
   time_t tp;
   struct tm *t;
 
@@ -195,18 +190,18 @@ GNUNET_FS_year_to_time (unsigned int year)
 
   memset (&t, 0, sizeof (t));
   if (year < 1900)
-    {
-      GNUNET_break (0);
-      return GNUNET_TIME_absolute_get (); /* now */
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_TIME_absolute_get (); /* now */
+  }
   t.tm_year = year - 1900;
   t.tm_mday = 1;
   t.tm_mon = 1;
   t.tm_wday = 1;
   t.tm_yday = 1;
   tp = mktime (&t);
-  GNUNET_break (tp != (time_t) -1);
-  ret.abs_value = tp * 1000LL; /* seconds to ms */
+  GNUNET_break (tp != (time_t) - 1);
+  ret.abs_value = tp * 1000LL;  /* seconds to ms */
   return ret;
 }
 
diff --git a/src/fs/fs_namespace.c b/src/fs/fs_namespace.c
index cd0bfc415..e8dd56ef4 100644
--- a/src/fs/fs_namespace.c
+++ b/src/fs/fs_namespace.c
@@ -46,16 +46,13 @@ get_namespace_directory (struct GNUNET_FS_Handle *h)
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (h->cfg,
-                                               "FS",
-                                               "IDENTITY_DIR",
-                                               &dn))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Configuration fails to specify `%s' in section `%s'\n"),
-                  "IDENTITY_DIR",
-                  "fs");
-      return NULL;
-    }
+                                               "FS", "IDENTITY_DIR", &dn))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Configuration fails to specify `%s' in section `%s'\n"),
+                "IDENTITY_DIR", "fs");
+    return NULL;
+  }
   return dn;
 }
 
@@ -75,21 +72,14 @@ get_update_information_directory (struct GNUNET_FS_Namespace *ns)
 
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (ns->h->cfg,
-                                               "FS",
-                                               "UPDATE_DIR",
-                                               &dn))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Configuration fails to specify `%s' in section `%s'\n"),
-                  "UPDATE_DIR",
-                  "fs");
-      return NULL;
-    }
-  GNUNET_asprintf (&ret,
-                   "%s%s%s",
-                   dn,
-                   DIR_SEPARATOR_STR,
-                   ns->name);
+                                               "FS", "UPDATE_DIR", &dn))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Configuration fails to specify `%s' in section `%s'\n"),
+                "UPDATE_DIR", "fs");
+    return NULL;
+  }
+  GNUNET_asprintf (&ret, "%s%s%s", dn, DIR_SEPARATOR_STR, ns->name);
   GNUNET_free (dn);
   return ret;
 }
@@ -103,7 +93,7 @@ get_update_information_directory (struct GNUNET_FS_Namespace *ns)
 static void
 write_update_information_graph (struct GNUNET_FS_Namespace *ns)
 {
-  char * fn;
+  char *fn;
   struct GNUNET_BIO_WriteHandle *wh;
   unsigned int i;
   struct NamespaceUpdateNode *n;
@@ -112,39 +102,35 @@ write_update_information_graph (struct GNUNET_FS_Namespace *ns)
   fn = get_update_information_directory (ns);
   wh = GNUNET_BIO_write_open (fn);
   if (wh == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to open `%s' for writing: %s\n"),
-                  STRERROR (errno));
-      GNUNET_free (fn);
-      return;
-    }
-  if (GNUNET_OK != 
-      GNUNET_BIO_write_int32 (wh, ns->update_node_count))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to open `%s' for writing: %s\n"), STRERROR (errno));
+    GNUNET_free (fn);
+    return;
+  }
+  if (GNUNET_OK != GNUNET_BIO_write_int32 (wh, ns->update_node_count))
     goto END;
-  for (i=0;i<ns->update_node_count;i++)
+  for (i = 0; i < ns->update_node_count; i++)
+  {
+    n = ns->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 = ns->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);
+      break;
     }
- END:
+    GNUNET_free (uris);
+  }
+END:
   if (GNUNET_OK != GNUNET_BIO_write_close (wh))
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                _("Failed to write `%s': %s\n"),
-                STRERROR (errno));
+                _("Failed to write `%s': %s\n"), STRERROR (errno));
   GNUNET_free (fn);
 }
 
@@ -157,89 +143,85 @@ write_update_information_graph (struct GNUNET_FS_Namespace *ns)
 static void
 read_update_information_graph (struct GNUNET_FS_Namespace *ns)
 {
-  char * fn;
+  char *fn;
   struct GNUNET_BIO_ReadHandle *rh;
   unsigned int i;
   struct NamespaceUpdateNode *n;
   char *uris;
   uint32_t count;
   char *emsg;
-  
+
   fn = get_update_information_directory (ns);
-  if (GNUNET_YES !=
-      GNUNET_DISK_file_test (fn))
-    {
-      GNUNET_free (fn);
-      return;
-    }
+  if (GNUNET_YES != GNUNET_DISK_file_test (fn))
+  {
+    GNUNET_free (fn);
+    return;
+  }
   rh = GNUNET_BIO_read_open (fn);
   if (rh == NULL)
-    {
-      GNUNET_free (fn);
-      return;
-    }
-  if (GNUNET_OK != 
-      GNUNET_BIO_read_int32 (rh, &count))
-    {
-      GNUNET_break (0);
-      goto END;
-    }
+  {
+    GNUNET_free (fn);
+    return;
+  }
+  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 (count == 0)
+  {
+    GNUNET_break (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
+    GNUNET_free (fn);
+    return;
+  }
+  ns->update_nodes =
+      GNUNET_malloc (count * sizeof (struct NamespaceUpdateNode *));
+
+  for (i = 0; i < count; i++)
+  {
+    n = GNUNET_malloc (sizeof (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 (GNUNET_OK == GNUNET_BIO_read_close (rh, NULL));
-      GNUNET_free (fn);
-      return;
+      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;
     }
-  ns->update_nodes = GNUNET_malloc (count * sizeof (struct NamespaceUpdateNode*));
-  
-  for (i=0;i<count;i++)
+    n->uri = GNUNET_FS_uri_parse (uris, &emsg);
+    GNUNET_free (uris);
+    if (n->uri == NULL)
     {
-      n = GNUNET_malloc (sizeof (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;
-        }
-      ns->update_nodes[i] = n;
+      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;
     }
+    ns->update_nodes[i] = n;
+  }
   ns->update_node_count = i;
- END:
+END:
   if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to write `%s': %s\n"),
-                  emsg);
-      GNUNET_free (emsg);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Failed to write `%s': %s\n"), emsg);
+    GNUNET_free (emsg);
+  }
   GNUNET_free (fn);
 }
 
@@ -266,7 +248,7 @@ struct AdvertisementContext
 
   /**
    * Our KSK URI.
-   */ 
+   */
   struct GNUNET_FS_Uri *ksk_uri;
 
   /**
@@ -291,7 +273,7 @@ struct AdvertisementContext
 
   /**
    * Number of bytes of plaintext.
-   */ 
+   */
   size_t pt_size;
 
   /**
@@ -308,13 +290,11 @@ struct AdvertisementContext
  * @param tc scheduler context
  */
 static void
-do_disconnect (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_disconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_DATASTORE_Handle *dsh = cls;
 
-  GNUNET_DATASTORE_disconnect (dsh, 
-                               GNUNET_NO);
+  GNUNET_DATASTORE_disconnect (dsh, GNUNET_NO);
 }
 
 
@@ -327,9 +307,7 @@ do_disconnect (void *cls,
  * @param msg NULL on success, otherwise an error message
  */
 static void
-advertisement_cont (void *cls,
-                    int success,
-                    const char *msg)
+advertisement_cont (void *cls, int success, const char *msg)
 {
   struct AdvertisementContext *ac = cls;
   const char *keyword;
@@ -338,81 +316,75 @@ advertisement_cont (void *cls,
   struct GNUNET_CRYPTO_AesSessionKey skey;
   struct GNUNET_CRYPTO_AesInitializationVector iv;
   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
-  
+
   if (GNUNET_OK != success)
+  {
+    /* error! */
+    GNUNET_SCHEDULER_add_continuation (&do_disconnect,
+                                       ac->dsh,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    if (msg == NULL)
     {
-      /* error! */
-      GNUNET_SCHEDULER_add_continuation (&do_disconnect,
-                                         ac->dsh,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      if (msg == NULL)
-        {
-          GNUNET_break (0);
-          msg = _("Unknown error");
-        }
-      if (ac->cont != NULL)
-        ac->cont (ac->cont_cls, NULL, msg);
-      GNUNET_FS_uri_destroy (ac->ksk_uri);
-      GNUNET_free (ac->pt);
-      GNUNET_free (ac->nb);
-      GNUNET_FS_namespace_delete (ac->ns, GNUNET_NO);
-      GNUNET_free (ac);
-      return;
+      GNUNET_break (0);
+      msg = _("Unknown error");
     }
+    if (ac->cont != NULL)
+      ac->cont (ac->cont_cls, NULL, msg);
+    GNUNET_FS_uri_destroy (ac->ksk_uri);
+    GNUNET_free (ac->pt);
+    GNUNET_free (ac->nb);
+    GNUNET_FS_namespace_delete (ac->ns, GNUNET_NO);
+    GNUNET_free (ac);
+    return;
+  }
   if (ac->pos == ac->ksk_uri->data.ksk.keywordCount)
-    {
-      /* done! */
-      GNUNET_SCHEDULER_add_continuation (&do_disconnect,
-                                         ac->dsh,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      if (ac->cont != NULL)
-        ac->cont (ac->cont_cls, ac->ksk_uri, NULL);
-      GNUNET_FS_uri_destroy (ac->ksk_uri);
-      GNUNET_free (ac->pt);
-      GNUNET_free (ac->nb);
-      GNUNET_FS_namespace_delete (ac->ns, GNUNET_NO);
-      GNUNET_free (ac);
-      return;
-    }
+  {
+    /* done! */
+    GNUNET_SCHEDULER_add_continuation (&do_disconnect,
+                                       ac->dsh,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    if (ac->cont != NULL)
+      ac->cont (ac->cont_cls, ac->ksk_uri, NULL);
+    GNUNET_FS_uri_destroy (ac->ksk_uri);
+    GNUNET_free (ac->pt);
+    GNUNET_free (ac->nb);
+    GNUNET_FS_namespace_delete (ac->ns, GNUNET_NO);
+    GNUNET_free (ac);
+    return;
+  }
   keyword = ac->ksk_uri->data.ksk.keywords[ac->pos++];
   /* first character of keyword indicates if it is
-     mandatory or not -- ignore for hashing */
+   * mandatory or not -- ignore for hashing */
   GNUNET_CRYPTO_hash (&keyword[1], strlen (&keyword[1]), &key);
   GNUNET_CRYPTO_hash_to_aes_key (&key, &skey, &iv);
-  GNUNET_CRYPTO_aes_encrypt (ac->pt,
-                             ac->pt_size,
-                             &skey,
-                             &iv,
-                             &ac->nb[1]);
-  GNUNET_break (GNUNET_OK == 
-                GNUNET_CRYPTO_rsa_sign (ac->ns->key,
-                                        &ac->nb->ns_purpose,
-                                        &ac->nb->ns_signature));
+  GNUNET_CRYPTO_aes_encrypt (ac->pt, ac->pt_size, &skey, &iv, &ac->nb[1]);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CRYPTO_rsa_sign (ac->ns->key,
+                                        &ac->nb->ns_purpose,
+                                        &ac->nb->ns_signature));
   pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&key);
   GNUNET_assert (pk != NULL);
   GNUNET_CRYPTO_rsa_key_get_public (pk, &ac->nb->keyspace);
   GNUNET_CRYPTO_hash (&ac->nb->keyspace,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &query);
-  GNUNET_break (GNUNET_OK == 
-                GNUNET_CRYPTO_rsa_sign (pk,
-                                        &ac->nb->ksk_purpose,
-                                        &ac->nb->ksk_signature));
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &query);
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CRYPTO_rsa_sign (pk,
+                                        &ac->nb->ksk_purpose,
+                                        &ac->nb->ksk_signature));
   GNUNET_CRYPTO_rsa_key_free (pk);
-  GNUNET_DATASTORE_put (ac->dsh,
-                        0 /* no reservation */, 
-                        &query,
-                        ac->pt_size + sizeof (struct NBlock),
-                        ac->nb,
-                        GNUNET_BLOCK_TYPE_FS_NBLOCK,
-                        ac->bo.content_priority,
-                        ac->bo.anonymity_level,
-                        ac->bo.replication_level,
-                        ac->bo.expiration_time,
-                        -2, 1,
-                        GNUNET_CONSTANTS_SERVICE_TIMEOUT, 
-                        &advertisement_cont,
-                        ac);
+  GNUNET_DATASTORE_put (ac->dsh, 0 /* no reservation */ ,
+                        &query,
+                        ac->pt_size + sizeof (struct NBlock),
+                        ac->nb,
+                        GNUNET_BLOCK_TYPE_FS_NBLOCK,
+                        ac->bo.content_priority,
+                        ac->bo.anonymity_level,
+                        ac->bo.replication_level,
+                        ac->bo.expiration_time,
+                        -2, 1,
+                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                        &advertisement_cont, ac);
 }
 
 
@@ -430,13 +402,13 @@ advertisement_cont (void *cls,
  */
 void
 GNUNET_FS_namespace_advertise (struct GNUNET_FS_Handle *h,
-                               struct GNUNET_FS_Uri *ksk_uri,
-                               struct GNUNET_FS_Namespace *namespace,
-                               const struct GNUNET_CONTAINER_MetaData *meta,
-                               const struct GNUNET_FS_BlockOptions *bo,
-                               const char *rootEntry,
-                               GNUNET_FS_PublishContinuation cont,
-                               void *cont_cls)
+                               struct GNUNET_FS_Uri *ksk_uri,
+                               struct GNUNET_FS_Namespace *namespace,
+                               const struct GNUNET_CONTAINER_MetaData *meta,
+                               const struct GNUNET_FS_BlockOptions *bo,
+                               const char *rootEntry,
+                               GNUNET_FS_PublishContinuation cont,
+                               void *cont_cls)
 {
   size_t reslen;
   size_t size;
@@ -450,50 +422,52 @@ GNUNET_FS_namespace_advertise (struct GNUNET_FS_Handle *h,
   /* create advertisements */
   mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
   if (-1 == mdsize)
-    {
-      cont (cont_cls, NULL, _("Failed to serialize meta data"));
-      return;
-    }
+  {
+    cont (cont_cls, NULL, _("Failed to serialize meta data"));
+    return;
+  }
   reslen = strlen (rootEntry) + 1;
   size = mdsize + sizeof (struct NBlock) + reslen;
   if (size > MAX_NBLOCK_SIZE)
-    {
-      size = MAX_NBLOCK_SIZE;
-      mdsize = size - sizeof (struct NBlock) - reslen;
-    }
+  {
+    size = MAX_NBLOCK_SIZE;
+    mdsize = size - sizeof (struct NBlock) - reslen;
+  }
 
   pt = GNUNET_malloc (mdsize + reslen);
   memcpy (pt, rootEntry, reslen);
   mdst = &pt[reslen];
   mdsize = GNUNET_CONTAINER_meta_data_serialize (meta,
-                                                 &mdst,
-                                                 mdsize,
-                                                 GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+                                                 &mdst,
+                                                 mdsize,
+                                                 GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (mdsize == -1)
-    {
-      GNUNET_break (0);
-      GNUNET_free (pt);
-      cont (cont_cls, NULL, _("Failed to serialize meta data"));
-      return;
-    }
-  size = mdsize + sizeof (struct NBlock) + reslen;  
+  {
+    GNUNET_break (0);
+    GNUNET_free (pt);
+    cont (cont_cls, NULL, _("Failed to serialize meta data"));
+    return;
+  }
+  size = mdsize + sizeof (struct NBlock) + reslen;
   nb = GNUNET_malloc (size);
-  GNUNET_CRYPTO_rsa_key_get_public (namespace->key, 
-                                    &nb->subspace);
-  nb->ns_purpose.size = htonl (mdsize + reslen + 
-                            sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
-                            sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+  GNUNET_CRYPTO_rsa_key_get_public (namespace->key, &nb->subspace);
+  nb->ns_purpose.size = htonl (mdsize + reslen +
+                               sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose)
+                               +
+                               sizeof (struct
+                                       GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
   nb->ns_purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK);
-  nb->ksk_purpose.size = htonl (size - sizeof (struct GNUNET_CRYPTO_RsaSignature));
+  nb->ksk_purpose.size =
+      htonl (size - sizeof (struct GNUNET_CRYPTO_RsaSignature));
   nb->ksk_purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_NBLOCK_KSIG);
   dsh = GNUNET_DATASTORE_connect (h->cfg);
   if (NULL == dsh)
-    {
-      GNUNET_free (nb);
-      GNUNET_free (pt);
-      cont (cont_cls, NULL, _("Failed to connect to datastore service"));
-      return;
-    }  
+  {
+    GNUNET_free (nb);
+    GNUNET_free (pt);
+    cont (cont_cls, NULL, _("Failed to connect to datastore service"));
+    return;
+  }
   ctx = GNUNET_malloc (sizeof (struct AdvertisementContext));
   ctx->cont = cont;
   ctx->cont_cls = cont_cls;
@@ -518,33 +492,28 @@ GNUNET_FS_namespace_advertise (struct GNUNET_FS_Handle *h,
  * @return handle to the namespace, NULL on error
  */
 struct GNUNET_FS_Namespace *
-GNUNET_FS_namespace_create (struct GNUNET_FS_Handle *h,
-                            const char *name)
+GNUNET_FS_namespace_create (struct GNUNET_FS_Handle *h, const char *name)
 {
   char *dn;
   char *fn;
   struct GNUNET_FS_Namespace *ret;
 
   dn = get_namespace_directory (h);
-  GNUNET_asprintf (&fn,
-                   "%s%s%s",
-                   dn,
-                   DIR_SEPARATOR_STR,
-                   name);
+  GNUNET_asprintf (&fn, "%s%s%s", dn, DIR_SEPARATOR_STR, name);
   GNUNET_free (dn);
   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Namespace));
   ret->h = h;
   ret->rc = 1;
   ret->key = GNUNET_CRYPTO_rsa_key_create_from_file (fn);
   if (ret->key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to create or read private key for namespace `%s'\n"),
-                  name);
-      GNUNET_free (ret);
-      GNUNET_free (fn);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to create or read private key for namespace `%s'\n"),
+                name);
+    GNUNET_free (ret);
+    GNUNET_free (fn);
+    return NULL;
+  }
   ret->name = GNUNET_strdup (name);
   ret->filename = fn;
   return ret;
@@ -562,42 +531,39 @@ GNUNET_FS_namespace_create (struct GNUNET_FS_Handle *h,
  *
  * @return GNUNET_OK on success, GNUNET_SYSERR on error
  */
-int 
-GNUNET_FS_namespace_delete (struct GNUNET_FS_Namespace *namespace,
-                            int freeze)
+int
+GNUNET_FS_namespace_delete (struct GNUNET_FS_Namespace *namespace, int freeze)
 {
   unsigned int i;
   struct NamespaceUpdateNode *nsn;
 
   namespace->rc--;
   if (freeze)
-    {
-      if (0 != UNLINK (namespace->filename))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
-                                  "unlink",
-                                  namespace->filename);      
-    }
+  {
+    if (0 != UNLINK (namespace->filename))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
+                                "unlink", namespace->filename);
+  }
   if (0 == namespace->rc)
+  {
+    GNUNET_CRYPTO_rsa_key_free (namespace->key);
+    GNUNET_free (namespace->filename);
+    GNUNET_free (namespace->name);
+    for (i = 0; i < namespace->update_node_count; i++)
     {
-      GNUNET_CRYPTO_rsa_key_free (namespace->key);
-      GNUNET_free (namespace->filename);
-      GNUNET_free (namespace->name);
-      for (i=0;i<namespace->update_node_count;i++)
-        {
-          nsn = namespace->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 (namespace->update_nodes,
-                         namespace->update_node_count,
-                         0);
-      if (namespace->update_map != NULL)
-        GNUNET_CONTAINER_multihashmap_destroy (namespace->update_map);
-      GNUNET_free (namespace);
+      nsn = namespace->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 (namespace->update_nodes,
+                       namespace->update_node_count, 0);
+    if (namespace->update_map != NULL)
+      GNUNET_CONTAINER_multihashmap_destroy (namespace->update_map);
+    GNUNET_free (namespace);
+  }
   return GNUNET_OK;
 }
 
@@ -630,8 +596,7 @@ struct ProcessNamespaceContext
  *  GNUNET_SYSERR to abort iteration with error!
  */
 static int
-process_namespace (void *cls, 
-                   const char *filename)
+process_namespace (void *cls, const char *filename)
 {
   struct ProcessNamespaceContext *pnc = cls;
   struct GNUNET_CRYPTO_RsaPrivateKey *key;
@@ -642,25 +607,22 @@ process_namespace (void *cls,
 
   key = GNUNET_CRYPTO_rsa_key_create_from_file (filename);
   if (key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to read namespace private key file `%s', deleting it!\n"),
-                  filename);
-      if (0 != UNLINK (filename))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
-                                  "unlink",
-                                  filename);
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _
+                ("Failed to read namespace private key file `%s', deleting it!\n"),
+                filename);
+    if (0 != UNLINK (filename))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink", filename);
+    return GNUNET_OK;
+  }
   GNUNET_CRYPTO_rsa_key_get_public (key, &pk);
   GNUNET_CRYPTO_rsa_key_free (key);
-  GNUNET_CRYPTO_hash (&pk, sizeof(pk), &id); 
+  GNUNET_CRYPTO_hash (&pk, sizeof (pk), &id);
   name = filename;
   while (NULL != (t = strstr (name, DIR_SEPARATOR_STR)))
     name = t + 1;
-  pnc->cb (pnc->cb_cls,
-           name,
-           &id);
+  pnc->cb (pnc->cb_cls, name, &id);
   return GNUNET_OK;
 }
 
@@ -674,22 +636,19 @@ process_namespace (void *cls,
  * @param cb function to call on each known namespace
  * @param cb_cls closure for cb
  */
-void 
+void
 GNUNET_FS_namespace_list (struct GNUNET_FS_Handle *h,
-                          GNUNET_FS_NamespaceInfoProcessor cb,
-                          void *cb_cls)
+                          GNUNET_FS_NamespaceInfoProcessor cb, void *cb_cls)
 {
   char *dn;
   struct ProcessNamespaceContext ctx;
-  
+
   dn = get_namespace_directory (h);
   if (dn == NULL)
     return;
   ctx.cb = cb;
   ctx.cb_cls = cb_cls;
-  GNUNET_DISK_directory_scan (dn,
-                              &process_namespace,
-                              &ctx);
+  GNUNET_DISK_directory_scan (dn, &process_namespace, &ctx);
   GNUNET_free (dn);
 }
 
@@ -730,7 +689,7 @@ struct PublishSksContext
 
   /**
    * Closure for cont.
-   */ 
+   */
   void *cont_cls;
 
 };
@@ -745,66 +704,56 @@ struct PublishSksContext
  * @param msg error message (or NULL)
  */
 static void
-sb_put_cont (void *cls,
-             int success,
-             const char *msg)
+sb_put_cont (void *cls, int success, const char *msg)
 {
   struct PublishSksContext *psc = cls;
   GNUNET_HashCode hc;
 
   if (NULL != psc->dsh)
-    {
-      GNUNET_DATASTORE_disconnect (psc->dsh, GNUNET_NO);
-      psc->dsh = NULL;
-    }
+  {
+    GNUNET_DATASTORE_disconnect (psc->dsh, GNUNET_NO);
+    psc->dsh = NULL;
+  }
   if (GNUNET_OK != success)
-    {
-      if (psc->cont != NULL)
-        psc->cont (psc->cont_cls,
-                   NULL,
-                   msg);
-    }
+  {
+    if (psc->cont != NULL)
+      psc->cont (psc->cont_cls, NULL, msg);
+  }
   else
+  {
+    if (psc->nsn != NULL)
     {
-      if (psc->nsn != NULL)
-        {
-          /* FIXME: this can be done much more
-             efficiently by simply appending to the
-             file and overwriting the 4-byte header */
-          if (psc->namespace->update_nodes == NULL)
-            read_update_information_graph (psc->namespace);
-          GNUNET_array_append (psc->namespace->update_nodes,
-                               psc->namespace->update_node_count,
-                               psc->nsn);
-          if (psc->namespace->update_map != NULL)
-            {
-              GNUNET_CRYPTO_hash (psc->nsn->id,
-                                  strlen (psc->nsn->id),
-                                  &hc);
-              GNUNET_CONTAINER_multihashmap_put (psc->namespace->update_map,
-                                                 &hc,
-                                                 psc->nsn,
-                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-            }
-          psc->nsn = NULL;
-          write_update_information_graph (psc->namespace);
-        }
-      if (psc->cont != NULL)
-        psc->cont (psc->cont_cls,
-                   psc->uri,
-                   NULL);
+      /* FIXME: this can be done much more
+       * efficiently by simply appending to the
+       * file and overwriting the 4-byte header */
+      if (psc->namespace->update_nodes == NULL)
+        read_update_information_graph (psc->namespace);
+      GNUNET_array_append (psc->namespace->update_nodes,
+                           psc->namespace->update_node_count, psc->nsn);
+      if (psc->namespace->update_map != NULL)
+      {
+        GNUNET_CRYPTO_hash (psc->nsn->id, strlen (psc->nsn->id), &hc);
+        GNUNET_CONTAINER_multihashmap_put (psc->namespace->update_map,
+                                           &hc,
+                                           psc->nsn,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+      }
+      psc->nsn = NULL;
+      write_update_information_graph (psc->namespace);
     }
-  GNUNET_FS_namespace_delete (psc->namespace,
-                              GNUNET_NO);
+    if (psc->cont != NULL)
+      psc->cont (psc->cont_cls, psc->uri, NULL);
+  }
+  GNUNET_FS_namespace_delete (psc->namespace, GNUNET_NO);
   GNUNET_FS_uri_destroy (psc->uri);
   if (psc->nsn != NULL)
-    {
-      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_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);
 }
 
@@ -825,15 +774,14 @@ sb_put_cont (void *cls,
  */
 void
 GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
-                       struct GNUNET_FS_Namespace *namespace,
-                       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_Namespace *namespace,
+                       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 PublishSksContext *psc;
   struct GNUNET_CRYPTO_AesSessionKey sk;
@@ -849,9 +797,9 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   struct SBlock *sb_enc;
   char *dest;
   struct GNUNET_CONTAINER_MetaData *mmeta;
-  GNUNET_HashCode key;         /* hash of thisId = key */
-  GNUNET_HashCode id;          /* hash of hc = identifier */
-  GNUNET_HashCode query;       /* id ^ nsid = DB query */
+  GNUNET_HashCode key;          /* hash of thisId = key */
+  GNUNET_HashCode id;           /* hash of hc = identifier */
+  GNUNET_HashCode query;        /* id ^ nsid = DB query */
 
   if (NULL == meta)
     mmeta = GNUNET_CONTAINER_meta_data_create ();
@@ -867,10 +815,10 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   mdsize = GNUNET_CONTAINER_meta_data_get_serialized_size (mmeta);
   size = sizeof (struct SBlock) + slen + nidlen + mdsize;
   if (size > MAX_SBLOCK_SIZE)
-    {
-      size = MAX_SBLOCK_SIZE;
-      mdsize = size - (sizeof (struct SBlock) + slen + nidlen);
-    }
+  {
+    size = MAX_SBLOCK_SIZE;
+    mdsize = size - (sizeof (struct SBlock) + slen + nidlen);
+  }
   sb = GNUNET_malloc (sizeof (struct SBlock) + size);
   dest = (char *) &sb[1];
   if (update != NULL)
@@ -882,19 +830,17 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   GNUNET_free (uris);
   dest += slen;
   mdsize = GNUNET_CONTAINER_meta_data_serialize (mmeta,
-                                                 &dest,
-                                                 mdsize, 
-                                                 GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+                                                 &dest,
+                                                 mdsize,
+                                                 GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   GNUNET_CONTAINER_meta_data_destroy (mmeta);
   if (mdsize == -1)
-    {
-      GNUNET_break (0);
-      GNUNET_free (sb);
-      cont (cont_cls,
-            NULL,
-            _("Internal error."));
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_free (sb);
+    cont (cont_cls, NULL, _("Internal error."));
+    return;
+  }
   size = sizeof (struct SBlock) + mdsize + slen + nidlen;
   sb_enc = GNUNET_malloc (size);
   GNUNET_CRYPTO_hash (identifier, idlen, &key);
@@ -903,76 +849,64 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
   sks_uri->type = sks;
   GNUNET_CRYPTO_rsa_key_get_public (namespace->key, &sb_enc->subspace);
   GNUNET_CRYPTO_hash (&sb_enc->subspace,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &sks_uri->data.sks.namespace);
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &sks_uri->data.sks.namespace);
   sks_uri->data.sks.identifier = GNUNET_strdup (identifier);
-  GNUNET_CRYPTO_hash_xor (&id, 
-                          &sks_uri->data.sks.namespace, 
-                          &sb_enc->identifier);
+  GNUNET_CRYPTO_hash_xor (&id,
+                          &sks_uri->data.sks.namespace, &sb_enc->identifier);
   GNUNET_CRYPTO_hash_to_aes_key (&key, &sk, &iv);
   GNUNET_CRYPTO_aes_encrypt (&sb[1],
-                             size - sizeof (struct SBlock),
-                             &sk,
-                             &iv,
-                             &sb_enc[1]);
+                             size - sizeof (struct SBlock),
+                             &sk, &iv, &sb_enc[1]);
   sb_enc->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_SBLOCK);
-  sb_enc->purpose.size = htonl(slen + mdsize + nidlen
-                               + sizeof(struct SBlock)
-                               - sizeof(struct GNUNET_CRYPTO_RsaSignature));
-  GNUNET_assert (GNUNET_OK == 
-                 GNUNET_CRYPTO_rsa_sign (namespace->key,
-                                         &sb_enc->purpose,
-                                         &sb_enc->signature));
-  psc = GNUNET_malloc (sizeof(struct PublishSksContext));
+  sb_enc->purpose.size = htonl (slen + mdsize + nidlen
+                                + sizeof (struct SBlock)
+                                - sizeof (struct GNUNET_CRYPTO_RsaSignature));
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_rsa_sign (namespace->key,
+                                         &sb_enc->purpose, &sb_enc->signature));
+  psc = GNUNET_malloc (sizeof (struct PublishSksContext));
   psc->uri = sks_uri;
   psc->cont = cont;
   psc->namespace = namespace;
   namespace->rc++;
   psc->cont_cls = cont_cls;
   if (0 != (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
-    {
-      GNUNET_free (sb_enc);
-      GNUNET_free (sb);
-      sb_put_cont (psc,
-                   GNUNET_OK,
-                   NULL);
-      return;
-    }
+  {
+    GNUNET_free (sb_enc);
+    GNUNET_free (sb);
+    sb_put_cont (psc, GNUNET_OK, NULL);
+    return;
+  }
   psc->dsh = GNUNET_DATASTORE_connect (h->cfg);
   if (NULL == psc->dsh)
-    {
-      GNUNET_free (sb_enc);
-      GNUNET_free (sb);
-      sb_put_cont (psc,
-                   GNUNET_NO,
-                   _("Failed to connect to datastore."));
-      return;
-    }
-  GNUNET_CRYPTO_hash_xor (&sks_uri->data.sks.namespace,
-                          &id,
-                          &query);  
+  {
+    GNUNET_free (sb_enc);
+    GNUNET_free (sb);
+    sb_put_cont (psc, GNUNET_NO, _("Failed to connect to datastore."));
+    return;
+  }
+  GNUNET_CRYPTO_hash_xor (&sks_uri->data.sks.namespace, &id, &query);
   if (NULL != update)
-    {
-      psc->nsn = GNUNET_malloc (sizeof (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->nsn = GNUNET_malloc (sizeof (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);
+  }
   GNUNET_DATASTORE_put (psc->dsh,
-                        0,
-                        &sb_enc->identifier,
-                        size,
-                        sb_enc,
-                        GNUNET_BLOCK_TYPE_FS_SBLOCK, 
-                        bo->content_priority,
-                        bo->anonymity_level,
-                        bo->replication_level,
-                        bo->expiration_time,
-                        -2, 1,
-                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                        &sb_put_cont,
-                        psc);
+                        0,
+                        &sb_enc->identifier,
+                        size,
+                        sb_enc,
+                        GNUNET_BLOCK_TYPE_FS_SBLOCK,
+                        bo->content_priority,
+                        bo->anonymity_level,
+                        bo->replication_level,
+                        bo->expiration_time,
+                        -2, 1,
+                        GNUNET_CONSTANTS_SERVICE_TIMEOUT, &sb_put_cont, psc);
   GNUNET_free (sb);
   GNUNET_free (sb_enc);
 }
@@ -981,7 +915,7 @@ GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
 /**
  * Closure for 'process_update_node'.
  */
-struct ProcessUpdateClosure 
+struct ProcessUpdateClosure
 {
   /**
    * Function to call for each node.
@@ -1006,18 +940,12 @@ struct ProcessUpdateClosure
  *         GNUNET_NO if not.
  */
 static int
-process_update_node (void *cls,
-                     const GNUNET_HashCode * key,
-                     void *value)
+process_update_node (void *cls, const 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;
 }
 
@@ -1025,7 +953,7 @@ process_update_node (void *cls,
 /**
  * Closure for 'find_trees'.
  */
-struct FindTreeClosure 
+struct FindTreeClosure
 {
   /**
    * Namespace we are operating on.
@@ -1075,42 +1003,36 @@ struct FindTreeClosure
  *         GNUNET_NO if not.
  */
 static int
-find_trees (void *cls,
-           const GNUNET_HashCode * key,
-           void *value)
+find_trees (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct FindTreeClosure *fc = cls;
   struct NamespaceUpdateNode *nsn = value;
   GNUNET_HashCode hc;
 
   if (nsn->nug == fc->nug)
-    {
-      if (nsn->tree_id == UINT_MAX) 
-        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 (fc->id == UINT_MAX)
-        fc->id = nsn->tree_id; /* take over ID */
-    }
+  {
+    if (nsn->tree_id == UINT_MAX)
+      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 (fc->id == UINT_MAX)
+      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->namespace->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->namespace->update_map,
+                                                &hc, &find_trees, fc);
+  }
   return GNUNET_YES;
 }
 
@@ -1139,9 +1061,9 @@ find_trees (void *cls,
  */
 void
 GNUNET_FS_namespace_list_updateable (struct GNUNET_FS_Namespace *namespace,
-                                     const char *next_id,
-                                     GNUNET_FS_IdentifierProcessor ip, 
-                                     void *ip_cls)
+                                     const char *next_id,
+                                     GNUNET_FS_IdentifierProcessor ip,
+                                     void *ip_cls)
 {
   unsigned int i;
   unsigned int nug;
@@ -1153,154 +1075,125 @@ GNUNET_FS_namespace_list_updateable (struct GNUNET_FS_Namespace *namespace,
   if (namespace->update_nodes == NULL)
     read_update_information_graph (namespace);
   if (namespace->update_nodes == NULL)
-    {
+  {
 #if DEBUG_NAMESPACE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No updateable nodes found for ID `%s'\n",
-                  next_id);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No updateable nodes found for ID `%s'\n", next_id);
 #endif
-      return; /* no nodes */
-    }
+    return;                     /* no nodes */
+  }
   if (namespace->update_map == NULL)
+  {
+    /* need to construct */
+    namespace->update_map =
+        GNUNET_CONTAINER_multihashmap_create (2 +
+                                              3 * namespace->update_node_count /
+                                              4);
+    for (i = 0; i < namespace->update_node_count; i++)
     {
-      /* need to construct */
-      namespace->update_map = GNUNET_CONTAINER_multihashmap_create (2 + 3 * namespace->update_node_count / 4);
-      for (i=0;i<namespace->update_node_count;i++)
-        {
-          nsn = namespace->update_nodes[i];
-          GNUNET_CRYPTO_hash (nsn->id,
-                              strlen (nsn->id),
-                              &hc);
-          GNUNET_CONTAINER_multihashmap_put (namespace->update_map,
-                                             &hc,
-                                             nsn,
-                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);                         
-        }
+      nsn = namespace->update_nodes[i];
+      GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
+      GNUNET_CONTAINER_multihashmap_put (namespace->update_map,
+                                         &hc,
+                                         nsn,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
     }
+  }
   if (next_id != NULL)
-    {
-      GNUNET_CRYPTO_hash (next_id,
-                          strlen (next_id),
-                          &hc);
-      pc.ip = ip;
-      pc.ip_cls = ip_cls;
-      GNUNET_CONTAINER_multihashmap_get_multiple (namespace->update_map,
-                                                  &hc,
-                                                  &process_update_node,
-                                                  &pc);
-      return;
-    }
+  {
+    GNUNET_CRYPTO_hash (next_id, strlen (next_id), &hc);
+    pc.ip = ip;
+    pc.ip_cls = ip_cls;
+    GNUNET_CONTAINER_multihashmap_get_multiple (namespace->update_map,
+                                                &hc, &process_update_node, &pc);
+    return;
+  }
 #if DEBUG_NAMESPACE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Calculating TREEs to find roots of update trees\n");
+              "Calculating TREEs to find roots of update trees\n");
 #endif
   /* Find heads of TREEs in update graph */
   nug = ++namespace->nug_gen;
   fc.tree_array = NULL;
   fc.tree_array_size = 0;
 
-  for (i=0;i<namespace->update_node_count;i++)
+  for (i = 0; i < namespace->update_node_count; i++)
+  {
+    nsn = namespace->update_nodes[i];
+    if (nsn->nug == nug)
     {
-      nsn = namespace->update_nodes[i];
-      if (nsn->nug == nug)
-        {
 #if DEBUG_NAMESPACE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "TREE of node `%s' is %u\n",
-                      nsn->id,
-                      nsn->nug);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "TREE of node `%s' is %u\n", nsn->id, nsn->nug);
 #endif
-          continue; /* already placed in TREE */
-        }
-      GNUNET_CRYPTO_hash (nsn->update,
-                          strlen (nsn->update),
-                          &hc);
-      nsn->nug = nug;
-      fc.id = UINT_MAX;
+      continue;                 /* already placed in TREE */
+    }
+    GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
+    nsn->nug = nug;
+    fc.id = UINT_MAX;
+    fc.nug = nug;
+    fc.namespace = namespace;
+    GNUNET_CONTAINER_multihashmap_get_multiple (namespace->update_map,
+                                                &hc, &find_trees, &fc);
+    if (fc.id == UINT_MAX)
+    {
+      /* start new TREE */
+      for (fc.id = 0; fc.id < fc.tree_array_size; fc.id++)
+      {
+        if (fc.tree_array[fc.id] == NULL)
+        {
+          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;
+      }
+#if DEBUG_NAMESPACE
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Starting new TREE %u with node `%s'\n",
+                  nsn->tree_id, nsn->id);
+#endif
+      /* 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.namespace = namespace;
       GNUNET_CONTAINER_multihashmap_get_multiple (namespace->update_map,
-                                                  &hc,
-                                                  &find_trees,
-                                                  &fc);
-      if (fc.id == UINT_MAX)
-        {
-          /* start new TREE */
-          for (fc.id=0;fc.id<fc.tree_array_size;fc.id++)
-            {
-              if (fc.tree_array[fc.id] == NULL)
-                {
-                  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;
-            }
-#if DEBUG_NAMESPACE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Starting new TREE %u with node `%s'\n",
-                      nsn->tree_id,
-                      nsn->id);
-#endif
-          /* 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.namespace = namespace;
-          GNUNET_CONTAINER_multihashmap_get_multiple (namespace->update_map,
-                                                      &hc,
-                                                      &find_trees,
-                                                      &fc);
-        }
-      else
-        {
-          /* make head of TREE "id" */
-          fc.tree_array[fc.id] = nsn;
-          nsn->tree_id = fc.id;
-        }
+                                                  &hc, &find_trees, &fc);
+    }
+    else
+    {
+      /* make head of TREE "id" */
+      fc.tree_array[fc.id] = nsn;
+      nsn->tree_id = fc.id;
+    }
 #if DEBUG_NAMESPACE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "TREE of node `%s' is %u\n",
-                  nsn->id,
-                  fc.id);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "TREE of node `%s' is %u\n", nsn->id, fc.id);
 #endif
-    }
-  for (i=0;i<fc.tree_array_size;i++)
+  }
+  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)
-        {
 #if DEBUG_NAMESPACE
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Root of TREE %u is node `%s'\n",
-                      i,
-                      nsn->id);
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Root of TREE %u is node `%s'\n", i, nsn->id);
 #endif
 
-          ip (ip_cls,
-              nsn->id,
-              nsn->uri,
-              nsn->md,
-              nsn->update);
-        }
+      ip (ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
     }
-  GNUNET_array_grow (fc.tree_array,
-                     fc.tree_array_size,
-                     0);
+  }
+  GNUNET_array_grow (fc.tree_array, fc.tree_array_size, 0);
 #if DEBUG_NAMESPACE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Done processing TREEs\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done processing TREEs\n");
 #endif
 }
 
 
 /* end of fs_namespace.c */
-
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index a52856c1f..87161501b 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -49,28 +49,25 @@
  */
 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)
+                                struct GNUNET_FS_PublishContext *pc,
+                                const struct GNUNET_FS_FileInformation *p,
+                                uint64_t offset)
 {
   pi->value.publish.pc = pc;
   pi->value.publish.fi = p;
-  pi->value.publish.cctx
-    = p->client_info;
-  pi->value.publish.pctx
-    = (NULL == p->dir) ? NULL : p->dir->client_info;
+  pi->value.publish.cctx = p->client_info;
+  pi->value.publish.pctx = (NULL == p->dir) ? NULL : p->dir->client_info;
   pi->value.publish.filename = p->filename;
-  pi->value.publish.size 
-    = (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);
+  pi->value.publish.size
+      = (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);
   pi->value.publish.completed = offset;
-  pi->value.publish.duration = GNUNET_TIME_absolute_get_duration (p->start_time);
+  pi->value.publish.duration =
+      GNUNET_TIME_absolute_get_duration (p->start_time);
   pi->value.publish.anonymity = p->bo.anonymity_level;
-  return pc->h->upcb (pc->h->upcb_cls,
-                      pi);
+  return pc->h->upcb (pc->h->upcb_cls, pi);
 }
 
 
@@ -81,39 +78,37 @@ GNUNET_FS_publish_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  * @param tc scheduler context
  */
 static void
-publish_cleanup (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+publish_cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Cleaning up publish context (done!)\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up publish context (done!)\n");
 #endif
   if (pc->fhc != NULL)
-    {
-      GNUNET_CRYPTO_hash_file_cancel (pc->fhc);
-      pc->fhc = NULL;
-    }
+  {
+    GNUNET_CRYPTO_hash_file_cancel (pc->fhc);
+    pc->fhc = NULL;
+  }
   GNUNET_FS_file_information_destroy (pc->fi, NULL, NULL);
   if (pc->namespace != NULL)
-    {
-      GNUNET_FS_namespace_delete (pc->namespace, GNUNET_NO);
-      pc->namespace = NULL;
-    }
-  GNUNET_free_non_null (pc->nid);  
+  {
+    GNUNET_FS_namespace_delete (pc->namespace, GNUNET_NO);
+    pc->namespace = NULL;
+  }
+  GNUNET_free_non_null (pc->nid);
   GNUNET_free_non_null (pc->nuid);
   GNUNET_free_non_null (pc->serialization);
   if (pc->dsh != NULL)
-    {
-      GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO);
-      pc->dsh = NULL;
-    }
+  {
+    GNUNET_DATASTORE_disconnect (pc->dsh, GNUNET_NO);
+    pc->dsh = NULL;
+  }
   if (pc->client != NULL)
-    {
-      GNUNET_CLIENT_disconnect (pc->client, GNUNET_NO);
-      pc->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (pc->client, GNUNET_NO);
+    pc->client = NULL;
+  }
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
   GNUNET_free (pc);
 }
@@ -128,48 +123,42 @@ publish_cleanup (void *cls,
  * @param msg error message (or NULL)
  */
 static void
-ds_put_cont (void *cls,
-             int success,
-             const char *msg)
+ds_put_cont (void *cls, int success, const char *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
   pc->qre = NULL;
   if (GNUNET_SYSERR == pc->in_network_wait)
-    {
-      /* we were aborted in the meantime, finish shutdown! */
-      GNUNET_SCHEDULER_add_continuation (&publish_cleanup,
-                                         pc,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      return;
-    }
+  {
+    /* we were aborted in the meantime, finish shutdown! */
+    GNUNET_SCHEDULER_add_continuation (&publish_cleanup,
+                                       pc, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    return;
+  }
   GNUNET_assert (GNUNET_YES == pc->in_network_wait);
   pc->in_network_wait = GNUNET_NO;
   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 ((pc->fi_pos->is_directory == GNUNET_NO) &&
+        (pc->fi_pos->filename != NULL) &&
+        (pc->fi_pos->data.file.do_index == GNUNET_YES))
     {
-      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 ( (pc->fi_pos->is_directory == GNUNET_NO) &&
-           (pc->fi_pos->filename != NULL) &&
-           (pc->fi_pos->data.file.do_index == GNUNET_YES) )
-        {
-          /* run unindex to clean up */
-          GNUNET_FS_unindex_start (pc->h,
-                                   pc->fi_pos->filename,
-                                   NULL);
-        }          
+      /* run unindex to clean up */
+      GNUNET_FS_unindex_start (pc->h, pc->fi_pos->filename, NULL);
     }
+  }
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
-  pc->upload_task 
-    = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                          &GNUNET_FS_publish_main_,
-                                          pc);
+  pc->upload_task
+      =
+      GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                          &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -181,17 +170,19 @@ ds_put_cont (void *cls,
  * @param p the completed upload
  * @param pc context of the publication
  */
-static void 
+static void
 signal_publish_completion (struct GNUNET_FS_FileInformation *p,
-                           struct GNUNET_FS_PublishContext *pc)
+                           struct GNUNET_FS_PublishContext *pc)
 {
   struct GNUNET_FS_ProgressInfo pi;
-  
+
   pi.status = GNUNET_FS_STATUS_PUBLISH_COMPLETED;
   pi.value.publish.eta = GNUNET_TIME_UNIT_ZERO;
   pi.value.publish.specifics.completed.chk_uri = p->chk_uri;
   p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p,
-                                                   GNUNET_ntohll (p->chk_uri->data.chk.file_length));
+                                                   GNUNET_ntohll (p->
+                                                                  chk_uri->data.
+                                                                  chk.file_length));
 }
 
 
@@ -204,28 +195,24 @@ signal_publish_completion (struct GNUNET_FS_FileInformation *p,
  * @param pc context of the publication
  * @param emsg error message
  */
-static void 
+static void
 signal_publish_error (struct GNUNET_FS_FileInformation *p,
-                      struct GNUNET_FS_PublishContext *pc,
-                      const char *emsg)
+                      struct GNUNET_FS_PublishContext *pc, const char *emsg)
 {
   struct GNUNET_FS_ProgressInfo pi;
-  
+
   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;
+  pi.value.publish.specifics.error.message = emsg;
   p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
-  if ( (p->is_directory == GNUNET_NO) &&
-       (p->filename != NULL) &&
-       (p->data.file.do_index == GNUNET_YES) )
-    {
-      /* run unindex to clean up */
-      GNUNET_FS_unindex_start (pc->h,
-                               p->filename,
-                               NULL);
-    }      
-  
+  if ((p->is_directory == GNUNET_NO) &&
+      (p->filename != NULL) && (p->data.file.do_index == GNUNET_YES))
+  {
+    /* run unindex to clean up */
+    GNUNET_FS_unindex_start (pc->h, p->filename, NULL);
+  }
+
 }
 
 
@@ -237,16 +224,13 @@ 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,
-                        const char *msg)
+finish_release_reserve (void *cls, int success, const char *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   pc->qre = NULL;
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Releasing reserve done!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Releasing reserve done!\n");
 #endif
   signal_publish_completion (pc->fi, pc);
   pc->all_done = GNUNET_YES;
@@ -264,34 +248,30 @@ finish_release_reserve (void *cls,
  */
 static void
 publish_sblocks_cont (void *cls,
-                      const struct GNUNET_FS_Uri *uri,
-                      const char *emsg)
+                      const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
+
   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;
+  }
   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,
-                                                  GNUNET_TIME_UNIT_FOREVER_REL,
-                                                  &finish_release_reserve,
-                                                  pc);
-    }
+  if ((pc->dsh != NULL) && (pc->rid != 0))
+  {
+    pc->qre = GNUNET_DATASTORE_release_reserve (pc->dsh,
+                                                pc->rid,
+                                                UINT_MAX,
+                                                UINT_MAX,
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                &finish_release_reserve, pc);
+  }
   else
-    {
-      finish_release_reserve (pc, GNUNET_OK, NULL);
-    }
+  {
+    finish_release_reserve (pc, GNUNET_OK, NULL);
+  }
 }
 
 
@@ -306,15 +286,12 @@ publish_sblock (struct GNUNET_FS_PublishContext *pc)
 {
   if (NULL != pc->namespace)
     GNUNET_FS_publish_sks (pc->h,
-                           pc->namespace,
-                           pc->nid,
-                           pc->nuid,
-                           pc->fi->meta,
-                           pc->fi->chk_uri,
-                           &pc->fi->bo,
-                           pc->options,
-                           &publish_sblocks_cont,
-                           pc);
+                           pc->namespace,
+                           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);
 }
@@ -331,35 +308,33 @@ publish_sblock (struct GNUNET_FS_PublishContext *pc)
  */
 static void
 publish_kblocks_cont (void *cls,
-                      const struct GNUNET_FS_Uri *uri,
-                      const char *emsg)
+                      const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p = pc->fi_pos;
 
   if (NULL != emsg)
-    {
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Error uploading KSK blocks: %s\n",
-                  emsg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Error uploading KSK blocks: %s\n", emsg);
 #endif
-      signal_publish_error (p, pc, emsg);
-      GNUNET_FS_file_information_sync_ (p);
-      GNUNET_FS_publish_sync_ (pc);
-      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
-      pc->upload_task 
-        = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                              &GNUNET_FS_publish_main_,
-                                              pc);
-      return;
-    }
+    signal_publish_error (p, pc, emsg);
+    GNUNET_FS_file_information_sync_ (p);
+    GNUNET_FS_publish_sync_ (pc);
+    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
+    pc->upload_task
+        =
+        GNUNET_SCHEDULER_add_with_priority
+        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc);
+    return;
+  }
 #if DEBUG_PUBLISH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "KSK blocks published, moving on to next file\n");
+              "KSK blocks published, moving on to next file\n");
 #endif
   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;
@@ -367,10 +342,10 @@ publish_kblocks_cont (void *cls,
     pc->fi_pos = p->dir;
   GNUNET_FS_publish_sync_ (pc);
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
-  pc->upload_task 
-    = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                          &GNUNET_FS_publish_main_,
-                                          pc);
+  pc->upload_task
+      =
+      GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                          &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -388,11 +363,7 @@ 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;
@@ -401,29 +372,22 @@ block_reader (void *cls,
 
   p = pc->fi_pos;
   if (p->is_directory)
-    {
-      pt_size = GNUNET_MIN(max,
-                           p->data.dir.dir_size - offset);
-      dd = p->data.dir.dir_data;
-      memcpy (buf,
-              &dd[offset],
-              pt_size);
-    }
+  {
+    pt_size = GNUNET_MIN (max, p->data.dir.dir_size - offset);
+    dd = p->data.dir.dir_data;
+    memcpy (buf, &dd[offset], pt_size);
+  }
   else
-    {
-      pt_size = GNUNET_MIN(max,
-                           p->data.file.file_size - offset);
-      if (pt_size == 0)
-        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;
-    }
+  {
+    pt_size = GNUNET_MIN (max, p->data.file.file_size - offset);
+    if (pt_size == 0)
+      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;
+  }
   return pt_size;
 }
 
@@ -436,9 +400,8 @@ block_reader (void *cls,
  * @param cls our publishing context
  * @param tc scheduler's task context (not used)
  */
-static void 
-encode_cont (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+encode_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -447,30 +410,23 @@ encode_cont (void *cls,
   uint64_t flen;
 
   p = pc->fi_pos;
-  GNUNET_FS_tree_encoder_finish (p->te,
-                                 &p->chk_uri,
-                                 &emsg);
+  GNUNET_FS_tree_encoder_finish (p->te, &p->chk_uri, &emsg);
   p->te = NULL;
   if (NULL != emsg)
-    {
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Error during tree walk: %s\n",
-                  emsg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error during tree walk: %s\n", emsg);
 #endif
-      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_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);
+  }
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Finished with tree encoder\n");
-#endif  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Finished with tree encoder\n");
+#endif
   /* final progress event */
   flen = GNUNET_FS_uri_chk_get_file_size (p->chk_uri);
   pi.status = GNUNET_FS_STATUS_PUBLISH_PROGRESS;
@@ -482,10 +438,10 @@ encode_cont (void *cls,
 
   /* continue with main */
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
-  pc->upload_task 
-    = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                          &GNUNET_FS_publish_main_,
-                                          pc);
+  pc->upload_task
+      =
+      GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                          &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -503,14 +459,12 @@ encode_cont (void *cls,
  * @param block the (encrypted) block
  * @param block_size size of block (in bytes)
  */
-static void 
+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)
+            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;
@@ -518,73 +472,68 @@ block_proc (void *cls,
 
   p = pc->fi_pos;
   if (NULL == pc->dsh)
-    {
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Waiting for datastore connection\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Waiting for datastore connection\n");
 #endif
-      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
-      pc->upload_task
-        = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                              &GNUNET_FS_publish_main_,
-                                              pc);
-      return;
-    }
-  
+    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
+    pc->upload_task
+        =
+        GNUNET_SCHEDULER_add_with_priority
+        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, pc);
+    return;
+  }
+
   GNUNET_assert (GNUNET_NO == pc->in_network_wait);
   pc->in_network_wait = GNUNET_YES;
-  if ( (! p->is_directory) &&
-       (GNUNET_YES == p->data.file.do_index) &&
-       (type == GNUNET_BLOCK_TYPE_FS_DBLOCK) )
-    {
+  if ((!p->is_directory) &&
+      (GNUNET_YES == p->data.file.do_index) &&
+      (type == GNUNET_BLOCK_TYPE_FS_DBLOCK))
+  {
 #if DEBUG_PUBLISH
-      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,
-                  sizeof (struct OnDemandBlock));
+    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, sizeof (struct OnDemandBlock));
 #endif
-      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) ? 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,
-                                      GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                      &ds_put_cont,
-                                      pc);        
-      return;
-    }
+    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) ? 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,
+                                    GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                    &ds_put_cont, pc);
+    return;
+  }
 #if DEBUG_PUBLISH
   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);
+              "Publishing block `%s' for offset %llu with size %u\n",
+              GNUNET_h2s (&chk->query),
+              (unsigned long long) offset, (unsigned int) block_size);
 #endif
   GNUNET_assert (pc->qre == NULL);
   pc->qre = GNUNET_DATASTORE_put (pc->dsh,
-                                  (p->is_directory) ? 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,
-                                  GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                  &ds_put_cont,
-                                  pc);
+                                  (p->is_directory) ? 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,
+                                  GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                  &ds_put_cont, pc);
 }
 
 
@@ -598,13 +547,11 @@ block_proc (void *cls,
  * @param pt_size size of pt_block
  * @param depth depth of the block in the tree, 0 for DBLOCK
  */
-static void 
+static void
 progress_proc (void *cls,
-               uint64_t offset,
-               const void *pt_block,
-               size_t pt_size,
-               unsigned int depth)
-{                      
+               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;
   struct GNUNET_FS_ProgressInfo pi;
@@ -627,7 +574,7 @@ progress_proc (void *cls,
  * @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;
@@ -639,77 +586,69 @@ publish_content (struct GNUNET_FS_PublishContext *pc)
   p = pc->fi_pos;
   GNUNET_assert (p != NULL);
   if (NULL == p->te)
+  {
+    if (p->is_directory)
     {
-      if (p->is_directory)
-        {
 #if DEBUG_PUBLISH
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Creating directory\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating directory\n");
 #endif
-          db = GNUNET_FS_directory_builder_create (p->meta);
-          dirpos = p->data.dir.entries;
-          while (NULL != dirpos)
-            {
-              if (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;
-                        } 
-                    }
-                }
-              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 = (p->is_directory) 
-        ? p->data.dir.dir_size 
-        : p->data.file.file_size;
+      db = GNUNET_FS_directory_builder_create (p->meta);
+      dirpos = p->data.dir.entries;
+      while (NULL != dirpos)
+      {
+        if (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;
+            }
+          }
+        }
+        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 = (p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size;
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Creating tree encoder\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Creating tree encoder\n");
 #endif
-      p->te = GNUNET_FS_tree_encoder_create (pc->h,
-                                             size,
-                                             pc,
-                                             &block_reader,
-                                             &block_proc,
-                                             &progress_proc,
-                                             &encode_cont);
-
-    }
+    p->te = GNUNET_FS_tree_encoder_create (pc->h,
+                                           size,
+                                           pc,
+                                           &block_reader,
+                                           &block_proc,
+                                           &progress_proc, &encode_cont);
+
+  }
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Processing next block from tree\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Processing next block from tree\n");
 #endif
   GNUNET_FS_tree_encoder_next (p->te);
 }
@@ -723,8 +662,7 @@ publish_content (struct GNUNET_FS_PublishContext *pc)
  * @param msg the response we got
  */
 static void
-process_index_start_response (void *cls,
-                              const struct GNUNET_MessageHeader *msg)
+process_index_start_response (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -735,32 +673,33 @@ process_index_start_response (void *cls,
   pc->client = NULL;
   p = pc->fi_pos;
   if (msg == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Can not index file `%s': %s.  Will try to insert instead.\n"),
-                  p->filename,
-                  _("timeout on index-start request to `fs' service"));
-      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,
+                _("timeout on index-start request to `fs' service"));
+    p->data.file.do_index = GNUNET_NO;
+    GNUNET_FS_file_information_sync_ (p);
+    publish_content (pc);
+    return;
+  }
   if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK)
-    {
-      msize = ntohs (msg->size);
-      emsg = (const char *) &msg[1];
-      if ( (msize <= sizeof (struct GNUNET_MessageHeader)) ||
-           (emsg[msize - sizeof(struct GNUNET_MessageHeader) - 1] != '\0') )
-        emsg = gettext_noop ("unknown error");
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Can not index file `%s': %s.  Will try to insert instead.\n"),
-                  p->filename,
-                  gettext (emsg));
-      p->data.file.do_index = GNUNET_NO;
-      GNUNET_FS_file_information_sync_ (p);
-      publish_content (pc);
-      return;
-    }
+  {
+    msize = ntohs (msg->size);
+    emsg = (const char *) &msg[1];
+    if ((msize <= sizeof (struct GNUNET_MessageHeader)) ||
+        (emsg[msize - sizeof (struct GNUNET_MessageHeader) - 1] != '\0'))
+      emsg = gettext_noop ("unknown error");
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("Can not index file `%s': %s.  Will try to insert instead.\n"),
+                p->filename, gettext (emsg));
+    p->data.file.do_index = GNUNET_NO;
+    GNUNET_FS_file_information_sync_ (p);
+    publish_content (pc);
+    return;
+  }
   p->data.file.index_start_confirmed = GNUNET_YES;
   /* success! continue with indexing */
   GNUNET_FS_file_information_sync_ (p);
@@ -775,10 +714,8 @@ process_index_start_response (void *cls,
  * @param cls closure, our publishing context
  * @param res resulting hash, NULL on error
  */
-static void 
-hash_for_index_cb (void *cls,
-                   const GNUNET_HashCode *
-                   res)
+static void
+hash_for_index_cb (void *cls, const GNUNET_HashCode * res)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_FileInformation *p;
@@ -791,106 +728,97 @@ 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;
-    }
+  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;
+  }
   if (GNUNET_YES == p->data.file.index_start_confirmed)
-    {
-      publish_content (pc);
-      return;
-    }
+  {
+    publish_content (pc);
+    return;
+  }
   fn = GNUNET_STRINGS_filename_expand (p->filename);
   GNUNET_assert (fn != NULL);
   slen = strlen (fn) + 1;
-  if (slen >= GNUNET_SERVER_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;
-    }
+  if (slen >=
+      GNUNET_SERVER_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;
+  }
 #if DEBUG_PUBLISH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Hash of indexed file `%s' is `%s'\n",
-              p->filename,
-              GNUNET_h2s (res));
+              "Hash of indexed file `%s' is `%s'\n",
+              p->filename, GNUNET_h2s (res));
 #endif
   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;
-    }
-  client = GNUNET_CLIENT_connect ("fs",
-                                  pc->h->cfg);
+  {
+    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;
+  }
+  client = GNUNET_CLIENT_connect ("fs", pc->h->cfg);
   if (NULL == client)
-    {
-      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);
-    }
-  ism = GNUNET_malloc (sizeof(struct IndexStartMessage) +
-                       slen);
-  ism->header.size = htons(sizeof(struct IndexStartMessage) +
-                           slen);
-  ism->header.type = htons(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);
-    }
+  {
+    p->data.file.file_id = *res;
+    p->data.file.have_hash = GNUNET_YES;
+    GNUNET_FS_file_information_sync_ (p);
+  }
+  ism = GNUNET_malloc (sizeof (struct IndexStartMessage) + slen);
+  ism->header.size = htons (sizeof (struct IndexStartMessage) + slen);
+  ism->header.type = htons (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);
+  }
 #if DEBUG_PUBLISH
   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);
+  }
 #endif
   ism->file_id = *res;
-  memcpy (&ism[1],
-          fn,
-          slen);
+  memcpy (&ism[1], fn, slen);
   GNUNET_free (fn);
   pc->client = client;
   GNUNET_break (GNUNET_YES ==
-                GNUNET_CLIENT_transmit_and_get_response (client,
-                                                         &ism->header,
-                                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                                         GNUNET_YES,
-                                                         &process_index_start_response,
-                                                         pc));
+                GNUNET_CLIENT_transmit_and_get_response (client,
+                                                         &ism->header,
+                                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                                         GNUNET_YES,
+                                                         &process_index_start_response,
+                                                         pc));
   GNUNET_free (ism);
 }
 
@@ -903,7 +831,7 @@ hash_for_index_cb (void *cls,
  */
 void
 GNUNET_FS_publish_main_ (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
@@ -911,135 +839,119 @@ GNUNET_FS_publish_main_ (void *cls,
   struct GNUNET_FS_Uri *loc;
   char *fn;
 
-  pc->upload_task = GNUNET_SCHEDULER_NO_TASK;  
+  pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
   p = pc->fi_pos;
   if (NULL == p)
-    {
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Publishing complete, now publishing SKS and KSK blocks.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Publishing complete, now publishing SKS and KSK blocks.\n");
 #endif
-      /* upload of entire hierarchy complete,
-         publish namespace entries */
-      GNUNET_FS_publish_sync_ (pc);
-      publish_sblock (pc);
-      return;
-    }
+    /* upload of entire hierarchy complete,
+     * publish namespace entries */
+    GNUNET_FS_publish_sync_ (pc);
+    publish_sblock (pc);
+    return;
+  }
   /* find starting position */
-  while ( (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);
-    }
+  while ((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);
+  }
   /* abort on error */
   if (NULL != p->emsg)
-    {
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Error uploading: %s\n",
-                  p->emsg);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Error uploading: %s\n", p->emsg);
 #endif
-      /* 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;
+    /* 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)
-    {
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "File upload complete, now publishing KSK blocks.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "File upload complete, now publishing KSK blocks.\n");
 #endif
-      if (0 == p->bo.anonymity_level)
-        {
-          /* zero anonymity, box CHK URI in LOC URI */
-          loc = GNUNET_FS_uri_loc_create (p->chk_uri,
-                                          pc->h->cfg,
-                                          p->bo.expiration_time);
-          GNUNET_FS_uri_destroy (p->chk_uri);
-          p->chk_uri = loc;
-        }
-      GNUNET_FS_publish_sync_ (pc);
-      /* upload of "p" complete, publish KBlocks! */
-      if (p->keywords != NULL)
-        {
-          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);
-        }
-      return;
+    if (0 == p->bo.anonymity_level)
+    {
+      /* zero anonymity, box CHK URI in LOC URI */
+      loc = GNUNET_FS_uri_loc_create (p->chk_uri,
+                                      pc->h->cfg, p->bo.expiration_time);
+      GNUNET_FS_uri_destroy (p->chk_uri);
+      p->chk_uri = loc;
     }
-  if ( (!p->is_directory) &&
-       (p->data.file.do_index) )
+    GNUNET_FS_publish_sync_ (pc);
+    /* upload of "p" complete, publish KBlocks! */
+    if (p->keywords != NULL)
     {
-      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);
-        }
+      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);
+    }
+    return;
+  }
+  if ((!p->is_directory) && (p->data.file.do_index))
+  {
+    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);
+    }
+    return;
+  }
   publish_content (pc);
 }
 
@@ -1059,14 +971,13 @@ 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;
@@ -1074,38 +985,39 @@ fip_signal_start(void *cls,
   uint64_t left;
 
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Starting publish operation\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting publish operation\n");
 #endif
   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_SERVER_MAX_MESSAGE_SIZE * kc;
-    }  
+  {
+    kc = GNUNET_FS_uri_ksk_get_keyword_count (*uri);
+    pc->reserve_entries += kc;
+    pc->reserve_space += GNUNET_SERVER_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);
@@ -1128,39 +1040,37 @@ fip_signal_start(void *cls,
  * @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;
+  struct GNUNET_FS_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t off;
 
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Suspending publish operation\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Suspending publish operation\n");
 #endif
   GNUNET_free_non_null (fi->serialization);
-  fi->serialization = NULL;    
+  fi->serialization = NULL;
   off = (fi->chk_uri == NULL) ? 0 : length;
   pi.status = GNUNET_FS_STATUS_PUBLISH_SUSPEND;
   GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, fi, off));
   *client_info = NULL;
   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;
   return GNUNET_OK;
 }
@@ -1178,13 +1088,11 @@ GNUNET_FS_publish_signal_suspend_ (void *cls)
   struct GNUNET_FS_PublishContext *pc = cls;
 
   if (GNUNET_SCHEDULER_NO_TASK != pc->upload_task)
-    {
-      GNUNET_SCHEDULER_cancel (pc->upload_task);
-      pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  GNUNET_FS_file_information_inspect (pc->fi,
-                                      &fip_signal_suspend,
-                                      pc);
+  {
+    GNUNET_SCHEDULER_cancel (pc->upload_task);
+    pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_suspend, pc);
   GNUNET_FS_end_top (pc->h, pc->top);
   pc->top = NULL;
   publish_cleanup (pc, NULL);
@@ -1200,35 +1108,27 @@ GNUNET_FS_publish_signal_suspend_ (void *cls)
  * @param msg error message on error, otherwise NULL
  */
 static void
-finish_reserve (void *cls,
-                int success,
-                const char *msg)
+finish_reserve (void *cls, int success, const char *msg)
 {
   struct GNUNET_FS_PublishContext *pc = cls;
 
   pc->qre = NULL;
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Reservation complete (%d)!\n",
-              success);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reservation complete (%d)!\n", success);
 #endif
-  if ( (msg != NULL) ||
-       (success <= 0) )
-    {
-      GNUNET_asprintf (&pc->fi->emsg, 
-                       _("Insufficient space for publishing: %s"),
-                       msg);
-      signal_publish_error (pc->fi,
-                            pc,
-                            pc->fi->emsg);
-      return;
-    }
+  if ((msg != NULL) || (success <= 0))
+  {
+    GNUNET_asprintf (&pc->fi->emsg,
+                     _("Insufficient space for publishing: %s"), msg);
+    signal_publish_error (pc->fi, pc, pc->fi->emsg);
+    return;
+  }
   pc->rid = success;
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pc->upload_task);
-  pc->upload_task 
-    = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                          &GNUNET_FS_publish_main_,
-                                          pc);
+  pc->upload_task
+      =
+      GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
+                                          &GNUNET_FS_publish_main_, pc);
 }
 
 
@@ -1247,26 +1147,26 @@ finish_reserve (void *cls,
  */
 struct GNUNET_FS_PublishContext *
 GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h,
-                         struct GNUNET_FS_FileInformation *fi,
-                         struct GNUNET_FS_Namespace *namespace,
-                         const char *nid,
-                         const char *nuid,
-                         enum GNUNET_FS_PublishOptions options)
+                         struct GNUNET_FS_FileInformation *fi,
+                         struct GNUNET_FS_Namespace *namespace,
+                         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);
   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;
-    }
+  {
+    dsh = NULL;
+  }
   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_PublishContext));
   ret->dsh = dsh;
   ret->h = h;
@@ -1274,44 +1174,40 @@ GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h,
   ret->namespace = namespace;
   ret->options = options;
   if (namespace != NULL)
-    {
-      namespace->rc++;
-      GNUNET_assert (NULL != nid);
-      ret->nid = GNUNET_strdup (nid);
-      if (NULL != nuid)
-        ret->nuid = GNUNET_strdup (nuid);
-    }
+  {
+    namespace->rc++;
+    GNUNET_assert (NULL != nid);
+    ret->nid = GNUNET_strdup (nid);
+    if (NULL != nuid)
+      ret->nuid = GNUNET_strdup (nuid);
+  }
   /* 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);
   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,
-                                           UINT_MAX,
-                                           UINT_MAX,
-                                           GNUNET_TIME_UNIT_FOREVER_REL,
-                                           &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, UINT_MAX, UINT_MAX,
+                                  GNUNET_TIME_UNIT_FOREVER_REL, &finish_reserve,
+                                  ret);
+  }
   else
-    {
-      GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == ret->upload_task);
-      ret->upload_task 
-        = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_BACKGROUND,
-                                              &GNUNET_FS_publish_main_,
-                                              ret);
-    }
+  {
+    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == ret->upload_task);
+    ret->upload_task
+        =
+        GNUNET_SCHEDULER_add_with_priority
+        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, ret);
+  }
   return ret;
 }
 
@@ -1331,27 +1227,26 @@ 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_PublishContext *pc = cls;
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t off;
 
-  if (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;
-    }
+  if (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));
@@ -1368,43 +1263,41 @@ fip_signal_stop(void *cls,
  *
  * @param pc context for the upload to stop
  */
-void 
+void
 GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc)
 {
 #if DEBUG_PUBLISH
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publish stop called\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Publish stop called\n");
 #endif
   GNUNET_FS_end_top (pc->h, pc->top);
   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;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != pc->upload_task)
-    {
-      GNUNET_SCHEDULER_cancel (pc->upload_task);
-      pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  if (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;
-    }
-  GNUNET_FS_file_information_inspect (pc->fi,
-                                      &fip_signal_stop,
-                                      pc);
+  {
+    GNUNET_SCHEDULER_cancel (pc->upload_task);
+    pc->upload_task = GNUNET_SCHEDULER_NO_TASK;
+  }
+  if (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;
+  }
+  GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_stop, pc);
   if (GNUNET_YES == pc->in_network_wait)
-    {
-      pc->in_network_wait = GNUNET_SYSERR;
-      return;
-    }
+  {
+    pc->in_network_wait = GNUNET_SYSERR;
+    return;
+  }
   publish_cleanup (pc, NULL);
 }
 
@@ -1435,7 +1328,7 @@ struct PublishKskContext
   /**
    * Buffer of the same size as "kb" for
    * the encrypted version.
-   */ 
+   */
   struct KBlock *cpy;
 
   /**
@@ -1456,7 +1349,7 @@ struct PublishKskContext
 
   /**
    * Closure for cont.
-   */ 
+   */
   void *cont_cls;
 
   /**
@@ -1491,8 +1384,7 @@ struct PublishKskContext
  * @param tc unused
  */
 static void
-publish_ksk_cont (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc);
+publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -1504,36 +1396,30 @@ publish_ksk_cont (void *cls,
  * @param msg error message (or NULL)
  */
 static void
-kb_put_cont (void *cls,
-             int success,
-             const char *msg)
+kb_put_cont (void *cls, int success, const char *msg)
 {
   struct PublishKskContext *pkc = cls;
 
   pkc->qre = NULL;
   if (GNUNET_OK != success)
-    {
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "KB PUT operation complete\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "KB PUT operation complete\n");
 #endif
-      if (NULL != pkc->dsh)
-        {
-          GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
-          pkc->dsh = NULL;
-        }
-      GNUNET_free (pkc->cpy);
-      GNUNET_free (pkc->kb);
-      pkc->cont (pkc->cont_cls,
-                 NULL,
-                 msg);
-      GNUNET_FS_uri_destroy (pkc->ksk_uri);
-      GNUNET_free (pkc);
-      return;
+    if (NULL != pkc->dsh)
+    {
+      GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+      pkc->dsh = NULL;
     }
+    GNUNET_free (pkc->cpy);
+    GNUNET_free (pkc->kb);
+    pkc->cont (pkc->cont_cls, NULL, msg);
+    GNUNET_FS_uri_destroy (pkc->ksk_uri);
+    GNUNET_free (pkc);
+    return;
+  }
   GNUNET_SCHEDULER_add_continuation (&publish_ksk_cont,
-                                     pkc,
-                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+                                     pkc, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 }
 
 
@@ -1545,8 +1431,7 @@ kb_put_cont (void *cls,
  * @param tc unused
  */
 static void
-publish_ksk_cont (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+publish_ksk_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PublishKskContext *pkc = cls;
   const char *keyword;
@@ -1557,69 +1442,60 @@ publish_ksk_cont (void *cls,
   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
 
 
-  if ( (pkc->i == pkc->ksk_uri->data.ksk.keywordCount) ||
-       (NULL == pkc->dsh) )
-    {
+  if ((pkc->i == pkc->ksk_uri->data.ksk.keywordCount) || (NULL == pkc->dsh))
+  {
 #if DEBUG_PUBLISH
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "KSK PUT operation complete\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "KSK PUT operation complete\n");
 #endif
-      if (NULL != pkc->dsh)
-        {
-          GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
-          pkc->dsh = NULL;
-        }
-      GNUNET_free (pkc->cpy);
-      GNUNET_free (pkc->kb);
-      pkc->cont (pkc->cont_cls,
-                 pkc->ksk_uri,
-                 NULL);
-      GNUNET_FS_uri_destroy (pkc->ksk_uri);
-      GNUNET_free (pkc);
-      return;
+    if (NULL != pkc->dsh)
+    {
+      GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+      pkc->dsh = NULL;
     }
+    GNUNET_free (pkc->cpy);
+    GNUNET_free (pkc->kb);
+    pkc->cont (pkc->cont_cls, pkc->ksk_uri, NULL);
+    GNUNET_FS_uri_destroy (pkc->ksk_uri);
+    GNUNET_free (pkc);
+    return;
+  }
   keyword = pkc->ksk_uri->data.ksk.keywords[pkc->i++];
 #if DEBUG_PUBLISH
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing under keyword `%s'\n",
-              keyword);
+              "Publishing under keyword `%s'\n", keyword);
 #endif
   /* first character of keyword indicates if it is
-     mandatory or not -- ignore for hashing */
+   * mandatory or not -- ignore for hashing */
   GNUNET_CRYPTO_hash (&keyword[1], strlen (&keyword[1]), &key);
   GNUNET_CRYPTO_hash_to_aes_key (&key, &skey, &iv);
   GNUNET_CRYPTO_aes_encrypt (&pkc->kb[1],
-                             pkc->slen + pkc->mdsize,
-                             &skey,
-                             &iv,
-                             &pkc->cpy[1]);
+                             pkc->slen + pkc->mdsize, &skey, &iv, &pkc->cpy[1]);
   pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&key);
   GNUNET_assert (NULL != pk);
   GNUNET_CRYPTO_rsa_key_get_public (pk, &pkc->cpy->keyspace);
   GNUNET_CRYPTO_hash (&pkc->cpy->keyspace,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &query);
-  GNUNET_assert (GNUNET_OK == 
-                 GNUNET_CRYPTO_rsa_sign (pk,
-                                         &pkc->cpy->purpose,
-                                         &pkc->cpy->signature));
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &query);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CRYPTO_rsa_sign (pk,
+                                         &pkc->cpy->purpose,
+                                         &pkc->cpy->signature));
   GNUNET_CRYPTO_rsa_key_free (pk);
   pkc->qre = GNUNET_DATASTORE_put (pkc->dsh,
-                                   0,
-                                   &query,
-                                   pkc->mdsize + 
-                                   sizeof (struct KBlock) + 
-                                   pkc->slen,
-                                   pkc->cpy,
-                                   GNUNET_BLOCK_TYPE_FS_KBLOCK, 
-                                   pkc->bo.content_priority,
-                                   pkc->bo.anonymity_level,
-                                   pkc->bo.replication_level,
-                                   pkc->bo.expiration_time,
-                                   -2, 1,
-                                   GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                   &kb_put_cont,
-                                   pkc);
+                                   0,
+                                   &query,
+                                   pkc->mdsize +
+                                   sizeof (struct KBlock) +
+                                   pkc->slen,
+                                   pkc->cpy,
+                                   GNUNET_BLOCK_TYPE_FS_KBLOCK,
+                                   pkc->bo.content_priority,
+                                   pkc->bo.anonymity_level,
+                                   pkc->bo.replication_level,
+                                   pkc->bo.expiration_time,
+                                   -2, 1,
+                                   GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                   &kb_put_cont, pkc);
 }
 
 
@@ -1637,13 +1513,12 @@ publish_ksk_cont (void *cls,
  */
 void
 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)
+                       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 PublishKskContext *pkc;
   char *uris;
@@ -1658,15 +1533,15 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
   pkc->cont = cont;
   pkc->cont_cls = cont_cls;
   if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
+  {
+    pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
+    if (pkc->dsh == NULL)
     {
-      pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
-      if (pkc->dsh == NULL)
-        {
-          cont (cont_cls, NULL, _("Could not connect to datastore."));
-          GNUNET_free (pkc);
-          return;
-        }
+      cont (cont_cls, NULL, _("Could not connect to datastore."));
+      GNUNET_free (pkc);
+      return;
     }
+  }
   if (meta == NULL)
     pkc->mdsize = 0;
   else
@@ -1676,10 +1551,10 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
   pkc->slen = strlen (uris) + 1;
   size = pkc->mdsize + sizeof (struct KBlock) + pkc->slen;
   if (size > MAX_KBLOCK_SIZE)
-    {
-      size = MAX_KBLOCK_SIZE;
-      pkc->mdsize = size - sizeof (struct KBlock) - pkc->slen;
-    }
+  {
+    size = MAX_KBLOCK_SIZE;
+    pkc->mdsize = size - sizeof (struct KBlock) - pkc->slen;
+  }
   pkc->kb = GNUNET_malloc (size);
   kbe = (char *) &pkc->kb[1];
   memcpy (kbe, uris, pkc->slen);
@@ -1687,34 +1562,33 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
   sptr = &kbe[pkc->slen];
   if (meta != NULL)
     pkc->mdsize = GNUNET_CONTAINER_meta_data_serialize (meta,
-                                                        &sptr,
-                                                        pkc->mdsize,
-                                                        GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
+                                                        &sptr,
+                                                        pkc->mdsize,
+                                                        GNUNET_CONTAINER_META_DATA_SERIALIZE_PART);
   if (pkc->mdsize == -1)
+  {
+    GNUNET_break (0);
+    GNUNET_free (pkc->kb);
+    if (pkc->dsh != NULL)
     {
-      GNUNET_break (0);
-      GNUNET_free (pkc->kb);
-      if (pkc->dsh != NULL)
-        {
-          GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
-          pkc->dsh = NULL;
-        }
-      cont (cont_cls, NULL, _("Internal error."));
-      GNUNET_free (pkc);
-      return;
+      GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
+      pkc->dsh = NULL;
     }
+    cont (cont_cls, NULL, _("Internal error."));
+    GNUNET_free (pkc);
+    return;
+  }
   size = sizeof (struct KBlock) + pkc->slen + pkc->mdsize;
 
   pkc->cpy = GNUNET_malloc (size);
-  pkc->cpy->purpose.size = htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) + 
-                                  sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
-                                  pkc->mdsize + 
-                                  pkc->slen);
-  pkc->cpy->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK);
+  pkc->cpy->purpose.size =
+      htonl (sizeof (struct GNUNET_CRYPTO_RsaSignaturePurpose) +
+             sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
+             pkc->mdsize + pkc->slen);
+  pkc->cpy->purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK);
   pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri);
   GNUNET_SCHEDULER_add_continuation (&publish_ksk_cont,
-                                     pkc,
-                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+                                     pkc, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 }
 
 
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index 526e6513b..60b7a1cc8 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -42,20 +42,19 @@
  */
 void *
 GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
-                               struct GNUNET_FS_SearchContext *sc)
-{  
+                               struct GNUNET_FS_SearchContext *sc)
+{
   void *ret;
+
   pi->value.search.sc = sc;
-  pi->value.search.cctx
-    = sc->client_info;
+  pi->value.search.cctx = sc->client_info;
   pi->value.search.pctx
-    = (sc->psearch_result == NULL) ? NULL : sc->psearch_result->client_info;
-  pi->value.search.query 
-    = sc->uri;
-  pi->value.search.duration = GNUNET_TIME_absolute_get_duration (sc->start_time);
+      = (sc->psearch_result == NULL) ? NULL : sc->psearch_result->client_info;
+  pi->value.search.query = sc->uri;
+  pi->value.search.duration =
+      GNUNET_TIME_absolute_get_duration (sc->start_time);
   pi->value.search.anonymity = sc->anonymity;
-  ret =  sc->h->upcb (sc->h->upcb_cls,
-                      pi);
+  ret = sc->h->upcb (sc->h->upcb_cls, pi);
   return ret;
 }
 
@@ -72,15 +71,12 @@ GNUNET_FS_search_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  *         GNUNET_OK otherwise
  */
 static int
-test_result_present (void *cls,
-                     const GNUNET_HashCode * key,
-                     void *value)
+test_result_present (void *cls, const 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;
 }
@@ -94,9 +90,9 @@ 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;
 
   pi.status = GNUNET_FS_STATUS_SEARCH_RESULT;
@@ -116,9 +112,9 @@ 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;
 
   pi.status = GNUNET_FS_STATUS_SEARCH_UPDATE;
@@ -126,11 +122,10 @@ notify_client_chk_update (struct GNUNET_FS_SearchContext *sc,
   pi.value.search.specifics.update.meta = sr->meta;
   pi.value.search.specifics.update.uri = sr->uri;
   pi.value.search.specifics.update.availability_rank
-    = 2*sr->availability_success - sr->availability_trials;
-  pi.value.search.specifics.update.availability_certainty 
-    = sr->availability_trials;
-  pi.value.search.specifics.update.applicability_rank 
-    = sr->optional_support;
+      = 2 * sr->availability_success - sr->availability_trials;
+  pi.value.search.specifics.update.availability_certainty
+      = sr->availability_trials;
+  pi.value.search.specifics.update.applicability_rank = sr->optional_support;
   sr->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
 }
 
@@ -138,7 +133,7 @@ notify_client_chk_update (struct GNUNET_FS_SearchContext *sc,
 /**
  * Context for "get_result_present".
  */
-struct GetResultContext 
+struct GetResultContext
 {
   /**
    * The URI we're looking for.
@@ -164,15 +159,12 @@ struct GetResultContext
  * @return GNUNET_OK
  */
 static int
-get_result_present (void *cls,
-                     const GNUNET_HashCode * key,
-                     void *value)
+get_result_present (void *cls, const 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;
 }
@@ -192,7 +184,8 @@ signal_probe_result (struct GNUNET_FS_SearchResult *sr)
   pi.value.search.specifics.update.meta = sr->meta;
   pi.value.search.specifics.update.uri = sr->uri;
   pi.value.search.specifics.update.availability_rank = sr->availability_success;
-  pi.value.search.specifics.update.availability_certainty = sr->availability_trials;
+  pi.value.search.specifics.update.availability_certainty =
+      sr->availability_trials;
   pi.value.search.specifics.update.applicability_rank = sr->optional_support;
   sr->sc->client_info = GNUNET_FS_search_make_status_ (&pi, sr->sc);
   GNUNET_FS_search_start_probe_ (sr);
@@ -206,10 +199,10 @@ signal_probe_result (struct GNUNET_FS_SearchResult *sr)
  * @param tc scheduler context
  */
 static void
-probe_failure_handler (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+probe_failure_handler (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_SearchResult *sr = cls;
+
   sr->availability_trials++;
   GNUNET_FS_search_result_sync_ (sr);
   signal_probe_result (sr);
@@ -223,10 +216,10 @@ probe_failure_handler (void *cls,
  * @param tc scheduler context
  */
 static void
-probe_success_handler (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+probe_success_handler (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_SearchResult *sr = cls;
+
   sr->availability_trials++;
   sr->availability_success++;
   GNUNET_FS_search_result_sync_ (sr);
@@ -249,79 +242,79 @@ probe_success_handler (void *cls,
  *         will be passed to future callbacks in the respective
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
-void*
+void *
 GNUNET_FS_search_probe_progress_ (void *cls,
-                                  const struct GNUNET_FS_ProgressInfo *info)
+                                  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 (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_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 (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
-          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
-        }     
-      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
-                                                            &probe_failure_handler,
-                                                            sr);
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
-          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
-        }     
-      sr->probe_cancel_task = GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
-                                                            &probe_success_handler,
-                                                            sr);
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
-      if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
-          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
-        }     
-      sr = NULL;
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-      GNUNET_assert (sr->probe_cancel_task == GNUNET_SCHEDULER_NO_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 (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
-          sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
-      sr->remaining_probe_time = GNUNET_TIME_relative_subtract (sr->remaining_probe_time,
-                                                                dur);
-      GNUNET_FS_search_result_sync_ (sr);
-      break;
-    default:
-      GNUNET_break (0);
-      return NULL;
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    sr->probe_cancel_task =
+        GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
+                                      &probe_failure_handler, sr);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    sr->probe_cancel_task =
+        GNUNET_SCHEDULER_add_delayed (sr->remaining_probe_time,
+                                      &probe_success_handler, sr);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+    if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
     }
+    sr = NULL;
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+    GNUNET_assert (sr->probe_cancel_task == GNUNET_SCHEDULER_NO_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 (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+      sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    dur = GNUNET_TIME_absolute_get_duration (sr->probe_active_time);
+    sr->remaining_probe_time =
+        GNUNET_TIME_relative_subtract (sr->remaining_probe_time, dur);
+    GNUNET_FS_search_result_sync_ (sr);
+    break;
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
   return sr;
 }
 
@@ -336,7 +329,7 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
 {
   uint64_t off;
   uint64_t len;
-  
+
   if (sr->probe_ctx != NULL)
     return;
   if (sr->download != NULL)
@@ -348,7 +341,7 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
   len = GNUNET_FS_uri_chk_get_file_size (sr->uri);
   if (len == 0)
     return;
-  if ( (len <= DBLOCK_SIZE) && (sr->availability_success > 0))
+  if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
     return;
   off = len / DBLOCK_SIZE;
   if (off > 0)
@@ -358,17 +351,14 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
     len = len - off;
   else
     len = DBLOCK_SIZE;
-  sr->remaining_probe_time = GNUNET_TIME_relative_multiply (sr->sc->h->avg_block_latency,
-                                                            2 * (1 + sr->availability_trials));
-  sr->probe_ctx = GNUNET_FS_download_start (sr->sc->h,
-                                            sr->uri,
-                                            sr->meta,
-                                            NULL, NULL,
-                                            off, len, 
-                                            sr->sc->anonymity,
-                                            GNUNET_FS_DOWNLOAD_NO_TEMPORARIES |
-                                            GNUNET_FS_DOWNLOAD_IS_PROBE,
-                                            sr, NULL);    
+  sr->remaining_probe_time =
+      GNUNET_TIME_relative_multiply (sr->sc->h->avg_block_latency,
+                                     2 * (1 + sr->availability_trials));
+  sr->probe_ctx =
+      GNUNET_FS_download_start (sr->sc->h, sr->uri, sr->meta, NULL, NULL, off,
+                                len, sr->sc->anonymity,
+                                GNUNET_FS_DOWNLOAD_NO_TEMPORARIES |
+                                GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
 }
 
 
@@ -383,10 +373,10 @@ GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
  *        under the "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)
 {
   GNUNET_HashCode key;
   struct GNUNET_FS_SearchResult *sr;
@@ -397,36 +387,34 @@ process_ksk_result (struct GNUNET_FS_SearchContext *sc,
   GNUNET_FS_uri_to_key (uri, &key);
   if (GNUNET_SYSERR ==
       GNUNET_CONTAINER_multihashmap_get_multiple (ent->results,
-                                                  &key,
-                                                  &test_result_present,
-                                                  (void*) uri))
-    return; /* duplicate result */
+                                                  &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);
+                                              &key, &get_result_present, &grc);
   sr = grc.sr;
   is_new = (NULL == sr) || (sr->mandatory_missing > 0);
   if (NULL == sr)
-    {
-      sr = GNUNET_malloc (sizeof (struct GNUNET_FS_SearchResult));
-      sr->sc = sc;
-      sr->uri = GNUNET_FS_uri_dup (uri);
-      sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
-      sr->mandatory_missing = sc->mandatory_count;
-      sr->key = key;
-      GNUNET_CONTAINER_multihashmap_put (sc->master_result_map,
-                                         &key,
-                                         sr,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
-    }
+  {
+    sr = GNUNET_malloc (sizeof (struct GNUNET_FS_SearchResult));
+    sr->sc = sc;
+    sr->uri = GNUNET_FS_uri_dup (uri);
+    sr->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
+    sr->mandatory_missing = sc->mandatory_count;
+    sr->key = key;
+    GNUNET_CONTAINER_multihashmap_put (sc->master_result_map,
+                                       &key,
+                                       sr,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+  }
   else
-    {
-      GNUNET_CONTAINER_meta_data_merge (sr->meta, meta);
-    }
+  {
+    GNUNET_CONTAINER_meta_data_merge (sr->meta, meta);
+  }
   /* check if mandatory satisfied */
   if (ent->mandatory)
     sr->mandatory_missing--;
@@ -455,13 +443,15 @@ process_ksk_result (struct GNUNET_FS_SearchContext *sc,
  * @param psearch parent search result (for namespace update searches)
  * @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);
+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);
 
 
 /**
@@ -474,10 +464,10 @@ 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;
   GNUNET_HashCode key;
@@ -486,39 +476,33 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc,
   /* check if new */
   GNUNET_FS_uri_to_key (uri, &key);
   GNUNET_CRYPTO_hash_xor (&uri->data.chk.chk.key,
-                          &uri->data.chk.chk.query,
-                          &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))
-    return; /* duplicate result */
+                                                  &key,
+                                                  &test_result_present,
+                                                  (void *) uri))
+    return;                     /* duplicate result */
   sr = GNUNET_malloc (sizeof (struct GNUNET_FS_SearchResult));
   sr->sc = sc;
   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);
+                                     &key,
+                                     sr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   GNUNET_FS_search_result_sync_ (sr);
   GNUNET_FS_search_start_probe_ (sr);
   /* notify client */
   notify_client_chk_result (sc, sr);
   /* search for updates */
   if (strlen (id_update) == 0)
-    return; /* no updates */
+    return;                     /* no updates */
   uu.type = sks;
   uu.data.sks.namespace = sc->uri->data.sks.namespace;
   uu.data.sks.identifier = GNUNET_strdup (id_update);
-  (void) search_start (sc->h,
-                       &uu,
-                       sc->anonymity,
-                       sc->options,
-                       NULL,
-                       sr);
+  (void) search_start (sc->h, &uu, sc->anonymity, sc->options, NULL, sr);
   GNUNET_free (uu.data.sks.identifier);
 }
 
@@ -532,8 +516,7 @@ process_sks_result (struct GNUNET_FS_SearchContext *sc,
  */
 static void
 process_kblock (struct GNUNET_FS_SearchContext *sc,
-                const struct KBlock *kb,
-                size_t size)
+                const struct KBlock *kb, size_t size)
 {
   unsigned int i;
   size_t j;
@@ -545,59 +528,54 @@ process_kblock (struct GNUNET_FS_SearchContext *sc,
   struct GNUNET_CONTAINER_MetaData *meta;
   struct GNUNET_FS_Uri *uri;
   char *emsg;
-  
+
   GNUNET_CRYPTO_hash (&kb->keyspace,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &q);
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &q);
   /* find key */
-  for (i=0;i<sc->uri->data.ksk.keywordCount;i++)
-    if (0 == memcmp (&q,
-                     &sc->requests[i].query,
-                     sizeof (GNUNET_HashCode)))
+  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
+    if (0 == memcmp (&q, &sc->requests[i].query, sizeof (GNUNET_HashCode)))
       break;
   if (i == sc->uri->data.ksk.keywordCount)
-    {
-      /* oops, does not match any of our keywords!? */
-      GNUNET_break (0);
-      return;
-    }
+  {
+    /* oops, does not match any of our keywords!? */
+    GNUNET_break (0);
+    return;
+  }
   /* decrypt */
   GNUNET_CRYPTO_hash_to_aes_key (&sc->requests[i].key, &skey, &iv);
   if (-1 == GNUNET_CRYPTO_aes_decrypt (&kb[1],
-                                       size - sizeof (struct KBlock),
-                                       &skey,
-                                       &iv,
-                                       pt))
-    {
-      GNUNET_break (0);
-      return;
-    }
+                                       size - sizeof (struct KBlock),
+                                       &skey, &iv, pt))
+  {
+    GNUNET_break (0);
+    return;
+  }
   /* parse */
   eos = memchr (pt, 0, sizeof (pt));
   if (NULL == eos)
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   j = eos - pt + 1;
   if (sizeof (pt) == j)
     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 (meta == NULL)
-    {
-      GNUNET_break_op (0);       /* kblock malformed */
-      return;
-    }
+  {
+    GNUNET_break_op (0);        /* kblock malformed */
+    return;
+  }
   uri = GNUNET_FS_uri_parse (pt, &emsg);
   if (uri == NULL)
-    {
-      GNUNET_break_op (0);       /* kblock malformed */
-      GNUNET_free_non_null (emsg);
-      GNUNET_CONTAINER_meta_data_destroy (meta);
-      return;
-    }
+  {
+    GNUNET_break_op (0);        /* kblock malformed */
+    GNUNET_free_non_null (emsg);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    return;
+  }
   /* process */
   process_ksk_result (sc, &sc->requests[i], uri, meta);
 
@@ -616,8 +594,7 @@ process_kblock (struct GNUNET_FS_SearchContext *sc,
  */
 static void
 process_nblock (struct GNUNET_FS_SearchContext *sc,
-                const struct NBlock *nb,
-                size_t size)
+                const struct NBlock *nb, size_t size)
 {
   unsigned int i;
   size_t j;
@@ -629,70 +606,61 @@ process_nblock (struct GNUNET_FS_SearchContext *sc,
   struct GNUNET_CONTAINER_MetaData *meta;
   struct GNUNET_FS_Uri *uri;
   char *uris;
-  
+
   GNUNET_CRYPTO_hash (&nb->keyspace,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &q);
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &q);
   /* find key */
-  for (i=0;i<sc->uri->data.ksk.keywordCount;i++)
-    if (0 == memcmp (&q,
-                     &sc->requests[i].query,
-                     sizeof (GNUNET_HashCode)))
+  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
+    if (0 == memcmp (&q, &sc->requests[i].query, sizeof (GNUNET_HashCode)))
       break;
   if (i == sc->uri->data.ksk.keywordCount)
-    {
-      /* oops, does not match any of our keywords!? */
-      GNUNET_break (0);
-      return;
-    }
+  {
+    /* oops, does not match any of our keywords!? */
+    GNUNET_break (0);
+    return;
+  }
   /* decrypt */
   GNUNET_CRYPTO_hash_to_aes_key (&sc->requests[i].key, &skey, &iv);
   if (-1 == GNUNET_CRYPTO_aes_decrypt (&nb[1],
-                                       size - sizeof (struct NBlock),
-                                       &skey,
-                                       &iv,
-                                       pt))
-    {
-      GNUNET_break (0);
-      return;
-    }
+                                       size - sizeof (struct NBlock),
+                                       &skey, &iv, pt))
+  {
+    GNUNET_break (0);
+    return;
+  }
   /* parse */
   eos = memchr (pt, 0, sizeof (pt));
   if (NULL == eos)
-    {
-      GNUNET_break_op (0);
-      return;
-    }
+  {
+    GNUNET_break_op (0);
+    return;
+  }
   j = eos - pt + 1;
   if (sizeof (pt) == j)
     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 (meta == NULL)
-    {
-      GNUNET_break_op (0);       /* nblock malformed */
-      return;
-    }
+  {
+    GNUNET_break_op (0);        /* nblock malformed */
+    return;
+  }
 
   uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   uri->type = sks;
   uri->data.sks.identifier = GNUNET_strdup (pt);
   GNUNET_CRYPTO_hash (&nb->subspace,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &uri->data.sks.namespace);
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &uri->data.sks.namespace);
   uris = GNUNET_FS_uri_to_string (uri);
   GNUNET_CONTAINER_meta_data_insert (meta,
-                                     "<gnunet>",
-                                     EXTRACTOR_METATYPE_URI,
-                                     EXTRACTOR_METAFORMAT_UTF8,
-                                     "text/plain",
-                                     uris,
-                                     strlen (uris)+1);
+                                     "<gnunet>",
+                                     EXTRACTOR_METATYPE_URI,
+                                     EXTRACTOR_METAFORMAT_UTF8,
+                                     "text/plain", uris, strlen (uris) + 1);
   GNUNET_free (uris);
-  GNUNET_PSEUDONYM_add (sc->h->cfg,
-                        &uri->data.sks.namespace,
-                        meta);
+  GNUNET_PSEUDONYM_add (sc->h->cfg, &uri->data.sks.namespace, meta);
   /* process */
   process_ksk_result (sc, &sc->requests[i], uri, meta);
 
@@ -711,8 +679,7 @@ process_nblock (struct GNUNET_FS_SearchContext *sc,
  */
 static void
 process_sblock (struct GNUNET_FS_SearchContext *sc,
-                const struct SBlock *sb,
-                size_t size)
+                const struct SBlock *sb, size_t size)
 {
   size_t len = size - sizeof (struct SBlock);
   char pt[len];
@@ -729,48 +696,36 @@ process_sblock (struct GNUNET_FS_SearchContext *sc,
 
   /* decrypt */
   identifier = sc->uri->data.sks.identifier;
-  GNUNET_CRYPTO_hash (identifier, 
-                      strlen (identifier), 
-                      &key);
+  GNUNET_CRYPTO_hash (identifier, strlen (identifier), &key);
   GNUNET_CRYPTO_hash_to_aes_key (&key, &skey, &iv);
-  if (-1 == GNUNET_CRYPTO_aes_decrypt (&sb[1],
-                                       len,
-                                       &skey,
-                                       &iv,
-                                       pt))
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if (-1 == GNUNET_CRYPTO_aes_decrypt (&sb[1], len, &skey, &iv, pt))
+  {
+    GNUNET_break (0);
+    return;
+  }
   /* parse */
-  off = GNUNET_STRINGS_buffer_tokenize (pt,
-                                        len, 
-                                        2, 
-                                        &id, 
-                                        &uris);
+  off = GNUNET_STRINGS_buffer_tokenize (pt, len, 2, &id, &uris);
   if (off == 0)
-    {
-      GNUNET_break_op (0);     /* sblock malformed */
-      return;
-    }
-  meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[off], 
-                                                 len - off);
+  {
+    GNUNET_break_op (0);        /* sblock malformed */
+    return;
+  }
+  meta = GNUNET_CONTAINER_meta_data_deserialize (&pt[off], len - off);
   if (meta == NULL)
-    {
-      GNUNET_break_op (0);     /* sblock malformed */
-      return;
-    }
+  {
+    GNUNET_break_op (0);        /* sblock malformed */
+    return;
+  }
   uri = GNUNET_FS_uri_parse (uris, &emsg);
   if (uri == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Failed to parse URI `%s': %s\n",
-                  uris, emsg);
-      GNUNET_break_op (0);     /* sblock malformed */
-      GNUNET_free_non_null (emsg);
-      GNUNET_CONTAINER_meta_data_destroy (meta);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to parse URI `%s': %s\n", uris, emsg);
+    GNUNET_break_op (0);        /* sblock malformed */
+    GNUNET_free_non_null (emsg);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    return;
+  }
   /* process */
   process_sks_result (sc, id, uri, meta);
   /* clean up */
@@ -790,76 +745,74 @@ process_sblock (struct GNUNET_FS_SearchContext *sc,
  */
 static void
 process_result (struct GNUNET_FS_SearchContext *sc,
-                enum GNUNET_BLOCK_Type type,
-                struct GNUNET_TIME_Absolute expiration,
-                const void *data,
-                size_t size)
+                enum GNUNET_BLOCK_Type type,
+                struct GNUNET_TIME_Absolute expiration,
+                const void *data, size_t size)
 {
   if (GNUNET_TIME_absolute_get_duration (expiration).rel_value > 0)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Result received has already expired.\n");
-      return; /* result expired */
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Result received has already expired.\n");
+    return;                     /* result expired */
+  }
   switch (type)
+  {
+  case GNUNET_BLOCK_TYPE_FS_KBLOCK:
+    if (!GNUNET_FS_uri_test_ksk (sc->uri))
     {
-    case GNUNET_BLOCK_TYPE_FS_KBLOCK:
-      if (! GNUNET_FS_uri_test_ksk (sc->uri))
-        {
-          GNUNET_break (0);
-          return;
-        }
-      if (sizeof (struct KBlock) > size)
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      process_kblock (sc, data, size);
-      break;
-    case GNUNET_BLOCK_TYPE_FS_SBLOCK:
-      if (! GNUNET_FS_uri_test_sks (sc->uri))
-        {
-          GNUNET_break (0);
-          return;
-        }
-      if (sizeof (struct SBlock) > size)
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      process_sblock (sc, data, size);
-      break;
-    case GNUNET_BLOCK_TYPE_FS_NBLOCK:
-      if (! GNUNET_FS_uri_test_ksk (sc->uri))
-        {
-          GNUNET_break (0);
-          return;
-        }
-      if (sizeof (struct NBlock) > size)
-        {
-          GNUNET_break_op (0);
-          return;
-        }
-      process_nblock (sc, data, size);
-      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:
+      return;
+    }
+    if (sizeof (struct KBlock) > size)
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    process_kblock (sc, data, size);
+    break;
+  case GNUNET_BLOCK_TYPE_FS_SBLOCK:
+    if (!GNUNET_FS_uri_test_sks (sc->uri))
+    {
       GNUNET_break (0);
-      break;
-    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
+      return;
+    }
+    if (sizeof (struct SBlock) > size)
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    process_sblock (sc, data, size);
+    break;
+  case GNUNET_BLOCK_TYPE_FS_NBLOCK:
+    if (!GNUNET_FS_uri_test_ksk (sc->uri))
+    {
       GNUNET_break (0);
-      break;
-    default:
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Got result with unknown block type `%d', ignoring"),
-                  type);
-      break;
+      return;
     }
+    if (sizeof (struct NBlock) > size)
+    {
+      GNUNET_break_op (0);
+      return;
+    }
+    process_nblock (sc, data, size);
+    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;
+  }
 }
 
 
@@ -870,8 +823,7 @@ process_result (struct GNUNET_FS_SearchContext *sc,
  *
  * @param sc the search to reconnec
  */
-static void 
-try_reconnect (struct GNUNET_FS_SearchContext *sc);
+static void try_reconnect (struct GNUNET_FS_SearchContext *sc);
 
 
 /**
@@ -881,36 +833,31 @@ try_reconnect (struct GNUNET_FS_SearchContext *sc);
  * @param cls closure
  * @param msg message received, NULL on timeout or fatal error
  */
-static void 
-receive_results (void *cls,
-                 const struct GNUNET_MessageHeader * msg)
+static void
+receive_results (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   const struct PutMessage *cm;
   uint16_t msize;
 
-  if ( (NULL == msg) ||
-       (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_PUT) ||
-       (ntohs (msg->size) <= sizeof (struct PutMessage)) )
-    {
-      try_reconnect (sc);
-      return;
-    }
+  if ((NULL == msg) ||
+      (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_PUT) ||
+      (ntohs (msg->size) <= sizeof (struct PutMessage)))
+  {
+    try_reconnect (sc);
+    return;
+  }
   msize = ntohs (msg->size);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Receiving %u bytes of result from fs service\n",
-              msize);
-  cm = (const struct PutMessage*) msg;
-  process_result (sc, 
-                  ntohl (cm->type),
-                  GNUNET_TIME_absolute_ntoh (cm->expiration),
-                  &cm[1],
-                  msize - sizeof (struct PutMessage));
+              "Receiving %u bytes of result from fs service\n", msize);
+  cm = (const struct PutMessage *) msg;
+  process_result (sc,
+                  ntohl (cm->type),
+                  GNUNET_TIME_absolute_ntoh (cm->expiration),
+                  &cm[1], msize - sizeof (struct PutMessage));
   /* continue receiving */
   GNUNET_CLIENT_receive (sc->client,
-                         &receive_results,
-                         sc,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &receive_results, sc, GNUNET_TIME_UNIT_FOREVER_REL);
 }
 
 
@@ -967,22 +914,19 @@ struct MessageBuilderContext
  * @return GNUNET_OK to continue iterating
  */
 static int
-build_result_set (void *cls,
-                  const GNUNET_HashCode *key,
-                  void *value)
+build_result_set (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct MessageBuilderContext *mbc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
-  
-  if ( (mbc->uri != NULL) &&
-       (GNUNET_YES != GNUNET_FS_uri_test_equal (mbc->uri,
-                                                sr->uri)) )
+
+  if ((mbc->uri != NULL) &&
+      (GNUNET_YES != GNUNET_FS_uri_test_equal (mbc->uri, sr->uri)))
     return GNUNET_OK;
   if (mbc->skip_cnt > 0)
-    {
-      mbc->skip_cnt--;
-      return GNUNET_OK;
-    }
+  {
+    mbc->skip_cnt--;
+    return GNUNET_OK;
+  }
   if (mbc->put_cnt == 0)
     return GNUNET_SYSERR;
   mbc->sc->search_request_map_offset++;
@@ -1002,16 +946,13 @@ build_result_set (void *cls,
  * @return GNUNET_OK to continue iterating
  */
 static int
-find_result_set (void *cls,
-                  const GNUNET_HashCode *key,
-                  void *value)
+find_result_set (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct MessageBuilderContext *mbc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
-  
-  if ( (mbc->uri != NULL) &&
-       (GNUNET_YES != GNUNET_FS_uri_test_equal (mbc->uri,
-                                                sr->uri)) )
+
+  if ((mbc->uri != NULL) &&
+      (GNUNET_YES != GNUNET_FS_uri_test_equal (mbc->uri, sr->uri)))
     return GNUNET_OK;
   mbc->put_cnt++;
   return GNUNET_OK;
@@ -1028,9 +969,7 @@ find_result_set (void *cls,
  * @return number of bytes written to buf
  */
 static size_t
-transmit_search_request (void *cls,
-                         size_t size, 
-                         void *buf)
+transmit_search_request (void *cls, size_t size, void *buf)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct MessageBuilderContext mbc;
@@ -1042,105 +981,91 @@ transmit_search_request (void *cls,
   unsigned int sqms;
 
   if (NULL == buf)
-    {
-      try_reconnect (sc);
-      return 0;
-    }
+  {
+    try_reconnect (sc);
+    return 0;
+  }
   mbc.sc = sc;
   mbc.skip_cnt = sc->search_request_map_offset;
   sm = buf;
   sm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_START_SEARCH);
-  mbc.xoff = (GNUNET_HashCode* ) &sm[1];
+  mbc.xoff = (GNUNET_HashCode *) & sm[1];
   if (GNUNET_FS_uri_test_ksk (sc->uri))
+  {
+    msize = sizeof (struct SearchMessage);
+    GNUNET_assert (size >= msize);
+    mbc.uri = NULL;
+    mbc.put_cnt = 0;
+    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                           &find_result_set, &mbc);
+    sqms = mbc.put_cnt;
+    mbc.put_cnt = (size - msize) / sizeof (GNUNET_HashCode);
+    mbc.put_cnt = GNUNET_MIN (mbc.put_cnt, sqms - mbc.skip_cnt);
+    if (sc->search_request_map_offset < sqms)
+      GNUNET_assert (mbc.put_cnt > 0);
+
+    sm->header.size = htons (msize);
+    if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
+      sm->options = htonl (1);
+    else
+      sm->options = htonl (0);
+    sm->type = htonl (GNUNET_BLOCK_TYPE_ANY);
+    sm->anonymity_level = htonl (sc->anonymity);
+    memset (&sm->target, 0, sizeof (GNUNET_HashCode));
+    sm->query = sc->requests[sc->keyword_offset].query;
+    msize += sizeof (GNUNET_HashCode) * mbc.put_cnt;
+    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                           &build_result_set, &mbc);
+    sm->header.size = htons (msize);
+    if (sqms != sc->search_request_map_offset)
+    {
+      /* more requesting to be done... */
+      schedule_transmit_search_request (sc);
+      return msize;
+    }
+    sc->keyword_offset++;
+    if (sc->uri->data.ksk.keywordCount != sc->keyword_offset)
     {
-      msize = sizeof (struct SearchMessage);
-      GNUNET_assert (size >= msize);
-      mbc.uri = NULL;
-      mbc.put_cnt = 0;
-      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                             &find_result_set,
-                                             &mbc);
-      sqms = mbc.put_cnt;
-      mbc.put_cnt = (size - msize) / sizeof (GNUNET_HashCode);
-      mbc.put_cnt = GNUNET_MIN (mbc.put_cnt,
-                                sqms - mbc.skip_cnt);
-      if (sc->search_request_map_offset < sqms)
-        GNUNET_assert (mbc.put_cnt > 0);
-
-      sm->header.size = htons (msize);
-      if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
-        sm->options = htonl (1);
-      else
-        sm->options = htonl (0);          
-      sm->type = htonl (GNUNET_BLOCK_TYPE_ANY);
-      sm->anonymity_level = htonl (sc->anonymity);
-      memset (&sm->target, 0, sizeof (GNUNET_HashCode));
-      sm->query = sc->requests[sc->keyword_offset].query;
-      msize += sizeof (GNUNET_HashCode) * mbc.put_cnt;
-      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                             &build_result_set,
-                                             &mbc);
-      sm->header.size = htons (msize);
-      if (sqms != sc->search_request_map_offset)
-        {
-          /* more requesting to be done... */
-          schedule_transmit_search_request (sc);
-          return msize;
-        }
-      sc->keyword_offset++;
-      if (sc->uri->data.ksk.keywordCount !=
-          sc->keyword_offset)
-        {
-          /* more requesting to be done... */
-          schedule_transmit_search_request (sc);
-          return msize;
-        }
+      /* more requesting to be done... */
+      schedule_transmit_search_request (sc);
+      return msize;
     }
+  }
   else
+  {
+    GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri));
+    msize = sizeof (struct SearchMessage);
+    GNUNET_assert (size >= msize);
+    if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
+      sm->options = htonl (1);
+    else
+      sm->options = htonl (0);
+    sm->type = htonl (GNUNET_BLOCK_TYPE_FS_SBLOCK);
+    sm->anonymity_level = htonl (sc->anonymity);
+    sm->target = sc->uri->data.sks.namespace;
+    identifier = sc->uri->data.sks.identifier;
+    GNUNET_CRYPTO_hash (identifier, strlen (identifier), &key);
+    GNUNET_CRYPTO_hash (&key, sizeof (GNUNET_HashCode), &idh);
+    GNUNET_CRYPTO_hash_xor (&idh, &sm->target, &sm->query);
+    mbc.put_cnt = (size - msize) / sizeof (GNUNET_HashCode);
+    sqms = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
+    mbc.put_cnt = GNUNET_MIN (mbc.put_cnt, sqms - mbc.skip_cnt);
+    mbc.uri = NULL;
+    if (sc->search_request_map_offset < sqms)
+      GNUNET_assert (mbc.put_cnt > 0);
+    msize += sizeof (GNUNET_HashCode) * mbc.put_cnt;
+    GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
+                                           &build_result_set, &mbc);
+    sm->header.size = htons (msize);
+    if (sqms != sc->search_request_map_offset)
     {
-      GNUNET_assert (GNUNET_FS_uri_test_sks (sc->uri));
-      msize = sizeof (struct SearchMessage);
-      GNUNET_assert (size >= msize);
-      if (0 != (sc->options & GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY))
-        sm->options = htonl (1);
-      else
-        sm->options = htonl (0);      
-      sm->type = htonl (GNUNET_BLOCK_TYPE_FS_SBLOCK);
-      sm->anonymity_level = htonl (sc->anonymity);
-      sm->target = sc->uri->data.sks.namespace;
-      identifier = sc->uri->data.sks.identifier;
-      GNUNET_CRYPTO_hash (identifier,
-                          strlen (identifier),
-                          &key);
-      GNUNET_CRYPTO_hash (&key,
-                          sizeof (GNUNET_HashCode),
-                          &idh);
-      GNUNET_CRYPTO_hash_xor (&idh,
-                              &sm->target,
-                              &sm->query);
-      mbc.put_cnt = (size - msize) / sizeof (GNUNET_HashCode);
-      sqms = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map);
-      mbc.put_cnt = GNUNET_MIN (mbc.put_cnt,
-                                sqms - mbc.skip_cnt);
-      mbc.uri = NULL;
-      if (sc->search_request_map_offset < sqms)
-        GNUNET_assert (mbc.put_cnt > 0);
-      msize += sizeof (GNUNET_HashCode) * mbc.put_cnt;
-      GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                             &build_result_set,
-                                             &mbc);
-      sm->header.size = htons (msize);
-      if (sqms != sc->search_request_map_offset)
-        {
-          /* more requesting to be done... */
-          schedule_transmit_search_request (sc);
-          return msize;
-        }
+      /* more requesting to be done... */
+      schedule_transmit_search_request (sc);
+      return msize;
     }
+  }
   GNUNET_CLIENT_receive (sc->client,
-                         &receive_results,
-                         sc,
-                         GNUNET_TIME_UNIT_FOREVER_REL);
+                         &receive_results, sc, GNUNET_TIME_UNIT_FOREVER_REL);
   return msize;
 }
 
@@ -1159,16 +1084,16 @@ schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
   unsigned int fit;
 
   size = sizeof (struct SearchMessage);
-  sqms = GNUNET_CONTAINER_multihashmap_size (sc->master_result_map) - sc->search_request_map_offset;  
+  sqms =
+      GNUNET_CONTAINER_multihashmap_size (sc->master_result_map) -
+      sc->search_request_map_offset;
   fit = (GNUNET_SERVER_MAX_MESSAGE_SIZE - 1 - size) / sizeof (GNUNET_HashCode);
   fit = GNUNET_MIN (fit, sqms);
   size += sizeof (GNUNET_HashCode) * fit;
   GNUNET_CLIENT_notify_transmit_ready (sc->client,
-                                       size,
+                                       size,
                                        GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                       GNUNET_NO,
-                                       &transmit_search_request,
-                                       sc);  
+                                       GNUNET_NO, &transmit_search_request, sc);
 
 }
 
@@ -1181,20 +1106,18 @@ schedule_transmit_search_request (struct GNUNET_FS_SearchContext *sc)
  * @param tc unused
  */
 static void
-do_reconnect (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_reconnect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_CLIENT_Connection *client;
- 
+
   sc->task = GNUNET_SCHEDULER_NO_TASK;
-  client = GNUNET_CLIENT_connect ("fs",
-                                  sc->h->cfg);
+  client = GNUNET_CLIENT_connect ("fs", sc->h->cfg);
   if (NULL == client)
-    {
-      try_reconnect (sc);
-      return;
-    }
+  {
+    try_reconnect (sc);
+    return;
+  }
   sc->client = client;
   sc->search_request_map_offset = 0;
   sc->keyword_offset = 0;
@@ -1209,18 +1132,17 @@ do_reconnect (void *cls,
  *
  * @param sc the search to reconnec
  */
-static void 
+static void
 try_reconnect (struct GNUNET_FS_SearchContext *sc)
 {
   if (NULL != sc->client)
-    {
-      GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
-      sc->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
+    sc->client = NULL;
+  }
   sc->task
-    = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
-                                    &do_reconnect,
-                                    sc);
+      = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                      &do_reconnect, sc);
 }
 
 
@@ -1238,36 +1160,34 @@ try_reconnect (struct GNUNET_FS_SearchContext *sc)
  */
 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)
+              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_malloc (sizeof(struct GNUNET_FS_SearchContext));
+  sc = GNUNET_malloc (sizeof (struct GNUNET_FS_SearchContext));
   sc->h = h;
   sc->options = options;
   sc->uri = GNUNET_FS_uri_dup (uri);
   sc->anonymity = anonymity;
   sc->start_time = GNUNET_TIME_absolute_get ();
   if (psearch != NULL)
-    {
-      sc->psearch_result = psearch;  
-      psearch->update_search = sc;
-    }
+  {
+    sc->psearch_result = psearch;
+    psearch->update_search = sc;
+  }
   sc->master_result_map = GNUNET_CONTAINER_multihashmap_create (16);
   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;
-    }
+  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);
@@ -1288,39 +1208,35 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
   unsigned int i;
   const char *keyword;
   GNUNET_HashCode hc;
-  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;  
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pub;
   struct GNUNET_CRYPTO_RsaPrivateKey *pk;
 
   GNUNET_assert (NULL == sc->client);
   if (GNUNET_FS_uri_test_ksk (sc->uri))
+  {
+    GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
+    sc->requests = GNUNET_malloc (sizeof (struct SearchRequestEntry) *
+                                  sc->uri->data.ksk.keywordCount);
+    for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
     {
-      GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
-      sc->requests = GNUNET_malloc (sizeof (struct SearchRequestEntry) *
-                                    sc->uri->data.ksk.keywordCount);
-      for (i=0;i<sc->uri->data.ksk.keywordCount;i++)
-        {
-          keyword = &sc->uri->data.ksk.keywords[i][1];
-          GNUNET_CRYPTO_hash (keyword, 
-                              strlen (keyword), 
-                              &hc);
-          pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc);
-          GNUNET_assert (pk != NULL);
-          GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
-          GNUNET_CRYPTO_rsa_key_free (pk);
-          GNUNET_CRYPTO_hash (&pub,
-                              sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), 
-                              &sc->requests[i].query);
-          sc->requests[i].mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
-          if (sc->requests[i].mandatory)
-            sc->mandatory_count++;
-          sc->requests[i].results = GNUNET_CONTAINER_multihashmap_create (4);
-          GNUNET_CRYPTO_hash (keyword,
-                              strlen (keyword),
-                              &sc->requests[i].key);
-        }
+      keyword = &sc->uri->data.ksk.keywords[i][1];
+      GNUNET_CRYPTO_hash (keyword, strlen (keyword), &hc);
+      pk = GNUNET_CRYPTO_rsa_key_create_from_hash (&hc);
+      GNUNET_assert (pk != NULL);
+      GNUNET_CRYPTO_rsa_key_get_public (pk, &pub);
+      GNUNET_CRYPTO_rsa_key_free (pk);
+      GNUNET_CRYPTO_hash (&pub,
+                          sizeof (struct
+                                  GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                          &sc->requests[i].query);
+      sc->requests[i].mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
+      if (sc->requests[i].mandatory)
+        sc->mandatory_count++;
+      sc->requests[i].results = GNUNET_CONTAINER_multihashmap_create (4);
+      GNUNET_CRYPTO_hash (keyword, strlen (keyword), &sc->requests[i].key);
     }
-  sc->client = GNUNET_CLIENT_connect ("fs",
-                                      sc->h->cfg);
+  }
+  sc->client = GNUNET_CLIENT_connect ("fs", sc->h->cfg);
   if (NULL == sc->client)
     return GNUNET_SYSERR;
   schedule_transmit_search_request (sc);
@@ -1338,21 +1254,20 @@ GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
  */
 static int
 search_result_freeze_probes (void *cls,
-                             const GNUNET_HashCode * key,
-                             void *value)
+                             const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
   if (sr->probe_ctx != NULL)
-    {
-      GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);    
-      sr->probe_ctx = NULL;
-    }
+  {
+    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
+    sr->probe_ctx = NULL;
+  }
   if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
-      sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
+    sr->probe_cancel_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (sr->update_search != NULL)
     GNUNET_FS_search_pause (sr->update_search);
   return GNUNET_OK;
@@ -1369,8 +1284,7 @@ search_result_freeze_probes (void *cls,
  */
 static int
 search_result_resume_probes (void *cls,
-                             const GNUNET_HashCode * key,
-                             void *value)
+                             const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchResult *sr = value;
 
@@ -1390,9 +1304,7 @@ search_result_resume_probes (void *cls,
  * @return GNUNET_OK
  */
 static int
-search_result_suspend (void *cls,
-                       const GNUNET_HashCode * key,
-                       void *value)
+search_result_suspend (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GNUNET_FS_SearchContext *sc = cls;
   struct GNUNET_FS_SearchResult *sr = value;
@@ -1412,7 +1324,7 @@ search_result_suspend (void *cls,
   GNUNET_FS_uri_destroy (sr->uri);
   GNUNET_CONTAINER_meta_data_destroy (sr->meta);
   if (sr->probe_ctx != NULL)
-    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);    
+    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
   if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
   GNUNET_free (sr);
@@ -1435,8 +1347,7 @@ GNUNET_FS_search_signal_suspend_ (void *cls)
 
   GNUNET_FS_end_top (sc->h, sc->top);
   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                         &search_result_suspend,
-                                         sc);
+                                         &search_result_suspend, sc);
   pi.status = GNUNET_FS_STATUS_SEARCH_SUSPEND;
   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
   GNUNET_break (NULL == sc->client_info);
@@ -1446,11 +1357,11 @@ GNUNET_FS_search_signal_suspend_ (void *cls)
     GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
   GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
   if (sc->requests != NULL)
-    {
-      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_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);
@@ -1472,12 +1383,12 @@ GNUNET_FS_search_signal_suspend_ (void *cls)
  */
 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)
+                        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);
   if (ret == NULL)
     return NULL;
@@ -1491,7 +1402,7 @@ GNUNET_FS_search_start (struct GNUNET_FS_Handle *h,
  *
  * @param sc context for the search that should be paused
  */
-void 
+void
 GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_FS_ProgressInfo pi;
@@ -1504,8 +1415,7 @@ GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
   sc->client = NULL;
   GNUNET_FS_search_sync_ (sc);
   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                         &search_result_freeze_probes,
-                                         sc);
+                                         &search_result_freeze_probes, sc);
   pi.status = GNUNET_FS_STATUS_SEARCH_PAUSED;
   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
 }
@@ -1516,7 +1426,7 @@ GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
  *
  * @param sc context for the search that should be resumed
  */
-void 
+void
 GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_FS_ProgressInfo pi;
@@ -1528,8 +1438,7 @@ GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
   pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED;
   sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc);
   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                         &search_result_resume_probes,
-                                         sc);
+                                         &search_result_resume_probes, sc);
 }
 
 
@@ -1542,39 +1451,36 @@ GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
  * @return GNUNET_OK
  */
 static int
-search_result_free (void *cls,
-                    const GNUNET_HashCode * key,
-                    void *value)
+search_result_free (void *cls, const 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)
+  {
+    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 (NULL != sr->update_search)
-    {
-      GNUNET_FS_search_stop (sr->update_search);
-      GNUNET_assert (sr->update_search == NULL);
-    }
+  {
+    GNUNET_FS_search_stop (sr->update_search);
+    GNUNET_assert (sr->update_search == NULL);
+  }
   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;
@@ -1585,7 +1491,7 @@ search_result_free (void *cls,
   GNUNET_FS_uri_destroy (sr->uri);
   GNUNET_CONTAINER_meta_data_destroy (sr->meta);
   if (sr->probe_ctx != NULL)
-    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);    
+    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
   if (sr->probe_cancel_task != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (sr->probe_cancel_task);
   GNUNET_free (sr);
@@ -1598,7 +1504,7 @@ search_result_free (void *cls,
  *
  * @param sc context for the search that should be stopped
  */
-void 
+void
 GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
 {
   struct GNUNET_FS_ProgressInfo pi;
@@ -1609,22 +1515,21 @@ GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
   if (sc->psearch_result != NULL)
     sc->psearch_result->update_search = NULL;
   GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
-                                         &search_result_free,
-                                         sc);
+                                         &search_result_free, sc);
   if (sc->serialization != NULL)
-    {
-      GNUNET_FS_remove_sync_file_ (sc->h,
-                                   (sc->psearch_result != NULL)  
-                                   ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH 
-                                   : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
-                                   sc->serialization);
-      GNUNET_FS_remove_sync_dir_ (sc->h,
-                                  (sc->psearch_result != NULL)  
-                                  ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH 
-                                  : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
-                                  sc->serialization);
-      GNUNET_free (sc->serialization);
-    }
+  {
+    GNUNET_FS_remove_sync_file_ (sc->h,
+                                 (sc->psearch_result != NULL)
+                                 ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH
+                                 : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
+                                 sc->serialization);
+    GNUNET_FS_remove_sync_dir_ (sc->h,
+                                (sc->psearch_result != NULL)
+                                ? 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);
   GNUNET_break (NULL == sc->client_info);
@@ -1634,11 +1539,11 @@ GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
     GNUNET_CLIENT_disconnect (sc->client, GNUNET_NO);
   GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
   if (sc->requests != NULL)
-    {
-      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_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);
diff --git a/src/fs/fs_test_lib.c b/src/fs/fs_test_lib.c
index 522967f13..334432232 100644
--- a/src/fs/fs_test_lib.c
+++ b/src/fs/fs_test_lib.c
@@ -77,7 +77,7 @@ struct GNUNET_FS_TestDaemon
    * Function to call when upload is done.
    */
   GNUNET_FS_TEST_UriContinuation publish_cont;
-  
+
   /**
    * Closure for publish_cont.
    */
@@ -105,7 +105,7 @@ struct GNUNET_FS_TestDaemon
 
   /**
    * Name of the temporary file used, or NULL for none.
-   */ 
+   */
   char *publish_tmp_file;
 
   /**
@@ -130,7 +130,7 @@ struct GNUNET_FS_TestDaemon
 
   /**
    * Context for current download operation.
-   */  
+   */
   struct GNUNET_FS_DownloadContext *download_context;
 
   /**
@@ -138,39 +138,35 @@ struct GNUNET_FS_TestDaemon
    */
   int verbose;
 
-                
+
 };
 
 /**
  * Check whether peers successfully shut down.
  */
-static void 
-shutdown_callback (void *cls,
-                   const char *emsg)
+static void
+shutdown_callback (void *cls, const char *emsg)
 {
   struct GNUNET_CONFIGURATION_Handle *gcfg = cls;
 
   if (emsg != NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Shutdown of peers failed: %s\n",
-                  emsg);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Shutdown of peers failed: %s\n", emsg);
+  }
   else
-    {
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All peers successfully shut down!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "All peers successfully shut down!\n");
 #endif
-    }
+  }
   if (gcfg != NULL)
     GNUNET_CONFIGURATION_destroy (gcfg);
 }
 
 
 static void
-report_uri (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+report_uri (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_TestDaemon *daemon = cls;
   GNUNET_FS_TEST_UriContinuation cont;
@@ -181,73 +177,70 @@ report_uri (void *cls,
   cont = daemon->publish_cont;
   daemon->publish_cont = NULL;
   uri = daemon->publish_uri;
-  cont (daemon->publish_cont_cls,
-        uri);
+  cont (daemon->publish_cont_cls, uri);
   GNUNET_FS_uri_destroy (uri);
-}            
+}
 
 
 static void
-report_success (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+report_success (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_TestDaemon *daemon = cls;
 
   GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES);
   daemon->download_context = NULL;
   GNUNET_SCHEDULER_add_continuation (daemon->download_cont,
-                                     daemon->download_cont_cls,
-                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);      
+                                     daemon->download_cont_cls,
+                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);
   daemon->download_cont = NULL;
 }
 
 
-static void*
-progress_cb (void *cls,
-             const struct GNUNET_FS_ProgressInfo *info)
+static void *
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   struct GNUNET_FS_TestDaemon *daemon = cls;
 
   switch (info->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:      
-      GNUNET_SCHEDULER_cancel (daemon->publish_timeout_task);
-      daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
-      daemon->publish_uri = GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
-      GNUNET_SCHEDULER_add_continuation (&report_uri,
-                                         daemon,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      if (daemon->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_DOWNLOAD_PROGRESS:
-      if (daemon->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 (daemon->download_timeout_task);
-      daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
-      GNUNET_SCHEDULER_add_continuation (&report_success,
-                                         daemon,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_PUBLISH_COMPLETED:
+    GNUNET_SCHEDULER_cancel (daemon->publish_timeout_task);
+    daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    daemon->publish_uri =
+        GNUNET_FS_uri_dup (info->value.publish.specifics.completed.chk_uri);
+    GNUNET_SCHEDULER_add_continuation (&report_uri, daemon,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    if (daemon->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_DOWNLOAD_PROGRESS:
+    if (daemon->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 (daemon->download_timeout_task);
+    daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    GNUNET_SCHEDULER_add_continuation (&report_success,
+                                       daemon,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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;
 }
 
@@ -266,31 +259,28 @@ struct StartContext
 };
 
 
-static void 
+static void
 notify_running (void *cls,
-                const struct GNUNET_PeerIdentity *id,
-                const struct GNUNET_CONFIGURATION_Handle *cfg,
-                struct GNUNET_TESTING_Daemon *d,
-                const char *emsg)
+                const struct GNUNET_PeerIdentity *id,
+                const struct GNUNET_CONFIGURATION_Handle *cfg,
+                struct GNUNET_TESTING_Daemon *d, const char *emsg)
 {
   struct StartContext *sctx = cls;
   unsigned int i;
 
   if (emsg != NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to start daemon: %s\n"),
-                  emsg);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to start daemon: %s\n"), emsg);
+    return;
+  }
   i = 0;
   while (i < sctx->total)
-    {
-      if (GNUNET_TESTING_daemon_get (sctx->group,
-                                     i) == d)
-        break;
-      i++;
-    }
+  {
+    if (GNUNET_TESTING_daemon_get (sctx->group, i) == d)
+      break;
+    i++;
+  }
   GNUNET_assert (i < sctx->total);
   GNUNET_assert (sctx->have < sctx->total);
   GNUNET_assert (sctx->daemons[i]->cfg == NULL);
@@ -300,50 +290,49 @@ notify_running (void *cls,
   sctx->daemons[i]->id = *id;
   sctx->have++;
   if (sctx->have == sctx->total)
+  {
+    GNUNET_SCHEDULER_add_continuation (sctx->cont,
+                                       sctx->cont_cls,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    sctx->daemons[0]->gcfg = sctx->cfg;
+    GNUNET_SCHEDULER_cancel (sctx->timeout_task);
+    for (i = 0; i < sctx->total; i++)
     {
-      GNUNET_SCHEDULER_add_continuation (sctx->cont,
-                                         sctx->cont_cls,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      sctx->daemons[0]->gcfg = sctx->cfg;
-      GNUNET_SCHEDULER_cancel (sctx->timeout_task);
-      for (i=0;i<sctx->total;i++)
-        {
-          sctx->daemons[i]->fs = GNUNET_FS_start (sctx->daemons[i]->cfg,
-                                                  "<tester>",
-                                                  &progress_cb,
-                                                  sctx->daemons[i],
-                                                  GNUNET_FS_FLAGS_NONE,
-                                                  GNUNET_FS_OPTIONS_END);
-        }
-      GNUNET_free (sctx);
+      sctx->daemons[i]->fs = GNUNET_FS_start (sctx->daemons[i]->cfg,
+                                              "<tester>",
+                                              &progress_cb,
+                                              sctx->daemons[i],
+                                              GNUNET_FS_FLAGS_NONE,
+                                              GNUNET_FS_OPTIONS_END);
     }
+    GNUNET_free (sctx);
+  }
 }
 
 
 static void
-start_timeout (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+start_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct StartContext *sctx = cls;
   unsigned int i;
 
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Timeout while trying to start daemons\n");
+              "Timeout while trying to start daemons\n");
   GNUNET_TESTING_daemons_stop (sctx->group,
-                               GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30), 
-                               &shutdown_callback,
-                               NULL);
-  for (i=0;i<sctx->total;i++)
-    {
-      if (i < sctx->have)
-        GNUNET_CONFIGURATION_destroy (sctx->daemons[i]->cfg);
-      GNUNET_free (sctx->daemons[i]);
-      sctx->daemons[i] = NULL;
-    }
+                               GNUNET_TIME_relative_multiply
+                               (GNUNET_TIME_UNIT_SECONDS, 30),
+                               &shutdown_callback, NULL);
+  for (i = 0; i < sctx->total; i++)
+  {
+    if (i < sctx->have)
+      GNUNET_CONFIGURATION_destroy (sctx->daemons[i]->cfg);
+    GNUNET_free (sctx->daemons[i]);
+    sctx->daemons[i] = NULL;
+  }
   GNUNET_CONFIGURATION_destroy (sctx->cfg);
   GNUNET_SCHEDULER_add_continuation (sctx->cont,
-                                     sctx->cont_cls,
-                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
+                                     sctx->cont_cls,
+                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
   GNUNET_free (sctx);
 }
 
@@ -362,11 +351,10 @@ start_timeout (void *cls,
  */
 void
 GNUNET_FS_TEST_daemons_start (const char *template_cfg_file,
-                              struct GNUNET_TIME_Relative timeout,
-                              unsigned int total,
-                              struct GNUNET_FS_TestDaemon **daemons,
-                              GNUNET_SCHEDULER_Task cont,
-                              void *cont_cls)
+                              struct GNUNET_TIME_Relative timeout,
+                              unsigned int total,
+                              struct GNUNET_FS_TestDaemon **daemons,
+                              GNUNET_SCHEDULER_Task cont, void *cont_cls)
 {
   struct StartContext *sctx;
   unsigned int i;
@@ -378,34 +366,27 @@ GNUNET_FS_TEST_daemons_start (const char *template_cfg_file,
   sctx->cont = cont;
   sctx->cont_cls = cont_cls;
   sctx->cfg = GNUNET_CONFIGURATION_create ();
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_load (sctx->cfg,
-                                 template_cfg_file))
-    {
-      GNUNET_break (0);
-      GNUNET_CONFIGURATION_destroy (sctx->cfg);
-      GNUNET_free (sctx);
-      GNUNET_SCHEDULER_add_continuation (cont,
-                                         cont_cls,
-                                         GNUNET_SCHEDULER_REASON_TIMEOUT);
-      return;
-    }
-  for (i=0;i<total;i++)
+  if (GNUNET_OK != GNUNET_CONFIGURATION_load (sctx->cfg, template_cfg_file))
+  {
+    GNUNET_break (0);
+    GNUNET_CONFIGURATION_destroy (sctx->cfg);
+    GNUNET_free (sctx);
+    GNUNET_SCHEDULER_add_continuation (cont,
+                                       cont_cls,
+                                       GNUNET_SCHEDULER_REASON_TIMEOUT);
+    return;
+  }
+  for (i = 0; i < total; i++)
     daemons[i] = GNUNET_malloc (sizeof (struct GNUNET_FS_TestDaemon));
-  sctx->group = GNUNET_TESTING_daemons_start (sctx->cfg,
-                                              total,
-                                              total, /* Outstanding connections */
-                                              total, /* Outstanding ssh connections */
-                                              timeout,
-                                              NULL,
-                                              NULL,
-                                              &notify_running,
-                                              sctx,
-                                              NULL, NULL,
-                                              NULL);
+  sctx->group = GNUNET_TESTING_daemons_start (sctx->cfg, total, total,  /* Outstanding connections */
+                                              total,    /* Outstanding ssh connections */
+                                              timeout,
+                                              NULL,
+                                              NULL,
+                                              &notify_running,
+                                              sctx, NULL, NULL, NULL);
   sctx->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                                     &start_timeout,
-                                                     sctx);
+                                                     &start_timeout, sctx);
 }
 
 
@@ -432,26 +413,25 @@ struct ConnectContext
  */
 static void
 notify_connection (void *cls,
-                   const struct GNUNET_PeerIdentity *first,
-                   const struct GNUNET_PeerIdentity *second,
-                   uint32_t distance,
-                   const struct GNUNET_CONFIGURATION_Handle *first_cfg,
-                   const struct GNUNET_CONFIGURATION_Handle *second_cfg,
-                   struct GNUNET_TESTING_Daemon *first_daemon,
-                   struct GNUNET_TESTING_Daemon *second_daemon,
-                   const char *emsg)
+                   const struct GNUNET_PeerIdentity *first,
+                   const struct GNUNET_PeerIdentity *second,
+                   uint32_t distance,
+                   const struct GNUNET_CONFIGURATION_Handle *first_cfg,
+                   const struct GNUNET_CONFIGURATION_Handle *second_cfg,
+                   struct GNUNET_TESTING_Daemon *first_daemon,
+                   struct GNUNET_TESTING_Daemon *second_daemon,
+                   const char *emsg)
 {
   struct ConnectContext *cc = cls;
-  
+
   if (emsg != NULL)
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Failed to connect peers: %s\n",
-                emsg);
+                "Failed to connect peers: %s\n", emsg);
   GNUNET_SCHEDULER_add_continuation (cc->cont,
-                                     cc->cont_cls,
-                                     (emsg != NULL) 
-                                     ? GNUNET_SCHEDULER_REASON_TIMEOUT 
-                                     : GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+                                     cc->cont_cls,
+                                     (emsg != NULL)
+                                     ? GNUNET_SCHEDULER_REASON_TIMEOUT
+                                     : GNUNET_SCHEDULER_REASON_PREREQ_DONE);
   GNUNET_free (cc);
 }
 
@@ -468,10 +448,9 @@ notify_connection (void *cls,
  */
 void
 GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1,
-                                struct GNUNET_FS_TestDaemon *daemon2,
-                                struct GNUNET_TIME_Relative timeout,
-                                GNUNET_SCHEDULER_Task cont,
-                                void *cont_cls)
+                                struct GNUNET_FS_TestDaemon *daemon2,
+                                struct GNUNET_TIME_Relative timeout,
+                                GNUNET_SCHEDULER_Task cont, void *cont_cls)
 {
   struct ConnectContext *ncc;
 
@@ -479,12 +458,10 @@ GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1,
   ncc->cont = cont;
   ncc->cont_cls = cont_cls;
   GNUNET_TESTING_daemons_connect (daemon1->daemon,
-                                  daemon2->daemon,
-                                  timeout,
-                                  CONNECT_ATTEMPTS,
-                                  GNUNET_YES,
-                                  &notify_connection,
-                                  ncc);
+                                  daemon2->daemon,
+                                  timeout,
+                                  CONNECT_ATTEMPTS,
+                                  GNUNET_YES, &notify_connection, ncc);
 }
 
 
@@ -497,9 +474,9 @@ GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1,
  */
 const struct GNUNET_CONFIGURATION_Handle *
 GNUNET_FS_TEST_get_configuration (struct GNUNET_FS_TestDaemon **daemons,
-                                  unsigned int off)
+                                  unsigned int off)
 {
-  return daemons[off]->cfg;  
+  return daemons[off]->cfg;
 }
 
 /**
@@ -511,7 +488,7 @@ GNUNET_FS_TEST_get_configuration (struct GNUNET_FS_TestDaemon **daemons,
 struct GNUNET_TESTING_PeerGroup *
 GNUNET_FS_TEST_get_group (struct GNUNET_FS_TestDaemon **daemons)
 {
-  return daemons[0]->group;  
+  return daemons[0]->group;
 }
 
 
@@ -523,7 +500,7 @@ GNUNET_FS_TEST_get_group (struct GNUNET_FS_TestDaemon **daemons)
  */
 void
 GNUNET_FS_TEST_daemons_stop (unsigned int total,
-                             struct GNUNET_FS_TestDaemon **daemons)
+                             struct GNUNET_FS_TestDaemon **daemons)
 {
   unsigned int i;
   struct GNUNET_TESTING_PeerGroup *pg;
@@ -534,70 +511,64 @@ GNUNET_FS_TEST_daemons_stop (unsigned int total,
   GNUNET_assert (daemons[0] != NULL);
   pg = daemons[0]->group;
   gcfg = daemons[0]->gcfg;
-  for (i=0;i<total;i++)
+  for (i = 0; i < total; i++)
+  {
+    daemon = daemons[i];
+    if (daemon->download_timeout_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (daemon->download_timeout_task);
+      daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    if (daemon->publish_timeout_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      daemon = daemons[i];
-      if (daemon->download_timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (daemon->download_timeout_task);
-          daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      if (daemon->publish_timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (daemon->publish_timeout_task);
-          daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      if (NULL != daemon->download_context)
-        {
-          GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES);
-          daemon->download_context = NULL;
-        }
-      if (daemon->fs != NULL)
-        GNUNET_FS_stop (daemon->fs);
-      if (daemon->cfg != NULL)
-        GNUNET_CONFIGURATION_destroy (daemon->cfg);
-      if (NULL != daemon->publish_tmp_file)
-        {
-          GNUNET_break (GNUNET_OK ==
-                        GNUNET_DISK_directory_remove (daemon->publish_tmp_file));
-          GNUNET_free (daemon->publish_tmp_file);
-          daemon->publish_tmp_file = NULL;
-        }
-      GNUNET_free (daemon);
-      daemons[i] = NULL;
-    }  
-  GNUNET_TESTING_daemons_stop (pg, 
-                               GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30), 
-                               &shutdown_callback, 
-                               gcfg);
+      GNUNET_SCHEDULER_cancel (daemon->publish_timeout_task);
+      daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    if (NULL != daemon->download_context)
+    {
+      GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES);
+      daemon->download_context = NULL;
+    }
+    if (daemon->fs != NULL)
+      GNUNET_FS_stop (daemon->fs);
+    if (daemon->cfg != NULL)
+      GNUNET_CONFIGURATION_destroy (daemon->cfg);
+    if (NULL != daemon->publish_tmp_file)
+    {
+      GNUNET_break (GNUNET_OK ==
+                    GNUNET_DISK_directory_remove (daemon->publish_tmp_file));
+      GNUNET_free (daemon->publish_tmp_file);
+      daemon->publish_tmp_file = NULL;
+    }
+    GNUNET_free (daemon);
+    daemons[i] = NULL;
+  }
+  GNUNET_TESTING_daemons_stop (pg,
+                               GNUNET_TIME_relative_multiply
+                               (GNUNET_TIME_UNIT_SECONDS, 30),
+                               &shutdown_callback, gcfg);
 }
 
 
 static void
-publish_timeout (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+publish_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_TestDaemon *daemon = cls;
   GNUNET_FS_TEST_UriContinuation cont;
 
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Timeout while trying to publish data\n");
+              "Timeout while trying to publish data\n");
   cont = daemon->publish_cont;
   daemon->publish_timeout_task = GNUNET_SCHEDULER_NO_TASK;
   daemon->publish_cont = NULL;
   GNUNET_FS_publish_stop (daemon->publish_context);
   daemon->publish_context = NULL;
-  cont (daemon->publish_cont_cls,
-        NULL);
+  cont (daemon->publish_cont_cls, NULL);
 }
 
 
 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)
 {
   struct GNUNET_FS_TestDaemon *daemon = cls;
   uint64_t pos;
@@ -608,15 +579,15 @@ file_generator (void *cls,
     *emsg = NULL;
   if (buf == NULL)
     return 0;
-  for (pos=0;pos<8;pos++)
-    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 * daemon->publish_seed) % mod);  
-    }
+  for (pos = 0; pos < 8; pos++)
+    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 * daemon->publish_seed) % mod);
+  }
   return max;
 }
 
@@ -639,14 +610,13 @@ file_generator (void *cls,
  */
 void
 GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon,
-                        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 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 GNUNET_FS_FileInformation *fi;
   struct GNUNET_DISK_FileHandle *fh;
@@ -655,7 +625,7 @@ GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon,
   char buf[DBLOCK_SIZE];
   size_t bsize;
   struct GNUNET_FS_BlockOptions bo;
- 
+
   GNUNET_assert (daemon->publish_cont == NULL);
   daemon->publish_cont = cont;
   daemon->publish_cont_cls = cont_cls;
@@ -666,78 +636,66 @@ GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon,
   bo.content_priority = 42;
   bo.replication_level = 1;
   if (GNUNET_YES == do_index)
+  {
+    GNUNET_assert (daemon->publish_tmp_file == NULL);
+    daemon->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index");
+    GNUNET_assert (daemon->publish_tmp_file != NULL);
+    fh = GNUNET_DISK_file_open (daemon->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 < size)
     {
-      GNUNET_assert (daemon->publish_tmp_file == NULL);
-      daemon->publish_tmp_file = GNUNET_DISK_mktemp ("fs-test-publish-index");
-      GNUNET_assert (daemon->publish_tmp_file != NULL);
-      fh = GNUNET_DISK_file_open (daemon->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 < size)
-        {
-          bsize = GNUNET_MIN (sizeof (buf),
-                              size - off);
-          emsg = NULL;
-          GNUNET_assert (bsize ==
-                         file_generator (daemon,
-                                         off,
-                                         bsize,
-                                         buf,
-                                         &emsg));
-          GNUNET_assert (emsg == 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 (daemon->fs,
-                                                        daemon,                                               
-                                                        daemon->publish_tmp_file,
-                                                        NULL, NULL,
-                                                        do_index,
-                                                        &bo);
+      bsize = GNUNET_MIN (sizeof (buf), size - off);
+      emsg = NULL;
+      GNUNET_assert (bsize == file_generator (daemon, off, bsize, buf, &emsg));
+      GNUNET_assert (emsg == 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 (daemon->fs,
+                                                      daemon,
+                                                      daemon->publish_tmp_file,
+                                                      NULL, NULL,
+                                                      do_index, &bo);
+  }
   else
-    {
-      fi = GNUNET_FS_file_information_create_from_reader (daemon->fs,
-                                                          daemon,                                                     
-                                                          size,
-                                                          &file_generator,
-                                                          daemon,
-                                                          NULL,
-                                                          NULL,
-                                                          do_index,
-                                                          &bo);
-    }
+  {
+    fi = GNUNET_FS_file_information_create_from_reader (daemon->fs,
+                                                        daemon,
+                                                        size,
+                                                        &file_generator,
+                                                        daemon,
+                                                        NULL,
+                                                        NULL, do_index, &bo);
+  }
   daemon->publish_context = GNUNET_FS_publish_start (daemon->fs,
-                                                     fi,
-                                                     NULL, NULL, NULL,
-                                                     GNUNET_FS_PUBLISH_OPTION_NONE);
+                                                     fi,
+                                                     NULL, NULL, NULL,
+                                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   daemon->publish_timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                                               &publish_timeout,
-                                                               daemon);
+                                                               &publish_timeout,
+                                                               daemon);
 }
 
 
 static void
-download_timeout (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+download_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_TestDaemon *daemon = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-              "Timeout while trying to download file\n");
+              "Timeout while trying to download file\n");
   daemon->download_timeout_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_FS_download_stop (daemon->download_context, GNUNET_YES);
   daemon->download_context = NULL;
   GNUNET_SCHEDULER_add_continuation (daemon->download_cont,
-                                     daemon->download_cont_cls,
-                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
+                                     daemon->download_cont_cls,
+                                     GNUNET_SCHEDULER_REASON_TIMEOUT);
   daemon->download_cont = NULL;
 }
 
@@ -757,35 +715,33 @@ download_timeout (void *cls,
  */
 void
 GNUNET_FS_TEST_download (struct GNUNET_FS_TestDaemon *daemon,
-                         struct GNUNET_TIME_Relative timeout,
-                         uint32_t anonymity,
-                         uint32_t seed,
-                         const struct GNUNET_FS_Uri *uri,
-                         unsigned int verbose,
-                         GNUNET_SCHEDULER_Task cont,
-                         void *cont_cls)
+                         struct GNUNET_TIME_Relative timeout,
+                         uint32_t anonymity,
+                         uint32_t seed,
+                         const struct GNUNET_FS_Uri *uri,
+                         unsigned int verbose,
+                         GNUNET_SCHEDULER_Task cont, void *cont_cls)
 {
   uint64_t size;
- 
+
   GNUNET_assert (daemon->download_cont == NULL);
   size = GNUNET_FS_uri_chk_get_file_size (uri);
   daemon->verbose = verbose;
   daemon->download_cont = cont;
   daemon->download_cont_cls = cont_cls;
-  daemon->download_seed = seed;  
+  daemon->download_seed = seed;
   daemon->download_context = GNUNET_FS_download_start (daemon->fs,
-                                                       uri,
-                                                       NULL, NULL,
-                                                       NULL,
-                                                       0,
-                                                       size,
-                                                       anonymity,
-                                                       GNUNET_FS_DOWNLOAD_OPTION_NONE,
-                                                       NULL,
-                                                       NULL);
+                                                       uri,
+                                                       NULL, NULL,
+                                                       NULL,
+                                                       0,
+                                                       size,
+                                                       anonymity,
+                                                       GNUNET_FS_DOWNLOAD_OPTION_NONE,
+                                                       NULL, NULL);
   daemon->download_timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                                                &download_timeout,
-                                                                daemon);
+                                                                &download_timeout,
+                                                                daemon);
 }
 
 /* end of test_fs_lib.c */
diff --git a/src/fs/fs_test_lib.h b/src/fs/fs_test_lib.h
index b348dfe78..2017b21ea 100644
--- a/src/fs/fs_test_lib.h
+++ b/src/fs/fs_test_lib.h
@@ -55,11 +55,10 @@ struct GNUNET_FS_TestDaemon;
  */
 void
 GNUNET_FS_TEST_daemons_start (const char *template_cfg_file,
-                              struct GNUNET_TIME_Relative timeout,
-                              unsigned int total,
-                              struct GNUNET_FS_TestDaemon **daemons,
-                              GNUNET_SCHEDULER_Task cont,
-                              void *cont_cls);
+                              struct GNUNET_TIME_Relative timeout,
+                              unsigned int total,
+                              struct GNUNET_FS_TestDaemon **daemons,
+                              GNUNET_SCHEDULER_Task cont, void *cont_cls);
 
 
 /**
@@ -74,10 +73,9 @@ GNUNET_FS_TEST_daemons_start (const char *template_cfg_file,
  */
 void
 GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1,
-                                struct GNUNET_FS_TestDaemon *daemon2,
-                                struct GNUNET_TIME_Relative timeout,
-                                GNUNET_SCHEDULER_Task cont,
-                                void *cont_cls);
+                                struct GNUNET_FS_TestDaemon *daemon2,
+                                struct GNUNET_TIME_Relative timeout,
+                                GNUNET_SCHEDULER_Task cont, void *cont_cls);
 
 
 /**
@@ -86,8 +84,9 @@ GNUNET_FS_TEST_daemons_connect (struct GNUNET_FS_TestDaemon *daemon1,
  * @param daemons array with the daemons (must contain at least one)
  * @return peer group
  */
-struct GNUNET_TESTING_PeerGroup *
-GNUNET_FS_TEST_get_group (struct GNUNET_FS_TestDaemon **daemons);
+struct GNUNET_TESTING_PeerGroup *GNUNET_FS_TEST_get_group (struct
+                                                           GNUNET_FS_TestDaemon
+                                                           **daemons);
 
 
 
@@ -98,9 +97,9 @@ GNUNET_FS_TEST_get_group (struct GNUNET_FS_TestDaemon **daemons);
  * @param off which configuration to get
  * @return peer configuration
  */
-const struct GNUNET_CONFIGURATION_Handle *
-GNUNET_FS_TEST_get_configuration (struct GNUNET_FS_TestDaemon **daemons,
-                                  unsigned int off);
+const struct GNUNET_CONFIGURATION_Handle
+    *GNUNET_FS_TEST_get_configuration (struct GNUNET_FS_TestDaemon **daemons,
+                                       unsigned int off);
 
 /**
  * Stop daemons used for testing.
@@ -110,7 +109,7 @@ GNUNET_FS_TEST_get_configuration (struct GNUNET_FS_TestDaemon **daemons,
  */
 void
 GNUNET_FS_TEST_daemons_stop (unsigned int total,
-                             struct GNUNET_FS_TestDaemon **daemons);
+                             struct GNUNET_FS_TestDaemon **daemons);
 
 
 /**
@@ -119,9 +118,9 @@ GNUNET_FS_TEST_daemons_stop (unsigned int total,
  * @param cls closure (user defined)
  * @param uri a URI, NULL for errors
  */
-typedef void 
-(*GNUNET_FS_TEST_UriContinuation)(void *cls,
-                                  const struct GNUNET_FS_Uri *uri);
+typedef void
+    (*GNUNET_FS_TEST_UriContinuation) (void *cls,
+                                       const struct GNUNET_FS_Uri * uri);
 
 
 /**
@@ -141,14 +140,13 @@ typedef void
  */
 void
 GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon,
-                        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 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);
 
 
 /**
@@ -166,13 +164,12 @@ GNUNET_FS_TEST_publish (struct GNUNET_FS_TestDaemon *daemon,
  */
 void
 GNUNET_FS_TEST_download (struct GNUNET_FS_TestDaemon *daemon,
-                         struct GNUNET_TIME_Relative timeout,
-                         uint32_t anonymity,
-                         uint32_t seed,
-                         const struct GNUNET_FS_Uri *uri,
-                         unsigned int verbose,
-                         GNUNET_SCHEDULER_Task cont,
-                         void *cont_cls);
+                         struct GNUNET_TIME_Relative timeout,
+                         uint32_t anonymity,
+                         uint32_t seed,
+                         const struct GNUNET_FS_Uri *uri,
+                         unsigned int verbose,
+                         GNUNET_SCHEDULER_Task cont, void *cont_cls);
 
 
 
diff --git a/src/fs/fs_tree.c b/src/fs/fs_tree.c
index e22ce8221..5584ad868 100644
--- a/src/fs/fs_tree.c
+++ b/src/fs/fs_tree.c
@@ -40,7 +40,7 @@ struct GNUNET_FS_TreeEncoder
    * Global FS context.
    */
   struct GNUNET_FS_Handle *h;
-  
+
   /**
    * Closure for all callbacks.
    */
@@ -65,7 +65,7 @@ struct GNUNET_FS_TreeEncoder
    * Function to call once we're done with processing.
    */
   GNUNET_SCHEDULER_Task cont;
-  
+
   /**
    * Set to an error message (if we had an error).
    */
@@ -132,15 +132,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;
 }
 
@@ -161,7 +161,7 @@ GNUNET_FS_tree_compute_tree_size (unsigned int depth)
   unsigned int i;
 
   rsize = DBLOCK_SIZE;
-  for (i = 0; i<depth; i++)
+  for (i = 0; i < depth; i++)
     rsize *= CHK_PER_INODE;
   return rsize;
 }
@@ -181,9 +181,8 @@ GNUNET_FS_tree_compute_tree_size (unsigned int depth)
  *        end of a block).
  * @return size of the corresponding IBlock
  */
-static uint16_t 
-GNUNET_FS_tree_compute_iblock_size (unsigned int depth,
-                                    uint64_t end_offset)
+static uint16_t
+GNUNET_FS_tree_compute_iblock_size (unsigned int depth, uint64_t end_offset)
 {
   unsigned int ret;
   uint64_t mod;
@@ -194,19 +193,19 @@ GNUNET_FS_tree_compute_iblock_size (unsigned int depth,
   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));
 }
 
 
@@ -223,8 +222,7 @@ GNUNET_FS_tree_compute_iblock_size (unsigned int depth,
  */
 size_t
 GNUNET_FS_tree_calculate_block_size (uint64_t fsize,
-                                     uint64_t offset,
-                                     unsigned int depth)
+                                     uint64_t offset, unsigned int depth)
 {
   size_t ret;
   uint64_t rsize;
@@ -234,18 +232,16 @@ GNUNET_FS_tree_calculate_block_size (uint64_t 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;
-    }
+  {
+    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) )
+  if ((epos < offset) || (epos > fsize))
     epos = fsize;
   /* round up when computing #CHKs in our IBlock */
   chks = (epos - offset + rsize - 1) / rsize;
@@ -273,16 +269,16 @@ GNUNET_FS_tree_calculate_block_size (uint64_t fsize,
  */
 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_Task cont)
+                               uint64_t size,
+                               void *cls,
+                               GNUNET_FS_DataReader reader,
+                               GNUNET_FS_TreeBlockProcessor proc,
+                               GNUNET_FS_TreeProgressCallback progress,
+                               GNUNET_SCHEDULER_Task cont)
 {
   struct GNUNET_FS_TreeEncoder *te;
-  
-  te = GNUNET_malloc (sizeof (struct GNUNET_FS_TreeEncoder));  
+
+  te = GNUNET_malloc (sizeof (struct GNUNET_FS_TreeEncoder));
   te->h = h;
   te->size = size;
   te->cls = cls;
@@ -292,8 +288,7 @@ GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h,
   te->cont = cont;
   te->chk_tree_depth = GNUNET_FS_compute_depth (size);
   te->chk_tree = GNUNET_malloc (te->chk_tree_depth *
-                                CHK_PER_INODE *
-                                sizeof (struct ContentHashKey));
+                                CHK_PER_INODE * sizeof (struct ContentHashKey));
   return te;
 }
 
@@ -310,17 +305,16 @@ GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h,
  * @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);
   if (depth > 0)
-    end_offset--; /* round down since for depth > 0 offset is at the END of the block */
+    end_offset--;               /* round down since for depth > 0 offset is at the END of the block */
   ret = end_offset / bds;
-  return ret % CHK_PER_INODE; 
+  return ret % CHK_PER_INODE;
 }
 
 
@@ -331,8 +325,8 @@ compute_chk_offset (unsigned int depth,
  *
  * @param te tree encoder to use
  */
-void 
-GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te)
+void
+GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te)
 {
   struct ContentHashKey *mychk;
   const void *pt_block;
@@ -346,105 +340,85 @@ GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te)
   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);
+  {
+    off = CHK_PER_INODE * (te->chk_tree_depth - 1);
 #if DEBUG_TREE
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "TE done, reading CHK `%s' from %u\n",
-              GNUNET_h2s (&te->chk_tree[off].query),           
-              off);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "TE done, reading CHK `%s' from %u\n",
+                GNUNET_h2s (&te->chk_tree[off].query), off);
 #endif
-      te->uri = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
-      te->uri->type = 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, NULL);
-      return;
-    }
+    te->uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
+    te->uri->type = 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, NULL);
+    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))
     {
-      /* 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))
-        {
-          GNUNET_SCHEDULER_add_continuation (te->cont,
-                                             te->cls,
-                                             GNUNET_SCHEDULER_REASON_TIMEOUT);
-          te->in_next = GNUNET_NO;
-          return;
-        }
-      pt_block = iob;
+      GNUNET_SCHEDULER_add_continuation (te->cont,
+                                         te->cls,
+                                         GNUNET_SCHEDULER_REASON_TIMEOUT);
+      te->in_next = GNUNET_NO;
+      return;
     }
+    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);
+  {
+    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);
 #if DEBUG_TREE
   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);
+              "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);
 #endif
-  mychk = &te->chk_tree[te->current_depth*CHK_PER_INODE+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_aes_encrypt (pt_block,
-                             pt_size,
-                             &sk,
-                             &iv,
-                             enc);
+  GNUNET_CRYPTO_aes_encrypt (pt_block, pt_size, &sk, &iv, enc);
   GNUNET_CRYPTO_hash (enc, pt_size, &mychk->query);
 #if DEBUG_TREE
   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);
+              "TE calculates query to be `%s', stored at %u\n",
+              GNUNET_h2s (&mychk->query),
+              te->current_depth * CHK_PER_INODE + off);
 #endif
   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);
+              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);
-  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_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++;
+  }
   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;
 }
 
@@ -460,16 +434,15 @@ GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te)
  *        prior to completion and prior to an internal error,
  *        both "*uri" and "*emsg" will be set to NULL).
  */
-void GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder *te,
-                                    struct GNUNET_FS_Uri **uri,
-                                    char **emsg)
+void
+GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder *te,
+                               struct GNUNET_FS_Uri **uri, char **emsg)
 {
   GNUNET_assert (GNUNET_NO == te->in_next);
   if (uri != NULL)
     *uri = te->uri;
-  else
-    if (NULL != te->uri)
-      GNUNET_FS_uri_destroy (te->uri);
+  else if (NULL != te->uri)
+    GNUNET_FS_uri_destroy (te->uri);
   if (emsg != NULL)
     *emsg = te->emsg;
   else
diff --git a/src/fs/fs_tree.h b/src/fs/fs_tree.h
index 5cd4d0afe..c2b7de48c 100644
--- a/src/fs/fs_tree.h
+++ b/src/fs/fs_tree.h
@@ -40,8 +40,7 @@
  * @param flen file length for which to compute the depth
  * @return depth of the tree, always > 0.  A depth of 1 means only a DBLOCK.
  */
-unsigned int
-GNUNET_FS_compute_depth (uint64_t flen);
+unsigned int GNUNET_FS_compute_depth (uint64_t flen);
 
 
 /**
@@ -53,8 +52,7 @@ GNUNET_FS_compute_depth (uint64_t flen);
  * @param depth depth of the block.  depth==0 is a DBLOCK.
  * @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);
+uint64_t GNUNET_FS_tree_compute_tree_size (unsigned int depth);
 
 
 /**
@@ -70,8 +68,7 @@ GNUNET_FS_tree_compute_tree_size (unsigned int depth);
  */
 size_t
 GNUNET_FS_tree_calculate_block_size (uint64_t fsize,
-                                     uint64_t offset,
-                                     unsigned int depth);
+                                     uint64_t offset, unsigned int depth);
 
 
 /**
@@ -95,14 +92,14 @@ struct GNUNET_FS_TreeEncoder;
  * @param block the (encrypted) block
  * @param block_size size of block (in bytes)
  */
-typedef void (*GNUNET_FS_TreeBlockProcessor)(void *cls,
-                                             const struct ContentHashKey *chk,
-                                             uint64_t offset,
-                                             unsigned int depth,
-                                             enum GNUNET_BLOCK_Type type,
-                                             const void *block,
-                                             uint16_t block_size);
-                                             
+typedef void (*GNUNET_FS_TreeBlockProcessor) (void *cls,
+                                              const struct ContentHashKey * chk,
+                                              uint64_t offset,
+                                              unsigned int depth,
+                                              enum GNUNET_BLOCK_Type type,
+                                              const void *block,
+                                              uint16_t block_size);
+
 
 /**
  * Function called with information about our
@@ -114,12 +111,12 @@ typedef void (*GNUNET_FS_TreeBlockProcessor)(void *cls,
  * @param pt_size size of pt_block
  * @param depth depth of the block in the tree, 0 for DBLOCKS
  */
-typedef void (*GNUNET_FS_TreeProgressCallback)(void *cls,
-                                               uint64_t offset,
-                                               const void *pt_block,
-                                               size_t pt_size,
-                                               unsigned int depth);
-                                               
+typedef void (*GNUNET_FS_TreeProgressCallback) (void *cls,
+                                                uint64_t offset,
+                                                const void *pt_block,
+                                                size_t pt_size,
+                                                unsigned int depth);
+
 
 /**
  * Initialize a tree encoder.  This function will call "proc" and
@@ -139,14 +136,18 @@ typedef void (*GNUNET_FS_TreeProgressCallback)(void *cls,
  * @param cont function to call when done
  * @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_Task cont);
+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_Task
+                                                             cont);
 
 
 /**
@@ -157,7 +158,7 @@ GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h,
  *
  * @param te tree encoder to use
  */
-void GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te);
+void GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder *te);
 
 
 /**
@@ -172,8 +173,7 @@ void GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te);
  *        both "*uri" and "*emsg" will be set to NULL).
  */
 void GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder *te,
-                                    struct GNUNET_FS_Uri **uri,
-                                    char **emsg);
+                                    struct GNUNET_FS_Uri **uri, char **emsg);
 
 
 #if 0
@@ -187,9 +187,8 @@ void GNUNET_FS_tree_encoder_finish (struct GNUNET_FS_TreeEncoder *te,
  * @param data set to the resume data
  * @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);
+void GNUNET_FS_tree_encoder_resume_get_data (const struct GNUNET_FS_TreeEncoder
+                                             *te, void **data, size_t * size);
 
 
 /**
@@ -201,8 +200,7 @@ void GNUNET_FS_tree_encoder_resume_get_data (const struct GNUNET_FS_TreeEncoder
  * @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);
+                                    const void *data, size_t size);
 #endif
 
 #endif
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index 83db96932..130b2eae2 100644
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -47,31 +47,22 @@
  * @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;
 }
 
@@ -86,22 +77,19 @@ unindex_reader (void *cls,
  */
 void
 GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
-                                struct GNUNET_FS_UnindexContext *uc,
-                                uint64_t offset)
+                                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);
-  pi->value.unindex.duration = GNUNET_TIME_absolute_get_duration (uc->start_time);
+  pi->value.unindex.eta
+      = GNUNET_TIME_calculate_eta (uc->start_time, offset, uc->file_size);
+  pi->value.unindex.duration =
+      GNUNET_TIME_absolute_get_duration (uc->start_time);
   pi->value.unindex.completed = offset;
-  uc->client_info 
-    = uc->h->upcb (uc->h->upcb_cls,
-                   pi);
+  uc->client_info = uc->h->upcb (uc->h->upcb_cls, pi);
 
 }
 
@@ -118,10 +106,8 @@ GNUNET_FS_unindex_make_status_ (struct GNUNET_FS_ProgressInfo *pi,
  */
 static void
 unindex_progress (void *cls,
-                  uint64_t offset,
-                  const void *pt_block,
-                  size_t pt_size,
-                  unsigned int depth)
+                  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;
@@ -133,7 +119,7 @@ unindex_progress (void *cls,
   pi.value.unindex.specifics.progress.depth = depth;
   GNUNET_FS_unindex_make_status_ (&pi, uc, offset);
 }
-                                               
+
 
 /**
  * We've encountered an error during
@@ -145,7 +131,7 @@ static void
 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;
@@ -162,20 +148,19 @@ 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,
-              const char *msg)
+process_cont (void *cls, int success, const char *msg)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
+
   if (success == GNUNET_SYSERR)
-    {
-      uc->emsg = GNUNET_strdup (msg);
-      signal_unindex_error (uc);
-      return;
-    }  
+  {
+    uc->emsg = GNUNET_strdup (msg);
+    signal_unindex_error (uc);
+    return;
+  }
 #if DEBUG_UNINDEX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Datastore REMOVE operation succeeded\n");
+              "Datastore REMOVE operation succeeded\n");
 #endif
   GNUNET_FS_tree_encoder_next (uc->tc);
 }
@@ -195,14 +180,13 @@ process_cont (void *cls,
  * @param block the (encrypted) block
  * @param block_size size of block (in bytes)
  */
-static void 
+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)
+                 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;
@@ -210,29 +194,27 @@ unindex_process (void *cls,
   struct OnDemandBlock odb;
 
   if (type != GNUNET_BLOCK_TYPE_FS_DBLOCK)
-    {
-      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;
-    }
+  {
+    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;
+  }
 #if DEBUG_UNINDEX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending REMOVE request to DATASTORE service\n");
+              "Sending REMOVE request to DATASTORE service\n");
 #endif
   GNUNET_DATASTORE_remove (uc->dsh,
-                           &chk->query,
-                           size,
-                           data,
-                           -2, 1,
-                           GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                           &process_cont,
-                           uc);
+                           &chk->query,
+                           size,
+                           data,
+                           -2, 1,
+                           GNUNET_CONSTANTS_SERVICE_TIMEOUT, &process_cont, uc);
 }
 
 
@@ -244,41 +226,41 @@ unindex_process (void *cls,
  * @param msg NULL on timeout, otherwise the response
  */
 static void
-process_fs_response (void *cls,
-                     const struct GNUNET_MessageHeader *msg)
+process_fs_response (void *cls, const struct GNUNET_MessageHeader *msg)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   struct GNUNET_FS_ProgressInfo pi;
 
   if (uc->client != NULL)
-    {
-      GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
-      uc->client = NULL;
-    }
-  if (uc->state != UNINDEX_STATE_FS_NOTIFY) 
-    {
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg = GNUNET_strdup (_("Unexpected time for a response from `fs' service."));
-      GNUNET_FS_unindex_sync_ (uc);
-      signal_unindex_error (uc);
-      return;
-    }
+  {
+    GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
+    uc->client = NULL;
+  }
+  if (uc->state != UNINDEX_STATE_FS_NOTIFY)
+  {
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg =
+        GNUNET_strdup (_("Unexpected time for a response from `fs' service."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
   if (NULL == msg)
-    {
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg = GNUNET_strdup (_("Timeout waiting for `fs' service."));
-      GNUNET_FS_unindex_sync_ (uc);
-      signal_unindex_error (uc);
-      return;
-    }
-  if (ntohs(msg->type) != GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK)
-    {
-      uc->state = UNINDEX_STATE_ERROR;
-      uc->emsg = GNUNET_strdup (_("Invalid response from `fs' service."));
-      GNUNET_FS_unindex_sync_ (uc);
-      signal_unindex_error (uc);                            
-      return;      
-    }
+  {
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg = GNUNET_strdup (_("Timeout waiting for `fs' service."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
+  if (ntohs (msg->type) != GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK)
+  {
+    uc->state = UNINDEX_STATE_ERROR;
+    uc->emsg = GNUNET_strdup (_("Invalid response from `fs' service."));
+    GNUNET_FS_unindex_sync_ (uc);
+    signal_unindex_error (uc);
+    return;
+  }
   uc->state = UNINDEX_STATE_COMPLETE;
   pi.status = GNUNET_FS_STATUS_UNINDEX_COMPLETED;
   pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
@@ -295,8 +277,7 @@ process_fs_response (void *cls,
  * @param tc not used
  */
 static void
-unindex_finish (void *cls,
-                const struct GNUNET_SCHEDULER_TaskContext *tc)
+unindex_finish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_UnindexContext *uc = cls;
   char *emsg;
@@ -304,13 +285,8 @@ unindex_finish (void *cls,
   struct UnindexMessage req;
 
   /* generate final progress message */
-  unindex_progress (uc, 
-                    uc->file_size,
-                    NULL,
-                    0, 0);
-  GNUNET_FS_tree_encoder_finish (uc->tc,
-                                 &uri,
-                                 &emsg);
+  unindex_progress (uc, uc->file_size, NULL, 0, 0);
+  GNUNET_FS_tree_encoder_finish (uc->tc, &uri, &emsg);
   uc->tc = NULL;
   if (uri != NULL)
     GNUNET_FS_uri_destroy (uri);
@@ -320,31 +296,31 @@ unindex_finish (void *cls,
   uc->dsh = NULL;
   uc->state = UNINDEX_STATE_FS_NOTIFY;
   GNUNET_FS_unindex_sync_ (uc);
-  uc->client = GNUNET_CLIENT_connect ("fs",
-                                      uc->h->cfg);
+  uc->client = GNUNET_CLIENT_connect ("fs", uc->h->cfg);
   if (uc->client == NULL)
-    {
-      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;
-    }
+  {
+    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;
+  }
 #if DEBUG_UNINDEX
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Sending UNINDEX message to FS service\n");
+              "Sending UNINDEX message to FS service\n");
 #endif
   req.header.size = htons (sizeof (struct UnindexMessage));
   req.header.type = htons (GNUNET_MESSAGE_TYPE_FS_UNINDEX);
   req.reserved = 0;
   req.file_id = uc->file_id;
-  GNUNET_break (GNUNET_OK == 
-                GNUNET_CLIENT_transmit_and_get_response (uc->client,
-                                                         &req.header,
-                                                         GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                                         GNUNET_YES,
-                                                         &process_fs_response,
-                                                         uc));
+  GNUNET_break (GNUNET_OK ==
+                GNUNET_CLIENT_transmit_and_get_response (uc->client,
+                                                         &req.header,
+                                                         GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                                                         GNUNET_YES,
+                                                         &process_fs_response,
+                                                         uc));
 }
 
 
@@ -353,38 +329,36 @@ unindex_finish (void *cls,
  *
  * @param uc context for the unindex operation.
  */
-void 
+void
 GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
 {
   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_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_finish);
+                                          uc->file_size,
+                                          uc,
+                                          &unindex_reader,
+                                          &unindex_process,
+                                          &unindex_progress, &unindex_finish);
   GNUNET_FS_tree_encoder_next (uc->tc);
 }
 
@@ -396,26 +370,25 @@ GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
  * @param cls closure, unindex context
  * @param file_id computed hash, NULL on error
  */
-void 
-GNUNET_FS_unindex_process_hash_ (void *cls,
-                                 const GNUNET_HashCode *file_id)
+void
+GNUNET_FS_unindex_process_hash_ (void *cls, const 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;
-    }
+  if (uc->state != UNINDEX_STATE_HASHING)
+  {
+    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);
@@ -436,37 +409,35 @@ GNUNET_FS_unindex_signal_suspend_ (void *cls)
   struct GNUNET_FS_ProgressInfo pi;
 
   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 (uc->client != NULL)
-    {
-      GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
-      uc->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
+    uc->client = 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, 
-                                     NULL);
-      uc->tc = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (uc->tc, NULL, NULL);
+    uc->tc = NULL;
+  }
   if (uc->fh != NULL)
-    {
-      GNUNET_DISK_file_close (uc->fh);
-      uc->fh = NULL;
-    }
+  {
+    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_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);
@@ -485,17 +456,13 @@ GNUNET_FS_unindex_signal_suspend_ (void *cls)
  */
 struct GNUNET_FS_UnindexContext *
 GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h,
-                         const char *filename,
-                         void *cctx)
+                         const char *filename, void *cctx)
 {
   struct GNUNET_FS_UnindexContext *ret;
   struct GNUNET_FS_ProgressInfo pi;
   uint64_t size;
 
-  if (GNUNET_OK !=
-      GNUNET_DISK_file_size (filename,
-                             &size,
-                             GNUNET_YES))
+  if (GNUNET_OK != GNUNET_DISK_file_size (filename, &size, GNUNET_YES))
     return NULL;
   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_UnindexContext));
   ret->h = h;
@@ -508,13 +475,10 @@ GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h,
   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
   GNUNET_FS_unindex_make_status_ (&pi, ret, 0);
   ret->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                      filename,
-                                      HASHING_BLOCKSIZE,
-                                      &GNUNET_FS_unindex_process_hash_,
-                                      ret);
-  ret->top = GNUNET_FS_make_top (h,
-                                 &GNUNET_FS_unindex_signal_suspend_,
-                                 ret);
+                                      filename,
+                                      HASHING_BLOCKSIZE,
+                                      &GNUNET_FS_unindex_process_hash_, ret);
+  ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_unindex_signal_suspend_, ret);
   return ret;
 }
 
@@ -526,48 +490,47 @@ GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h,
  */
 void
 GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc)
-{  
+{
   struct GNUNET_FS_ProgressInfo pi;
-  
+
   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 (uc->client != NULL)
-    {
-      GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
-      uc->client = NULL;
-    }
+  {
+    GNUNET_CLIENT_disconnect (uc->client, GNUNET_NO);
+    uc->client = 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, 
-                                     NULL);
-      uc->tc = NULL;
-    }
+  {
+    GNUNET_FS_tree_encoder_finish (uc->tc, NULL, NULL);
+    uc->tc = NULL;
+  }
   if (uc->fh != NULL)
-    {
-      GNUNET_DISK_file_close (uc->fh);
-      uc->fh = NULL;
-    }
+  {
+    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_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 (uc);
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index 4b249d6bf..5d5d24ca8 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -91,33 +91,33 @@
  * @param uri uri to convert to a unique key
  * @param key wherer to store the unique key
  */
-void 
-GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri,
-                      GNUNET_HashCode * key)
+void
+GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri, GNUNET_HashCode * key)
 {
   switch (uri->type)
-    {
-    case chk:
-      *key = uri->data.chk.chk.query;
-      return;
-    case sks:
-      GNUNET_CRYPTO_hash (uri->data.sks.identifier,
-                          strlen (uri->data.sks.identifier), key);
-      break;
-    case ksk:
-      if (uri->data.ksk.keywordCount > 0)
-        GNUNET_CRYPTO_hash (uri->data.ksk.keywords[0],
-                            strlen (uri->data.ksk.keywords[0]), key);
-      break;
-    case loc:
-      GNUNET_CRYPTO_hash (&uri->data.loc.fi,
-                          sizeof (struct FileIdentifier) +
-                          sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), key);
-      break;
-    default:
-      memset (key, 0, sizeof (GNUNET_HashCode));
-      break;
-    }
+  {
+  case chk:
+    *key = uri->data.chk.chk.query;
+    return;
+  case sks:
+    GNUNET_CRYPTO_hash (uri->data.sks.identifier,
+                        strlen (uri->data.sks.identifier), key);
+    break;
+  case ksk:
+    if (uri->data.ksk.keywordCount > 0)
+      GNUNET_CRYPTO_hash (uri->data.ksk.keywords[0],
+                          strlen (uri->data.ksk.keywords[0]), key);
+    break;
+  case loc:
+    GNUNET_CRYPTO_hash (&uri->data.loc.fi,
+                        sizeof (struct FileIdentifier) +
+                        sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                        key);
+    break;
+  default:
+    memset (key, 0, sizeof (GNUNET_HashCode));
+    break;
+  }
 }
 
 
@@ -139,45 +139,45 @@ GNUNET_FS_uri_ksk_to_string_fancy (const struct GNUNET_FS_Uri *uri)
   unsigned int keywordCount;
 
   if ((uri == NULL) || (uri->type != ksk))
-    {
-      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++;
-    }
+  {
+    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];
-      if (NULL != strstr (&keyword[1], " "))
-        {
-          strcat (ret, "\"");
-          if (keyword[0] == '+')
-            strcat (ret, keyword);
-          else
-            strcat (ret, &keyword[1]);
-          strcat (ret, "\"");
-        }
+      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, "\"");
     }
+    else
+    {
+      if (keyword[0] == '+')
+        strcat (ret, keyword);
+      else
+        strcat (ret, &keyword[1]);
+    }
+    strcat (ret, " ");
+  }
   return ret;
 }
 
@@ -205,37 +205,37 @@ percent_decode_keyword (const char *in, char **emsg)
   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 (_("`%' 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 (_("`%' 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);
-    }
+  {
+    /* need to prefix with space */
+    ret = GNUNET_malloc (strlen (out) + 2);
+    strcpy (ret, " ");
+    strcat (ret, out);
+  }
   GNUNET_free (out);
   return ret;
 }
@@ -265,66 +265,64 @@ uri_ksk_parse (const char *s, char **emsg)
   GNUNET_assert (s != NULL);
   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;
-    }
+  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;
+  }
   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 (_("`++' not allowed in KSK URI")); 
-              return NULL;
-            }
-        }
+      saw_quote = (saw_quote + 1) % 2;
+      i += 3;
+      continue;
     }
-  if (saw_quote == 1)
+    if ((s[i] == '+') && (saw_quote == 0))
     {
-      *emsg = GNUNET_strdup (_("Quotes not balanced in KSK URI")); 
-      return NULL;
+      max++;
+      if (s[i - 1] == '+')
+      {
+        *emsg = GNUNET_strdup (_("`++' not allowed in KSK URI"));
+        return NULL;
+      }
     }
+  }
+  if (saw_quote == 1)
+  {
+    *emsg = GNUNET_strdup (_("Quotes not balanced in KSK URI"));
+    return NULL;
+  }
   iret = max;
   dup = GNUNET_strdup (s);
   keywords = GNUNET_malloc (max * sizeof (char *));
   for (i = slen - 1; i >= 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;
-          i += 3;
-          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;
+      i += 3;
+      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';
     }
+  }
   keywords[--max] = percent_decode_keyword (&dup[pos], emsg);
   if (NULL == keywords[max])
     goto CLEANUP;
   GNUNET_assert (max == 0);
   GNUNET_free (dup);
-  ret = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
+  ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   ret->type = ksk;
   ret->data.ksk.keywordCount = iret;
   ret->data.ksk.keywords = keywords;
@@ -355,30 +353,29 @@ uri_sks_parse (const char *s, char **emsg)
   char *identifier;
   unsigned int pos;
   size_t slen;
-  char enc[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
+  char enc[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
 
   GNUNET_assert (s != NULL);
   slen = strlen (s);
-  pos = strlen ( GNUNET_FS_URI_SKS_PREFIX);
-  if ( (slen <= pos) ||
-       (0 != strncmp (s, GNUNET_FS_URI_SKS_PREFIX,
-                      pos) ) )
-    return NULL; /* not an SKS URI */
-  if ( (slen < pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) ||
-       (s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '/') )
-    {
-      *emsg = GNUNET_strdup (_("Malformed SKS URI"));
-      return NULL;
-    }
-  memcpy (enc, &s[pos], sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
-  enc[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)-1] = '\0';
+  pos = strlen (GNUNET_FS_URI_SKS_PREFIX);
+  if ((slen <= pos) || (0 != strncmp (s, GNUNET_FS_URI_SKS_PREFIX, pos)))
+    return NULL;                /* not an SKS URI */
+  if ((slen < pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)) ||
+      (s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '/'))
+  {
+    *emsg = GNUNET_strdup (_("Malformed SKS URI"));
+    return NULL;
+  }
+  memcpy (enc, &s[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+  enc[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
   if (GNUNET_OK != GNUNET_CRYPTO_hash_from_string (enc, &namespace))
-    {
-      *emsg = GNUNET_strdup (_("Malformed SKS URI"));
-      return NULL;
-    }
-  identifier = GNUNET_strdup (&s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)]);
-  ret = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
+  {
+    *emsg = GNUNET_strdup (_("Malformed SKS URI"));
+    return NULL;
+  }
+  identifier =
+      GNUNET_strdup (&s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)]);
+  ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   ret->type = sks;
   ret->data.sks.namespace = namespace;
   ret->data.sks.identifier = identifier;
@@ -403,46 +400,43 @@ uri_chk_parse (const char *s, char **emsg)
   unsigned int pos;
   unsigned long long flen;
   size_t slen;
-  char h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
-  char h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
+  char h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
+  char h2[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
 
   if (NULL == s)
     return NULL;
   GNUNET_assert (s != NULL);
   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) ) )
-    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"));
-      return NULL;
-    }
-  memcpy (h1,
-          &s[pos], 
-          sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
-  h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)-1] = '\0';
+  if ((slen < pos + 2 * sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) + 1) ||
+      (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"));
+    return NULL;
+  }
+  memcpy (h1, &s[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+  h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
   memcpy (h2,
-          &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
-          sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
-  h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)-1] = '\0';
-  
+          &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)) ||
+                                                    &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"));
-      return NULL;
-    }
+                                                    &fi.chk.query)) ||
+      (1 !=
+       SSCANF (&s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
+               "%llu", &flen)))
+  {
+    *emsg = GNUNET_strdup (_("Malformed CHK URI"));
+    return NULL;
+  }
   fi.file_length = GNUNET_htonll (flen);
-  ret = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
+  ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   ret->type = chk;
   ret->data.chk = fi;
   return ret;
@@ -499,16 +493,16 @@ enc2bin (const char *input, void *data, size_t size)
   hbits = 0;
   len = 0;
   for (pos = 0; pos < size; pos++)
+  {
+    while (hbits < 8)
     {
-      while (hbits < 8)
-        {
-          bits |= (c2v (input[len++]) << hbits);
-          hbits += 6;
-        }
-      (((unsigned char *) data)[pos]) = (unsigned char) bits;
-      bits >>= 8;
-      hbits -= 8;
+      bits |= (c2v (input[len++]) << hbits);
+      hbits += 6;
     }
+    (((unsigned char *) data)[pos]) = (unsigned char) bits;
+    bits >>= 8;
+    hbits -= 8;
+  }
   return len;
 }
 
@@ -520,14 +514,14 @@ enc2bin (const char *input, void *data, size_t size)
  * verify the signature of a location
  * URI.
  */
-struct LocUriAssembly 
+struct LocUriAssembly
 {
   struct GNUNET_CRYPTO_RsaSignaturePurpose purpose;
 
   struct GNUNET_TIME_AbsoluteNBO exptime;
 
   struct FileIdentifier fi;
-  
+
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded peer;
 
 };
@@ -547,8 +541,8 @@ static struct GNUNET_FS_Uri *
 uri_loc_parse (const char *s, char **emsg)
 {
   struct GNUNET_FS_Uri *uri;
-  char h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
-  char h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)];
+  char h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
+  char h2[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded)];
   unsigned int pos;
   unsigned int npos;
   unsigned long long exptime;
@@ -561,95 +555,92 @@ uri_loc_parse (const char *s, char **emsg)
 
   GNUNET_assert (s != NULL);
   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) ) )
-    return NULL; /* not an SKS URI */
-  if ( (s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '.') ||
-       (s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2 - 1] != '.') )
-    {
-      *emsg = GNUNET_strdup (_("SKS URI malformed"));
-      return NULL;
-    }
-  memcpy (h1,
-          &s[pos], 
-          sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
-  h1[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)-1] = '\0';
+  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)))
+    return NULL;                /* not an SKS URI */
+  if ((s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] != '.') ||
+      (s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2 - 1] != '.'))
+  {
+    *emsg = GNUNET_strdup (_("SKS URI malformed"));
+    return NULL;
+  }
+  memcpy (h1, &s[pos], sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded));
+  h1[sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) - 1] = '\0';
   memcpy (h2,
-          &s[pos + sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)],
-          sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded));
-  h2[sizeof(struct GNUNET_CRYPTO_HashAsciiEncoded)-1] = '\0';
-  
+          &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)) ||
+                                                    &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 (_("SKS URI malformed"));
-      return NULL;
-    }
+                                                    &ass.fi.chk.query)) ||
+      (1 !=
+       SSCANF (&s[pos + sizeof (struct GNUNET_CRYPTO_HashAsciiEncoded) * 2],
+               "%llu", &flen)))
+  {
+    *emsg = GNUNET_strdup (_("SKS URI malformed"));
+    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 (_("SKS URI malformed"));
-      goto ERR;
-    }
+  {
+    *emsg = GNUNET_strdup (_("SKS URI malformed"));
+    goto ERR;
+  }
   npos++;
-  ret = enc2bin (&s[npos], 
-                 &ass.peer,
-                 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+  ret = enc2bin (&s[npos],
+                 &ass.peer,
+                 sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
   if (ret == -1)
-    {
-      *emsg = GNUNET_strdup (_("SKS URI malformed (could not decode public key)"));
-      goto ERR;
-    }
+  {
+    *emsg =
+        GNUNET_strdup (_("SKS URI malformed (could not decode public key)"));
+    goto ERR;
+  }
   npos += ret;
   if (s[npos++] != '.')
-    {
-      *emsg = GNUNET_strdup (_("SKS URI malformed (could not find signature)"));
-      goto ERR;
-    }
-  ret = enc2bin (&s[npos],
-                 &sig,
-                 sizeof (struct GNUNET_CRYPTO_RsaSignature));
+  {
+    *emsg = GNUNET_strdup (_("SKS URI malformed (could not find signature)"));
+    goto ERR;
+  }
+  ret = enc2bin (&s[npos], &sig, sizeof (struct GNUNET_CRYPTO_RsaSignature));
   if (ret == -1)
-    {
-      *emsg = GNUNET_strdup (_("SKS URI malformed (could not decode signature)"));
-      goto ERR;
-    }
-    npos += ret;
+  {
+    *emsg = GNUNET_strdup (_("SKS URI malformed (could not decode signature)"));
+    goto ERR;
+  }
+  npos += ret;
   if (s[npos++] != '.')
-    {
-      *emsg = GNUNET_strdup (_("SKS URI malformed"));
-      goto ERR;
-    }
+  {
+    *emsg = GNUNET_strdup (_("SKS URI malformed"));
+    goto ERR;
+  }
   if (1 != SSCANF (&s[npos], "%llu", &exptime))
-    {
-      *emsg = GNUNET_strdup (_("SKS 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 (_
+                       ("SKS 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 = exptime;
   ass.exptime = GNUNET_TIME_absolute_hton (et);
-  if (GNUNET_OK != 
+  if (GNUNET_OK !=
       GNUNET_CRYPTO_rsa_verify (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT,
-                                &ass.purpose,
-                                &sig,
-                                &ass.peer))
-    {
-      *emsg = GNUNET_strdup (_("SKS URI malformed (signature failed validation)"));
-      goto ERR;
-    }
-  uri = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
+                                &ass.purpose, &sig, &ass.peer))
+  {
+    *emsg =
+        GNUNET_strdup (_("SKS URI malformed (signature failed validation)"));
+    goto ERR;
+  }
+  uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   uri->type = loc;
   uri->data.loc.fi = ass.fi;
   uri->data.loc.peer = ass.peer;
@@ -670,8 +661,7 @@ 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;
@@ -679,10 +669,10 @@ GNUNET_FS_uri_parse (const char *uri,
   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"));
@@ -697,29 +687,28 @@ GNUNET_FS_uri_parse (const char *uri,
  *
  * @param uri uri to free
  */
-void 
+void
 GNUNET_FS_uri_destroy (struct GNUNET_FS_Uri *uri)
 {
   unsigned int i;
 
   GNUNET_assert (uri != NULL);
   switch (uri->type)
-    {
-    case 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 sks:
-      GNUNET_free (uri->data.sks.identifier);
-      break;
-    case loc:
-      break;
-    default:
-      /* do nothing */
-      break;
-    }
+  {
+  case 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 sks:
+    GNUNET_free (uri->data.sks.identifier);
+    break;
+  case loc:
+    break;
+  default:
+    /* do nothing */
+    break;
+  }
   GNUNET_free (uri);
 }
 
@@ -729,7 +718,7 @@ GNUNET_FS_uri_destroy (struct GNUNET_FS_Uri *uri)
  * @param uri ksk uri to get the number of keywords from
  * @return 0 if this is not a keyword URI
  */
-unsigned int 
+unsigned int
 GNUNET_FS_uri_ksk_get_keyword_count (const struct GNUNET_FS_Uri *uri)
 {
   if (uri->type != ksk)
@@ -747,10 +736,10 @@ GNUNET_FS_uri_ksk_get_keyword_count (const struct GNUNET_FS_Uri *uri)
  * @return -1 if this is not a keyword URI, otherwise number of
  *   keywords iterated over until iterator aborted
  */
-int 
+int
 GNUNET_FS_uri_ksk_get_keywords (const struct GNUNET_FS_Uri *uri,
-                                GNUNET_FS_KeywordIterator iterator, 
-                                void *iterator_cls)
+                                GNUNET_FS_KeywordIterator iterator,
+                                void *iterator_cls)
 {
   unsigned int i;
   char *keyword;
@@ -760,15 +749,13 @@ GNUNET_FS_uri_ksk_get_keywords (const struct GNUNET_FS_Uri *uri,
   if (iterator == NULL)
     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;
 }
 
@@ -783,8 +770,7 @@ GNUNET_FS_uri_ksk_get_keywords (const struct GNUNET_FS_Uri *uri,
  */
 void
 GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri,
-                               const char *keyword,
-                               int is_mandatory)
+                               const char *keyword, int is_mandatory)
 {
   unsigned int i;
   const char *old;
@@ -792,17 +778,13 @@ GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri,
 
   GNUNET_assert (uri->type == 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);
 }
 
 
@@ -815,25 +797,25 @@ GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri,
  */
 void
 GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri *uri,
-                                  const char *keyword)
+                                  const char *keyword)
 {
   unsigned int i;
   char *old;
 
   GNUNET_assert (uri->type == 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;
     }
+  }
 }
 
 
@@ -846,13 +828,13 @@ GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri *uri,
  */
 int
 GNUNET_FS_uri_loc_get_peer_identity (const struct GNUNET_FS_Uri *uri,
-                                     struct GNUNET_PeerIdentity * peer)
+                                     struct GNUNET_PeerIdentity *peer)
 {
   if (uri->type != loc)
     return GNUNET_SYSERR;
   GNUNET_CRYPTO_hash (&uri->data.loc.peer,
-                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
-                      &peer->hashPubKey);
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &peer->hashPubKey);
   return GNUNET_OK;
 }
 
@@ -867,7 +849,7 @@ struct GNUNET_TIME_Absolute
 GNUNET_FS_uri_loc_get_expiration (const struct GNUNET_FS_Uri *uri)
 {
   GNUNET_assert (uri->type == loc);
-  return uri->data.loc.expirationTime; 
+  return uri->data.loc.expirationTime;
 }
 
 
@@ -902,11 +884,11 @@ GNUNET_FS_uri_loc_get_uri (const struct GNUNET_FS_Uri *uri)
  */
 struct GNUNET_FS_Uri *
 GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
-                          const struct GNUNET_CONFIGURATION_Handle *cfg,
-                          struct GNUNET_TIME_Absolute expiration_time)
+                          const struct GNUNET_CONFIGURATION_Handle *cfg,
+                          struct GNUNET_TIME_Absolute expiration_time)
 {
   struct GNUNET_FS_Uri *uri;
-  struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;  
+  struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
   char *keyfile;
   struct LocUriAssembly ass;
@@ -915,27 +897,24 @@ GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
     return NULL;
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                               "GNUNETD",
-                                               "HOSTKEY", &keyfile))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _
-                  ("Lacking key configuration settings.\n"));
-      return NULL;
-    }
+                                               "GNUNETD", "HOSTKEY", &keyfile))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Lacking key configuration settings.\n"));
+    return NULL;
+  }
   my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
   if (my_private_key == NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Could not access hostkey file `%s'.\n"),
-                  keyfile);
-      GNUNET_free (keyfile);
-      return NULL;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Could not access hostkey file `%s'.\n"), keyfile);
+    GNUNET_free (keyfile);
+    return NULL;
+  }
   GNUNET_free (keyfile);
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
-  ass.purpose.size = htonl(sizeof(struct LocUriAssembly));
-  ass.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
+  ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
+  ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
   ass.exptime = GNUNET_TIME_absolute_hton (expiration_time);
   ass.fi = baseUri->data.chk;
   ass.peer = my_public_key;
@@ -945,9 +924,9 @@ GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
   uri->data.loc.expirationTime = expiration_time;
   uri->data.loc.peer = my_public_key;
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CRYPTO_rsa_sign (my_private_key,
-                                         &ass.purpose,
-                                         &uri->data.loc.contentSignature));
+                 GNUNET_CRYPTO_rsa_sign (my_private_key,
+                                         &ass.purpose,
+                                         &uri->data.loc.contentSignature));
   GNUNET_CRYPTO_rsa_key_free (my_private_key);
   return uri;
 }
@@ -963,19 +942,15 @@ GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
  */
 struct GNUNET_FS_Uri *
 GNUNET_FS_uri_sks_create (struct GNUNET_FS_Namespace *ns,
-                          const char *id,
-                          char **emsg)
+                          const char *id, char **emsg)
 {
   struct GNUNET_FS_Uri *ns_uri;
   struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pk;
-              
+
   ns_uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   ns_uri->type = sks;
-  GNUNET_CRYPTO_rsa_key_get_public (ns->key,
-                                    &pk);
-  GNUNET_CRYPTO_hash (&pk,
-                      sizeof (pk),
-                      &ns_uri->data.sks.namespace);
+  GNUNET_CRYPTO_rsa_key_get_public (ns->key, &pk);
+  GNUNET_CRYPTO_hash (&pk, sizeof (pk), &ns_uri->data.sks.namespace);
   ns_uri->data.sks.identifier = GNUNET_strdup (id);
   return ns_uri;
 }
@@ -989,11 +964,10 @@ GNUNET_FS_uri_sks_create (struct GNUNET_FS_Namespace *ns,
  * @return an FS URI for the given namespace and identifier
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_sks_create_from_nsid (GNUNET_HashCode *nsid,
-                                    const char *id)
+GNUNET_FS_uri_sks_create_from_nsid (GNUNET_HashCode * nsid, const char *id)
 {
   struct GNUNET_FS_Uri *ns_uri;
-              
+
   ns_uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   ns_uri->type = sks;
   ns_uri->data.sks.namespace = *nsid;
@@ -1019,60 +993,60 @@ canonicalize_keyword (const char *in)
   wpos = ret;
   rpos = in;
   while ('\0' != *rpos)
+  {
+    switch (tolower ((unsigned char) *rpos))
     {
-      switch (tolower( (unsigned char) *rpos))
-        {
-        case 'a':
-        case 'e':
-        case 'i':
-        case 'o':
-        case 'u':
-        case ' ':
-        case '\t':
-        case '\n':
-        case '\r':
-          /* skip characters listed above */
-          break;
-        case 'b':
-        case 'c':
-        case 'd':
-        case 'f':
-        case 'g':
-        case 'h':
-        case 'j':
-        case 'k':
-        case 'l':
-        case 'm':
-        case 'n':
-        case 'p':
-        case 'r':
-        case 's':
-        case 't':
-        case 'v':
-        case 'w':
-        case 'x':
-        case 'y':
-        case 'z':
-          /* convert characters listed above to lower case */
-          *wpos = tolower( (unsigned char)*rpos);
-          wpos++;
-          break;
-        case '!':
-        case '.':
-        case '?':
-        case '-':
-          /* keep characters listed above without changes */
-          *wpos = *rpos;
-          wpos++;
-          break;
-        default:
-          /* replace characters listed above with '_' */
-          *wpos = '_';
-          wpos++;
-          break;
-        }
-      rpos++;
+    case 'a':
+    case 'e':
+    case 'i':
+    case 'o':
+    case 'u':
+    case ' ':
+    case '\t':
+    case '\n':
+    case '\r':
+      /* skip characters listed above */
+      break;
+    case 'b':
+    case 'c':
+    case 'd':
+    case 'f':
+    case 'g':
+    case 'h':
+    case 'j':
+    case 'k':
+    case 'l':
+    case 'm':
+    case 'n':
+    case 'p':
+    case 'r':
+    case 's':
+    case 't':
+    case 'v':
+    case 'w':
+    case 'x':
+    case 'y':
+    case 'z':
+      /* convert characters listed above to lower case */
+      *wpos = tolower ((unsigned char) *rpos);
+      wpos++;
+      break;
+    case '!':
+    case '.':
+    case '?':
+    case '-':
+      /* keep characters listed above without changes */
+      *wpos = *rpos;
+      wpos++;
+      break;
+    default:
+      /* replace characters listed above with '_' */
+      *wpos = '_';
+      wpos++;
+      break;
     }
+    rpos++;
+  }
   return ret;
 }
 
@@ -1094,10 +1068,10 @@ GNUNET_FS_uri_ksk_canonicalize (const struct GNUNET_FS_Uri *uri)
   char **kl;
 
   kc = uri->data.ksk.keywordCount;
-  kl = GNUNET_malloc (kc*sizeof(char*));
-  for (i=0;i<kc;i++)
+  kl = GNUNET_malloc (kc * sizeof (char *));
+  for (i = 0; i < kc; i++)
     kl[i] = canonicalize_keyword (uri->data.ksk.keywords[i]);
-  ret = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
+  ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   ret->type = ksk;
   ret->data.ksk.keywordCount = kc;
   ret->data.ksk.keywords = kl;
@@ -1116,7 +1090,7 @@ GNUNET_FS_uri_ksk_canonicalize (const struct GNUNET_FS_Uri *uri)
  */
 struct GNUNET_FS_Uri *
 GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri *u1,
-                         const struct GNUNET_FS_Uri *u2)
+                         const struct GNUNET_FS_Uri *u2)
 {
   struct GNUNET_FS_Uri *ret;
   unsigned int kc;
@@ -1126,39 +1100,37 @@ GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri *u1,
   const char *kp;
   char **kl;
 
-  if ( (u1 == NULL) && (u2 == NULL) )
+  if ((u1 == NULL) && (u2 == NULL))
     return NULL;
   if (u1 == NULL)
     return GNUNET_FS_uri_dup (u2);
   if (u2 == NULL)
     return GNUNET_FS_uri_dup (u1);
-  if ( (u1->type != ksk) ||
-       (u2->type != ksk) )
-    {
-      GNUNET_break (0);
-      return NULL;
-    } 
+  if ((u1->type != ksk) || (u2->type != ksk))
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   kc = u1->data.ksk.keywordCount;
-  kl = GNUNET_malloc ((kc+u2->data.ksk.keywordCount)*sizeof(char*));
-  for (i=0;i<u1->data.ksk.keywordCount;i++)
+  kl = GNUNET_malloc ((kc + u2->data.ksk.keywordCount) * sizeof (char *));
+  for (i = 0; i < u1->data.ksk.keywordCount; 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_malloc (sizeof(struct GNUNET_FS_Uri));
+  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_malloc (sizeof (struct GNUNET_FS_Uri));
   ret->type = ksk;
   ret->data.ksk.keywordCount = kc;
   ret->data.ksk.keywords = kl;
@@ -1183,33 +1155,33 @@ GNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri)
   ret = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
   memcpy (ret, uri, sizeof (struct GNUNET_FS_Uri));
   switch (ret->type)
+  {
+  case ksk:
+    if (ret->data.ksk.keywordCount >=
+        GNUNET_MAX_MALLOC_CHECKED / sizeof (char *))
     {
-    case 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_malloc (ret->data.ksk.keywordCount * sizeof (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 sks:
-      ret->data.sks.identifier = GNUNET_strdup (uri->data.sks.identifier);
-      break;
-    case loc:
-      break;
-    default:
-      break;
+      GNUNET_break (0);
+      GNUNET_free (ret);
+      return NULL;
     }
+    if (ret->data.ksk.keywordCount > 0)
+    {
+      ret->data.ksk.keywords
+          = GNUNET_malloc (ret->data.ksk.keywordCount * sizeof (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 sks:
+    ret->data.sks.identifier = GNUNET_strdup (uri->data.sks.identifier);
+    break;
+  case loc:
+    break;
+  default:
+    break;
+  }
   return ret;
 }
 
@@ -1232,8 +1204,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;
@@ -1244,67 +1215,67 @@ GNUNET_FS_uri_ksk_create (const char *keywords,
   int saw_quote;
 
   if (keywords == NULL)
-    {
-      *emsg = GNUNET_strdup (_("No keywords specified!\n"));
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+    *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;
-    }
+  {
+    GNUNET_free (searchString);
+    *emsg = GNUNET_strdup (_("Number of double-quotes not balanced!\n"));
+    return NULL;
+  }
   keywordarr = GNUNET_malloc (num_Words * sizeof (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_FS_uri_ksk_create_from_args (num_Words,
+                                          (const char **) keywordarr);
   GNUNET_free (keywordarr);
   GNUNET_free (searchString);
   return uri;
@@ -1329,8 +1300,7 @@ GNUNET_FS_uri_ksk_create (const char *keywords,
  *  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;
@@ -1343,12 +1313,13 @@ GNUNET_FS_uri_ksk_create_from_args (unsigned int argc,
   if (argc == 0)
     return NULL;
   /* allow URI to be given as one and only keyword and
-     handle accordingly */
+   * 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_malloc (sizeof (struct GNUNET_FS_Uri));
@@ -1356,24 +1327,24 @@ GNUNET_FS_uri_ksk_create_from_args (unsigned int argc,
   uri->data.ksk.keywordCount = argc;
   uri->data.ksk.keywords = GNUNET_malloc (argc * sizeof (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;
 }
 
@@ -1385,9 +1356,9 @@ GNUNET_FS_uri_ksk_create_from_args (unsigned int argc,
  * @param u2 the other URI
  * @return GNUNET_YES if the URIs are equal
  */
-int 
+int
 GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
-                          const struct GNUNET_FS_Uri *u2)
+                          const struct GNUNET_FS_Uri *u2)
 {
   int ret;
   unsigned int i;
@@ -1398,53 +1369,50 @@ GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1,
   if (u1->type != u2->type)
     return GNUNET_NO;
   switch (u1->type)
-    {
-    case chk:
-      if (0 == memcmp (&u1->data.chk,
-                       &u2->data.chk,
-                       sizeof (struct FileIdentifier)))
-        return GNUNET_YES;
-      return GNUNET_NO;
-    case sks:
-      if ((0 == memcmp (&u1->data.sks.namespace,
-                        &u2->data.sks.namespace,
-                        sizeof (GNUNET_HashCode))) &&
-          (0 == strcmp (u1->data.sks.identifier,
-                        u2->data.sks.identifier)))
-
-        return GNUNET_YES;
+  {
+  case chk:
+    if (0 == memcmp (&u1->data.chk,
+                     &u2->data.chk, sizeof (struct FileIdentifier)))
+      return GNUNET_YES;
+    return GNUNET_NO;
+  case sks:
+    if ((0 == memcmp (&u1->data.sks.namespace,
+                      &u2->data.sks.namespace,
+                      sizeof (GNUNET_HashCode))) &&
+        (0 == strcmp (u1->data.sks.identifier, u2->data.sks.identifier)))
+
+      return GNUNET_YES;
+    return GNUNET_NO;
+  case ksk:
+    if (u1->data.ksk.keywordCount != u2->data.ksk.keywordCount)
       return GNUNET_NO;
-    case ksk:
-      if (u1->data.ksk.keywordCount != u2->data.ksk.keywordCount)
-        return GNUNET_NO;
-      for (i = 0; i < u1->data.ksk.keywordCount; i++)
+    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 loc:
-      if (memcmp (&u1->data.loc,
-                  &u2->data.loc,
-                  sizeof (struct FileIdentifier) +
-                  sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
-                  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 loc:
+    if (memcmp (&u1->data.loc,
+                &u2->data.loc,
+                sizeof (struct FileIdentifier) +
+                sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded) +
+                sizeof (struct GNUNET_TIME_Absolute) +
+                sizeof (unsigned short) + sizeof (unsigned short)) != 0)
+      return GNUNET_NO;
+    return GNUNET_YES;
+  default:
+    return GNUNET_NO;
+  }
 }
 
 
@@ -1469,15 +1437,15 @@ GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri)
  * @param nsid where to store the ID of the namespace
  * @return GNUNET_OK on success
  */
-int 
+int
 GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri,
-                                 GNUNET_HashCode * nsid)
+                                 GNUNET_HashCode * nsid)
 {
-  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;
+  }
   *nsid = uri->data.sks.namespace;
   return GNUNET_OK;
 }
@@ -1493,10 +1461,10 @@ char *
 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;
-    }
+  {
+    GNUNET_break (0);
+    return NULL;
+  }
   return GNUNET_strdup (uri->data.sks.identifier);
 }
 
@@ -1511,7 +1479,7 @@ GNUNET_FS_uri_sks_get_content_id (const struct GNUNET_FS_Uri *uri)
  */
 char *
 GNUNET_FS_uri_sks_to_string_fancy (struct GNUNET_CONFIGURATION_Handle *cfg,
-                                   const struct GNUNET_FS_Uri *uri)
+                                   const struct GNUNET_FS_Uri *uri)
 {
   char *ret;
   char *name;
@@ -1521,10 +1489,7 @@ GNUNET_FS_uri_sks_to_string_fancy (struct GNUNET_CONFIGURATION_Handle *cfg,
   name = GNUNET_PSEUDONYM_id_to_name (cfg, &uri->data.sks.namespace);
   if (name == NULL)
     return GNUNET_FS_uri_to_string (uri);
-  GNUNET_asprintf (&ret,
-                   "%s: %s",
-                   name,
-                   uri->data.sks.identifier);
+  GNUNET_asprintf (&ret, "%s: %s", name, uri->data.sks.identifier);
   GNUNET_free (name);
   return ret;
 }
@@ -1536,17 +1501,17 @@ GNUNET_FS_uri_sks_to_string_fancy (struct GNUNET_CONFIGURATION_Handle *cfg,
  * @param uri the uri
  * @return GNUNET_YES if this is a KSK uri
  */
-int 
+int
 GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri)
 {
 #if EXTRA_CHECKS
   unsigned int i;
 
   if (uri->type == ksk)
-    {
-      for (i = uri->data.ksk.keywordCount - 1; i >= 0; i--)
-        GNUNET_assert (uri->data.ksk.keywords[i] != NULL);
-    }
+  {
+    for (i = uri->data.ksk.keywordCount - 1; i >= 0; i--)
+      GNUNET_assert (uri->data.ksk.keywords[i] != NULL);
+  }
 #endif
   return uri->type == ksk;
 }
@@ -1558,7 +1523,7 @@ GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri)
  * @param uri the uri to check
  * @return GNUNET_YES if this is a CHK uri
  */
-int 
+int
 GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri)
 {
   return uri->type == chk;
@@ -1572,18 +1537,18 @@ GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri)
  * @param uri the CHK URI to inspect
  * @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)
+uint64_t
+GNUNET_FS_uri_chk_get_file_size (const struct GNUNET_FS_Uri * uri)
 {
   switch (uri->type)
-    {
-    case chk:
-      return GNUNET_ntohll (uri->data.chk.file_length);
-    case loc:
-      return GNUNET_ntohll (uri->data.loc.fi.file_length);
-    default:
-      GNUNET_assert (0);
-    }
+  {
+  case chk:
+    return GNUNET_ntohll (uri->data.chk.file_length);
+  case loc:
+    return GNUNET_ntohll (uri->data.loc.fi.file_length);
+  default:
+    GNUNET_assert (0);
+  }
   return 0;                     /* unreachable */
 }
 
@@ -1594,7 +1559,7 @@ GNUNET_FS_uri_chk_get_file_size (const struct GNUNET_FS_Uri *uri)
  * @param uri the uri to check
  * @return GNUNET_YES if this is a LOC uri
  */
-int 
+int
 GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
 {
   return uri->type == loc;
@@ -1620,26 +1585,23 @@ GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
  */
 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)
+                 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 *nkword;
   int j;
-  
-  if ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
-       (format != EXTRACTOR_METAFORMAT_C_STRING) )
+
+  if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
+      (format != EXTRACTOR_METAFORMAT_C_STRING))
     return 0;
   for (j = uri->data.ksk.keywordCount - 1; j >= 0; j--)
     if (0 == strcmp (&uri->data.ksk.keywords[j][1], data))
       return GNUNET_OK;
-  GNUNET_asprintf (&nkword,
-                   " %s", /* space to mark as 'non mandatory' */
-                   data);
+  GNUNET_asprintf (&nkword, " %s",      /* space to mark as 'non mandatory' */
+                   data);
   uri->data.ksk.keywords[uri->data.ksk.keywordCount++] = nkword;
   return 0;
 }
@@ -1654,7 +1616,8 @@ 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 (const struct GNUNET_CONTAINER_MetaData *md)
+GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData
+                                         *md)
 {
   struct GNUNET_FS_Uri *ret;
   int ent;
@@ -1665,11 +1628,10 @@ GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData
   ret->type = ksk;
   ent = GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL);
   if (ent > 0)
-    {
-      ret->data.ksk.keywords
-        = GNUNET_malloc (sizeof (char *) * ent);                     
-      GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
-    }
+  {
+    ret->data.ksk.keywords = GNUNET_malloc (sizeof (char *) * ent);
+    GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
+  }
   return ret;
 }
 
@@ -1681,7 +1643,7 @@ GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData
 static int
 needs_percent (char c)
 {
-  return (!((isalnum ( (unsigned char) c)) ||
+  return (!((isalnum ((unsigned char) c)) ||
             (c == '-') || (c == '_') || (c == '.') || (c == '~')));
 }
 
@@ -1695,7 +1657,7 @@ needs_percent (char c)
 static char *
 uri_ksk_to_string (const struct GNUNET_FS_Uri *uri)
 {
-  char ** keywords; 
+  char **keywords;
   unsigned int keywordCount;
   size_t n;
   char *ret;
@@ -1709,50 +1671,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);
   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", 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", keyword[j]);
+        wpos += 3;
+      }
+      else
+      {
+        ret[wpos++] = keyword[j];
+      }
     }
+    if (i != keywordCount - 1)
+      ret[wpos++] = '+';
+  }
   return ret;
 }
 
@@ -1766,11 +1727,11 @@ uri_ksk_to_string (const struct GNUNET_FS_Uri *uri)
 static char *
 uri_sks_to_string (const struct GNUNET_FS_Uri *uri)
 {
-  const GNUNET_HashCode * namespace;
+  const GNUNET_HashCode *namespace;
   const char *identifier;
   char *ret;
   struct GNUNET_CRYPTO_HashAsciiEncoded ns;
-  
+
   if (uri->type != sks)
     return NULL;
   namespace = &uri->data.sks.namespace;
@@ -1778,9 +1739,8 @@ uri_sks_to_string (const struct GNUNET_FS_Uri *uri)
   GNUNET_CRYPTO_hash_to_enc (namespace, &ns);
   GNUNET_asprintf (&ret,
                    "%s%s%s/%s",
-                   GNUNET_FS_URI_PREFIX, 
-                   GNUNET_FS_URI_SKS_INFIX,
-                   (const char *) &ns, identifier);
+                   GNUNET_FS_URI_PREFIX,
+                   GNUNET_FS_URI_SKS_INFIX, (const char *) &ns, identifier);
   return ret;
 }
 
@@ -1794,7 +1754,7 @@ uri_sks_to_string (const struct GNUNET_FS_Uri *uri)
 static char *
 uri_chk_to_string (const struct GNUNET_FS_Uri *uri)
 {
-  const struct FileIdentifier * fi;
+  const struct FileIdentifier *fi;
   char *ret;
   struct GNUNET_CRYPTO_HashAsciiEncoded keyhash;
   struct GNUNET_CRYPTO_HashAsciiEncoded queryhash;
@@ -1809,9 +1769,8 @@ uri_chk_to_string (const struct GNUNET_FS_Uri *uri)
                    "%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));
+                   (const char *) &keyhash,
+                   (const char *) &queryhash, GNUNET_ntohll (fi->file_length));
   return ret;
 }
 
@@ -1829,8 +1788,8 @@ bin2enc (const void *data, size_t size)
    * 64 characters for encoding, 6 bits per character
    */
   static char *tbl =
-    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_=";
-  
+      "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_=";
+
   size_t len;
   size_t pos;
   unsigned int bits;
@@ -1847,16 +1806,16 @@ bin2enc (const void *data, size_t size)
   bits = 0;
   hbits = 0;
   for (pos = 0; pos < size; pos++)
+  {
+    bits |= ((((const unsigned char *) data)[pos]) << hbits);
+    hbits += 8;
+    while (hbits >= 6)
     {
-      bits |= ((((const unsigned char *) data)[pos]) << hbits);
-      hbits += 8;
-      while (hbits >= 6)
-        {
-          ret[len++] = tbl[bits & 63];
-          bits >>= 6;
-          hbits -= 6;
-        }
+      ret[len++] = tbl[bits & 63];
+      bits >>= 6;
+      hbits -= 6;
     }
+  }
   if (hbits > 0)
     ret[len] = tbl[bits & 63];
   return ret;
@@ -1881,19 +1840,19 @@ uri_loc_to_string (const struct GNUNET_FS_Uri *uri)
   GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.key, &keyhash);
   GNUNET_CRYPTO_hash_to_enc (&uri->data.loc.fi.chk.query, &queryhash);
   peerId = bin2enc (&uri->data.loc.peer,
-                    sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
-  peerSig = bin2enc (&uri->data.loc.contentSignature, 
-                     sizeof (struct GNUNET_CRYPTO_RsaSignature));
+                    sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded));
+  peerSig = bin2enc (&uri->data.loc.contentSignature,
+                     sizeof (struct GNUNET_CRYPTO_RsaSignature));
   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),
-                   peerId,
-                   peerSig,
-                   (unsigned long long) uri->data.loc.expirationTime.abs_value);
+                   (unsigned long long) GNUNET_ntohll (uri->data.loc.
+                                                       fi.file_length), peerId,
+                   peerSig,
+                   (unsigned long long) uri->data.loc.expirationTime.abs_value);
   GNUNET_free (peerSig);
   GNUNET_free (peerId);
   return ret;
@@ -1910,24 +1869,24 @@ char *
 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 ksk:
-      return uri_ksk_to_string (uri);
-    case sks:
-      return uri_sks_to_string (uri);
-    case chk:
-      return uri_chk_to_string (uri);
-    case loc:
-      return uri_loc_to_string (uri);
-    default:
-      GNUNET_break (0);
-      return NULL;
-    }
+  {
+  case ksk:
+    return uri_ksk_to_string (uri);
+  case sks:
+    return uri_sks_to_string (uri);
+  case chk:
+    return uri_chk_to_string (uri);
+  case loc:
+    return uri_loc_to_string (uri);
+  default:
+    GNUNET_break (0);
+    return NULL;
+  }
 }
 
 /* end of fs_uri.c */
diff --git a/src/fs/gnunet-directory.c b/src/fs/gnunet-directory.c
index 9bd5ed9c1..a6fa42664 100644
--- a/src/fs/gnunet-directory.c
+++ b/src/fs/gnunet-directory.c
@@ -41,21 +41,19 @@ static int ret;
  */
 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)
+              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;
-    }
-  if ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
-       (format != EXTRACTOR_METAFORMAT_C_STRING) )
+  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;
+  }
+  if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
+      (format != EXTRACTOR_METAFORMAT_C_STRING))
     return 0;
   if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
     return 0;
@@ -84,36 +82,29 @@ item_printer (void *cls,
  */
 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)
+             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 (meta,
-                                                 EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+                                                 EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
   if (uri == NULL)
-    {
-      printf (_("Directory `%s' meta data:\n"),
-              name);
-      GNUNET_CONTAINER_meta_data_iterate (meta,
-                                          &item_printer,
-                                          NULL);
-      printf ("\n");
-      printf (_("Directory `%s' contents:\n"),
-              name);
-      GNUNET_free (name);
-      return;
-    }
+  {
+    printf (_("Directory `%s' meta data:\n"), name);
+    GNUNET_CONTAINER_meta_data_iterate (meta, &item_printer, NULL);
+    printf ("\n");
+    printf (_("Directory `%s' contents:\n"), name);
+    GNUNET_free (name);
+    return;
+  }
   string = GNUNET_FS_uri_to_string (uri);
   printf ("%s (%s):\n", name, string);
   GNUNET_free (string);
-  GNUNET_CONTAINER_meta_data_iterate (meta,
-                                      &item_printer,
-                                      NULL);
+  GNUNET_CONTAINER_meta_data_iterate (meta, &item_printer, NULL);
   printf ("\n");
   GNUNET_free (name);
 }
@@ -130,8 +121,7 @@ print_entry (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_DISK_MapHandle *map;
   struct GNUNET_DISK_FileHandle *h;
@@ -142,44 +132,35 @@ run (void *cls,
   int i;
 
   if (NULL == args[0])
-    {
-      fprintf (stderr,
-               _("You must specify a filename to inspect."));
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, _("You must specify a filename to inspect."));
+    ret = 1;
+    return;
+  }
   i = 0;
   while (NULL != (filename = args[i++]))
+  {
+    if ((GNUNET_OK !=
+         GNUNET_DISK_file_size (filename,
+                                &size,
+                                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)) ||
-           (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);
-      GNUNET_FS_directory_list_contents (len,
-                                         data,
-                                         0, 
-                                         &print_entry,
-                                         NULL);
-      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);
+    GNUNET_FS_directory_list_contents (len, data, 0, &print_entry, NULL);
+    printf ("\n");
+    GNUNET_DISK_file_unmap (map);
+    GNUNET_DISK_file_close (h);
+  }
 }
 
 /**
diff --git a/src/fs/gnunet-download.c b/src/fs/gnunet-download.c
index ccfa9c417..fc0b768d9 100644
--- a/src/fs/gnunet-download.c
+++ b/src/fs/gnunet-download.c
@@ -53,8 +53,7 @@ static char *filename;
 static int local_only;
 
 static void
-cleanup_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_stop (ctx);
   ctx = NULL;
@@ -62,17 +61,16 @@ cleanup_task (void *cls,
 
 
 static void
-shutdown_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_DownloadContext *d;
 
   if (dc != NULL)
-    {
-      d = dc;
-      dc = NULL;
-      GNUNET_FS_download_stop (d, delete_incomplete);
-    }
+  {
+    d = dc;
+    dc = NULL;
+    GNUNET_FS_download_stop (d, delete_incomplete);
+  }
 }
 
 
@@ -90,67 +88,64 @@ 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)
 {
   char *s;
   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)
-        {         
-          s = GNUNET_STRINGS_relative_time_to_string(info->value.download.eta);
-          t = GNUNET_STRINGS_byte_size_fancy(info->value.download.completed * 1000LL / (info->value.download.duration.rel_value + 1));
-          fprintf (stdout,
-                   _("Downloading `%s' at %llu/%llu (%s remaining, %s/s)\n"),
-                   info->value.download.filename,
-                   (unsigned long long) info->value.download.completed,
-                   (unsigned long long) info->value.download.size,
-                   s,
-                   t);
-          GNUNET_free (s);
-          GNUNET_free (t);
-        }
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+  {
+  case GNUNET_FS_STATUS_DOWNLOAD_START:
+    if (verbose > 1)
       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 + 1));
+               _("Starting download `%s'.\n"), info->value.download.filename);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+    if (verbose)
+    {
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.download.eta);
+      t = GNUNET_STRINGS_byte_size_fancy (info->value.download.completed *
+                                          1000LL /
+                                          (info->value.download.
+                                           duration.rel_value + 1));
       fprintf (stdout,
-               _("Downloading `%s' done (%s/s).\n"),
-               info->value.download.filename,
-               s);
+               _("Downloading `%s' at %llu/%llu (%s remaining, %s/s)\n"),
+               info->value.download.filename,
+               (unsigned long long) info->value.download.completed,
+               (unsigned long long) info->value.download.size, s, t);
       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_continuation (&cleanup_task,
-                                           NULL,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;      
-    case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
-    case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
-      break;
-    default:
-      fprintf (stderr,
-               _("Unexpected status: %d\n"),
-               info->status);
-      break;
+      GNUNET_free (t);
     }
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+    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 + 1));
+    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_continuation (&cleanup_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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;
 }
 
@@ -166,92 +161,77 @@ progress_cb (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     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,
-               _("You need to specify a URI argument.\n"));
-      return;
-    }
-  uri = GNUNET_FS_uri_parse (args[0],
-                             &emsg);
+  {
+    fprintf (stderr, _("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,
-               _("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, _("Only CHK or LOC URIs supported.\n"));
+    ret = 1;
+    GNUNET_FS_uri_destroy (uri);
+    return;
+  }
   if (NULL == filename)
-    {
-      fprintf (stderr,
-               _("Target filename must be specified.\n"));
-      ret = 1;
-      GNUNET_FS_uri_destroy (uri);
-      return;            
-    }
+  {
+    fprintf (stderr, _("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);
+                         "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);
+                                 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_FS_stop (ctx);
+    ctx = NULL;
+    return;
+  }
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+                                &shutdown_task, NULL);
 }
 
 
@@ -304,4 +284,3 @@ main (int argc, char *const *argv)
 }
 
 /* end of gnunet-download.c */
-
diff --git a/src/fs/gnunet-pseudonym.c b/src/fs/gnunet-pseudonym.c
index df67571a0..742111c4e 100644
--- a/src/fs/gnunet-pseudonym.c
+++ b/src/fs/gnunet-pseudonym.c
@@ -53,12 +53,12 @@ static struct GNUNET_CONTAINER_MetaData *adv_metadata;
 /**
  * Our block options (-p, -r, -a).
  */
-static struct GNUNET_FS_BlockOptions bo = { { 0LL  }, 1, 365, 1 };
+static struct GNUNET_FS_BlockOptions bo = { {0LL}, 1, 365, 1 };
 
 /**
  * -q option given.
  */
-static int no_remote_printing; 
+static int no_remote_printing;
 
 /**
  * -r option.
@@ -87,53 +87,39 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 static int ret;
 
-static void* 
-progress_cb (void *cls,
-             const struct GNUNET_FS_ProgressInfo *info)
+static void *
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   return NULL;
 }
 
 
 static void
-ns_printer (void *cls,
-            const char *name,
-            const GNUNET_HashCode *id)
+ns_printer (void *cls, const char *name, const GNUNET_HashCode * id)
 {
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
 
   GNUNET_CRYPTO_hash_to_enc (id, &enc);
-  fprintf (stdout, 
-           "%s (%s)\n",
-           name,
-           (const char*) &enc);
+  fprintf (stdout, "%s (%s)\n", name, (const char *) &enc);
 }
 
 
 static int
 pseudo_printer (void *cls,
-                const GNUNET_HashCode *
-                pseudonym,
-                const struct
-                GNUNET_CONTAINER_MetaData * md,
-                int rating)
+                const GNUNET_HashCode *
+                pseudonym,
+                const struct GNUNET_CONTAINER_MetaData *md, int rating)
 {
   char *id;
 
-  id = GNUNET_PSEUDONYM_id_to_name (cfg,
-                                    pseudonym);
+  id = GNUNET_PSEUDONYM_id_to_name (cfg, pseudonym);
   if (id == NULL)
-    {
-      GNUNET_break (0);
-      return GNUNET_OK;
-    }
-  fprintf (stdout, 
-           "%s (%d):\n",
-           id,
-           rating);
-  GNUNET_CONTAINER_meta_data_iterate (md,
-                                      &EXTRACTOR_meta_data_print, 
-                                      stdout);
+  {
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
+  fprintf (stdout, "%s (%d):\n", id, rating);
+  GNUNET_CONTAINER_meta_data_iterate (md, &EXTRACTOR_meta_data_print, stdout);
   fprintf (stdout, "\n");
   GNUNET_free (id);
   return GNUNET_OK;
@@ -141,73 +127,58 @@ pseudo_printer (void *cls,
 
 
 static void
-post_advertising (void *cls,
-                  const struct GNUNET_FS_Uri *uri,
-                  const char *emsg)
+post_advertising (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
 {
   GNUNET_HashCode nsid;
   char *set;
   int delta;
 
   if (emsg != NULL)
-    {
-      fprintf (stderr, "%s", emsg);
-      ret = 1;
-    }
+  {
+    fprintf (stderr, "%s", emsg);
+    ret = 1;
+  }
   if (ns != NULL)
+  {
+    if (GNUNET_OK != GNUNET_FS_namespace_delete (ns, GNUNET_NO))
+      ret = 1;
+  }
+  if (NULL != rating_change)
+  {
+    set = rating_change;
+    while ((*set != '\0') && (*set != ':'))
+      set++;
+    if (*set != ':')
     {
-      if (GNUNET_OK !=
-          GNUNET_FS_namespace_delete (ns,
-                                      GNUNET_NO))
-        ret = 1;
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Invalid argument `%s'\n"), rating_change);
     }
-  if (NULL != rating_change)
+    else
     {
-      set = rating_change;
-      while ((*set != '\0') && (*set != ':'))
-        set++;
-      if (*set != ':')
-        {
-          GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                      _("Invalid argument `%s'\n"),
-                      rating_change);
-        }
+      *set = '\0';
+      delta = strtol (&set[1], NULL,    /* no error handling yet */
+                      10);
+      if (GNUNET_OK == GNUNET_PSEUDONYM_name_to_id (cfg, rating_change, &nsid))
+      {
+        (void) GNUNET_PSEUDONYM_rank (cfg, &nsid, delta);
+      }
       else
-        {
-          *set = '\0';
-          delta = strtol (&set[1], NULL, /* no error handling yet */
-                          10);
-          if (GNUNET_OK ==
-              GNUNET_PSEUDONYM_name_to_id (cfg,
-                                           rating_change,
-                                           &nsid))
-            {
-              (void) GNUNET_PSEUDONYM_rank (cfg,
-                                            &nsid,
-                                            delta);           
-            }
-          else
-            {
-              GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                          _("Namespace `%s' unknown.\n"),
-                          rating_change);
-            }
-        }
-      GNUNET_free (rating_change);
-      rating_change = NULL;
+      {
+        GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                    _("Namespace `%s' unknown.\n"), rating_change);
+      }
     }
+    GNUNET_free (rating_change);
+    rating_change = NULL;
+  }
   if (0 != print_local_only)
-    {
-      GNUNET_FS_namespace_list (h,
-                                &ns_printer, 
-                                NULL);
-    }  
+  {
+    GNUNET_FS_namespace_list (h, &ns_printer, NULL);
+  }
   else if (0 == no_remote_printing)
-    {
-      GNUNET_PSEUDONYM_list_all (cfg,
-                                 &pseudo_printer,
-                                 NULL);
-    }
+  {
+    GNUNET_PSEUDONYM_list_all (cfg, &pseudo_printer, NULL);
+  }
   GNUNET_FS_stop (h);
 }
 
@@ -223,76 +194,70 @@ post_advertising (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   char *emsg;
 
   cfg = c;
   h = GNUNET_FS_start (cfg,
-                       "gnunet-pseudonym",
-                       &progress_cb,
-                       NULL,
-                       GNUNET_FS_FLAGS_NONE,
-                       GNUNET_FS_OPTIONS_END);
+                       "gnunet-pseudonym",
+                       &progress_cb,
+                       NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
   if (NULL != delete_ns)
+  {
+    ns = GNUNET_FS_namespace_create (h, delete_ns);
+    if (ns == NULL)
     {
-      ns = GNUNET_FS_namespace_create (h, delete_ns);
-      if (ns == NULL)
-        {
-          ret = 1;
-        }
-      else
-        {
-          if (GNUNET_OK !=
-              GNUNET_FS_namespace_delete (ns,
-                                          GNUNET_YES))
-            ret = 1;
-          ns = NULL;
-        }
+      ret = 1;
+    }
+    else
+    {
+      if (GNUNET_OK != GNUNET_FS_namespace_delete (ns, GNUNET_YES))
+        ret = 1;
+      ns = NULL;
     }
+  }
   if (NULL != create_ns)
+  {
+    ns = GNUNET_FS_namespace_create (h, create_ns);
+    if (ns == NULL)
+    {
+      ret = 1;
+    }
+    else
     {
-      ns = GNUNET_FS_namespace_create (h, create_ns);
-      if (ns == NULL)
-        {
-          ret = 1;
-        }
+      if (NULL != root_identifier)
+      {
+        if (ksk_uri == NULL)
+        {
+          emsg = NULL;
+          ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/namespace", &emsg);
+          GNUNET_assert (NULL == emsg);
+        }
+        GNUNET_FS_namespace_advertise (h,
+                                       ksk_uri,
+                                       ns,
+                                       adv_metadata,
+                                       &bo,
+                                       root_identifier,
+                                       &post_advertising, NULL);
+        return;
+      }
       else
-        {
-          if (NULL != root_identifier)
-            {
-              if (ksk_uri == NULL)
-                {
-                  emsg = NULL;
-                  ksk_uri = GNUNET_FS_uri_parse ("gnunet://fs/ksk/namespace", &emsg);
-                  GNUNET_assert (NULL == emsg);
-                }
-              GNUNET_FS_namespace_advertise (h,
-                                             ksk_uri,
-                                             ns,
-                                             adv_metadata,
-                                             &bo,
-                                             root_identifier,
-                                             &post_advertising,
-                                             NULL);
-              return;
-            }
-          else
-            {
-              if (ksk_uri != NULL)
-                fprintf (stderr, _("Option `%s' ignored\n"), "-k");   
-            }
-        }
+      {
+        if (ksk_uri != NULL)
+          fprintf (stderr, _("Option `%s' ignored\n"), "-k");
+      }
     }
+  }
   else
-    {
-      if (root_identifier != NULL) 
-        fprintf (stderr, _("Option `%s' ignored\n"), "-r");
-      if (ksk_uri != NULL)
-        fprintf (stderr, _("Option `%s' ignored\n"), "-k");   
-    }    
-    
+  {
+    if (root_identifier != NULL)
+      fprintf (stderr, _("Option `%s' ignored\n"), "-r");
+    if (ksk_uri != NULL)
+      fprintf (stderr, _("Option `%s' ignored\n"), "-k");
+  }
+
   post_advertising (NULL, NULL, NULL);
 }
 
@@ -313,12 +278,10 @@ main (int argc, char *const *argv)
      gettext_noop ("set the desired LEVEL of sender-anonymity"),
      1, &GNUNET_GETOPT_set_uint, &bo.anonymity_level},
     {'C', "create", "NAME",
-     gettext_noop
-     ("create or advertise namespace NAME"),
+     gettext_noop ("create or advertise namespace NAME"),
      1, &GNUNET_GETOPT_set_string, &create_ns},
     {'D', "delete", "NAME",
-     gettext_noop
-     ("delete namespace NAME "),
+     gettext_noop ("delete namespace NAME "),
      1, &GNUNET_GETOPT_set_string, &delete_ns},
     {'k', "keyword", "VALUE",
      gettext_noop
@@ -341,22 +304,18 @@ main (int argc, char *const *argv)
      gettext_noop ("set the desired replication LEVEL"),
      1, &GNUNET_GETOPT_set_uint, &bo.replication_level},
     {'R', "root", "ID",
-     gettext_noop
-     ("specify ID of the root of the namespace"),
+     gettext_noop ("specify ID of the root of the namespace"),
      1, &GNUNET_GETOPT_set_string, &root_identifier},
     {'s', "set-rating", "ID:VALUE",
-     gettext_noop
-     ("change rating of namespace ID by VALUE"),
+     gettext_noop ("change rating of namespace ID by VALUE"),
      1, &GNUNET_GETOPT_set_string, &rating_change},
     GNUNET_GETOPT_OPTION_END
   };
-  bo.expiration_time = GNUNET_FS_year_to_time (GNUNET_FS_get_current_year () + 2);
+  bo.expiration_time =
+      GNUNET_FS_year_to_time (GNUNET_FS_get_current_year () + 2);
   return (GNUNET_OK ==
-          GNUNET_PROGRAM_run (argc,
-                              argv,
-                              "gnunet-pseudonym [OPTIONS]",
-                              gettext_noop
-                              ("Manage GNUnet pseudonyms."),
+          GNUNET_PROGRAM_run (argc, argv, "gnunet-pseudonym [OPTIONS]",
+                              gettext_noop ("Manage GNUnet pseudonyms."),
                               options, &run, NULL)) ? ret : 1;
 }
 
diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index 4ff1ad000..326fed3c6 100644
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -44,7 +44,7 @@ static struct GNUNET_FS_Uri *topKeywords;
 
 static struct GNUNET_FS_Uri *uri;
 
-static struct GNUNET_FS_BlockOptions bo = { { 0LL  }, 1, 365, 1 };
+static struct GNUNET_FS_BlockOptions bo = { {0LL}, 1, 365, 1 };
 
 static char *uri_string;
 
@@ -67,23 +67,22 @@ static int do_disable_creation_time;
 static GNUNET_SCHEDULER_TaskIdentifier kill_task;
 
 
-static void 
-do_stop_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+static void
+do_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_PublishContext *p;
 
   if (pc != NULL)
+  {
+    p = pc;
+    pc = NULL;
+    GNUNET_FS_publish_stop (p);
+    if (NULL != meta)
     {
-      p = pc;
-      pc = NULL;
-      GNUNET_FS_publish_stop (p);
-      if (NULL != meta) 
-        {
-          GNUNET_CONTAINER_meta_data_destroy (meta);
-          meta = NULL;
-        }
+      GNUNET_CONTAINER_meta_data_destroy (meta);
+      meta = NULL;
     }
+  }
 }
 
 
@@ -101,72 +100,66 @@ 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)
 {
   char *s;
 
   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);
-          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);
-          GNUNET_free (s);
-        }
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf (stderr,
-               _("Error publishing: %s.\n"),
-               info->value.publish.specifics.error.message);
-      if (kill_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (kill_task);
-          kill_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      GNUNET_SCHEDULER_add_continuation (&do_stop_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.eta);
       fprintf (stdout,
-               _("Publishing `%s' done.\n"),
-               info->value.publish.filename);
-      s = GNUNET_FS_uri_to_string (info->value.publish.specifics.completed.chk_uri);
-      fprintf (stdout,
-               _("URI is `%s'.\n"),
-               s);
+               _("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);
       GNUNET_free (s);
-      if (info->value.publish.pctx == NULL)
-        {
-          if (kill_task != GNUNET_SCHEDULER_NO_TASK)
-            {
-              GNUNET_SCHEDULER_cancel (kill_task);
-              kill_task = GNUNET_SCHEDULER_NO_TASK;
-            }
-          GNUNET_SCHEDULER_add_continuation (&do_stop_task,
-                                             NULL,
-                                             GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-        }
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED: 
-      GNUNET_break (NULL == pc);
-      return NULL;      
-    default:
-      fprintf (stderr,
-               _("Unexpected status: %d\n"),
-               info->status);
-      return NULL;
     }
-  return ""; /* non-null */
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr,
+             _("Error publishing: %s.\n"),
+             info->value.publish.specifics.error.message);
+    if (kill_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (kill_task);
+      kill_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    GNUNET_SCHEDULER_add_continuation (&do_stop_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    fprintf (stdout,
+             _("Publishing `%s' done.\n"), info->value.publish.filename);
+    s = GNUNET_FS_uri_to_string (info->value.publish.specifics.
+                                 completed.chk_uri);
+    fprintf (stdout, _("URI is `%s'.\n"), s);
+    GNUNET_free (s);
+    if (info->value.publish.pctx == NULL)
+    {
+      if (kill_task != GNUNET_SCHEDULER_NO_TASK)
+      {
+        GNUNET_SCHEDULER_cancel (kill_task);
+        kill_task = GNUNET_SCHEDULER_NO_TASK;
+      }
+      GNUNET_SCHEDULER_add_continuation (&do_stop_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    }
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_break (NULL == pc);
+    return NULL;
+  default:
+    fprintf (stderr, _("Unexpected status: %d\n"), info->status);
+    return NULL;
+  }
+  return "";                    /* non-null */
 }
 
 
@@ -185,22 +178,17 @@ progress_cb (void *cls,
  */
 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)
+              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) )
+  if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
+      (format != EXTRACTOR_METAFORMAT_C_STRING))
     return 0;
-  if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME) 
+  if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
     return 0;
-  fprintf (stdout, 
-           "\t%s - %s\n",
-           EXTRACTOR_metatype_to_string (type),
-           data);
+  fprintf (stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string (type), data);
   return 0;
 }
 
@@ -215,13 +203,9 @@ meta_printer (void *cls,
  */
 
 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;
 }
 
@@ -245,13 +229,12 @@ keyword_printer (void *cls,
  */
 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)
+                   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;
@@ -260,73 +243,57 @@ publish_inspector (void *cls,
   if (cls == fi)
     return GNUNET_OK;
   if (NULL != topKeywords)
+  {
+    if (*uri != NULL)
     {
-      if (*uri != NULL)
-        {
-          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;
     }
-  if (! do_disable_creation_time)
+    topKeywords = NULL;
+  }
+  if (NULL != meta)
+  {
+    GNUNET_CONTAINER_meta_data_merge (m, meta);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    meta = NULL;
+  }
+  if (!do_disable_creation_time)
     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, "\n");
-    }
+  {
+    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, "\n");
+  }
   if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (m))
-    GNUNET_FS_file_information_inspect (fi,
-                                        &publish_inspector,
-                                        fi);
+    GNUNET_FS_file_information_inspect (fi, &publish_inspector, fi);
   return GNUNET_OK;
 }
 
 
-static void 
+static void
 uri_sks_continuation (void *cls,
-                      const struct GNUNET_FS_Uri *ksk_uri,
-                      const char *emsg)
+                      const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
 {
   if (emsg != NULL)
-    {
-      fprintf (stderr,
-               "%s\n",
-               emsg);
-      ret = 1;
-    }
+  {
+    fprintf (stderr, "%s\n", emsg);
+    ret = 1;
+  }
   GNUNET_FS_uri_destroy (uri);
   uri = NULL;
   GNUNET_FS_stop (ctx);
@@ -334,48 +301,40 @@ uri_sks_continuation (void *cls,
 }
 
 
-static void 
+static void
 uri_ksk_continuation (void *cls,
-                      const struct GNUNET_FS_Uri *ksk_uri,
-                      const char *emsg)
+                      const struct GNUNET_FS_Uri *ksk_uri, const char *emsg)
 {
   struct GNUNET_FS_Namespace *ns;
 
   if (emsg != NULL)
+  {
+    fprintf (stderr, "%s\n", emsg);
+    ret = 1;
+  }
+  if (pseudonym != NULL)
+  {
+    ns = GNUNET_FS_namespace_create (ctx, pseudonym);
+    if (ns == NULL)
     {
-      fprintf (stderr,
-               "%s\n",
-               emsg);
+      fprintf (stderr, _("Failed to create namespace `%s'\n"), pseudonym);
       ret = 1;
     }
-  if (pseudonym != NULL)
+    else
     {
-      ns = GNUNET_FS_namespace_create (ctx,
-                                       pseudonym);
-      if (ns == NULL)
-        {
-          fprintf (stderr,
-                   _("Failed to create namespace `%s'\n"),
-                   pseudonym);
-          ret = 1;
-        }
-      else
-        {
-          GNUNET_FS_publish_sks (ctx,
-                                 ns,
-                                 this_id,
-                                 next_id,
-                                 meta,
-                                 uri,
-                                 &bo,
-                                 GNUNET_FS_PUBLISH_OPTION_NONE,
-                                 uri_sks_continuation,
-                                 NULL);
-          GNUNET_assert (GNUNET_OK ==
-                         GNUNET_FS_namespace_delete (ns, GNUNET_NO));
-          return;
-        }
+      GNUNET_FS_publish_sks (ctx,
+                             ns,
+                             this_id,
+                             next_id,
+                             meta,
+                             uri,
+                             &bo,
+                             GNUNET_FS_PUBLISH_OPTION_NONE,
+                             uri_sks_continuation, NULL);
+      GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_NO));
+      return;
     }
+  }
   GNUNET_FS_uri_destroy (uri);
   uri = NULL;
   GNUNET_FS_stop (ctx);
@@ -394,8 +353,7 @@ uri_ksk_continuation (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct GNUNET_FS_FileInformation *fi;
   struct GNUNET_FS_Namespace *namespace;
@@ -404,212 +362,187 @@ run (void *cls,
   struct stat sbuf;
   char *ex;
   char *emsg;
-  
+
   /* check arguments */
   if ((uri_string != NULL) && (extract_only))
+  {
+    printf (_("Cannot extract metadata from a URI!\n"));
+    ret = -1;
+    return;
+  }
+  if (((uri_string == NULL) || (extract_only))
+      && ((args[0] == NULL) || (args[1] != NULL)))
+  {
+    printf (_("You must specify one and only one filename for insertion.\n"));
+    ret = -1;
+    return;
+  }
+  if ((uri_string != NULL) && (args[0] != NULL))
+  {
+    printf (_("You must NOT specify an URI and a filename.\n"));
+    ret = -1;
+    return;
+  }
+  if (pseudonym != NULL)
+  {
+    if (NULL == this_id)
     {
-      printf (_("Cannot extract metadata from a URI!\n"));
+      fprintf (stderr,
+               _("Option `%s' is required when using option `%s'.\n"),
+               "-t", "-P");
       ret = -1;
       return;
     }
-  if ( ( (uri_string == NULL) || (extract_only) ) 
-       && ( (args[0] == NULL) || (args[1] != NULL) ) )
+  }
+  else
+  {                             /* ordinary insertion checks */
+    if (NULL != next_id)
     {
-      printf (_
-              ("You must specify one and only one filename for insertion.\n"));
+      fprintf (stderr,
+               _("Option `%s' makes no sense without option `%s'.\n"),
+               "-N", "-P");
       ret = -1;
       return;
     }
-  if ((uri_string != NULL) && (args[0] != NULL))
+    if (NULL != this_id)
     {
-      printf (_("You must NOT specify an URI and a filename.\n"));
+      fprintf (stderr,
+               _("Option `%s' makes no sense without option `%s'.\n"),
+               "-t", "-P");
       ret = -1;
       return;
     }
-  if (pseudonym != NULL)
-    {
-      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;
-        }
-    }
+  }
   cfg = c;
   ctx = GNUNET_FS_start (cfg,
-                         "gnunet-publish",
-                         &progress_cb,
-                         NULL,
-                         GNUNET_FS_FLAGS_NONE,
-                         GNUNET_FS_OPTIONS_END);
+                         "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;
-    }
+  {
+    fprintf (stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
+    ret = 1;
+    return;
+  }
   namespace = NULL;
   if (NULL != pseudonym)
+  {
+    namespace = GNUNET_FS_namespace_create (ctx, pseudonym);
+    if (NULL == namespace)
     {
-      namespace = GNUNET_FS_namespace_create (ctx,
-                                              pseudonym);
-      if (NULL == namespace)
-        {
-          fprintf (stderr,
-                   _("Could not create namespace `%s'\n"),
-                   pseudonym);
-          GNUNET_FS_stop (ctx);
-          ret = 1;
-          return;
-        }
+      fprintf (stderr, _("Could not create namespace `%s'\n"), pseudonym);
+      GNUNET_FS_stop (ctx);
+      ret = 1;
+      return;
     }
+  }
   if (NULL != uri_string)
-    {      
-      emsg = NULL;
-      uri = GNUNET_FS_uri_parse (uri_string,
-                                 &emsg);
-      if (uri == NULL)
-        {
-          fprintf (stderr, 
-                   _("Failed to parse URI: %s\n"),
-                   emsg);
-          GNUNET_free (emsg);
-          if (namespace != NULL)
-            GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
-          GNUNET_FS_stop (ctx);
-          ret = 1;
-          return;         
-        }
-      GNUNET_FS_publish_ksk (ctx,
-                             topKeywords,
-                             meta,
-                             uri,
-                             &bo,
-                             GNUNET_FS_PUBLISH_OPTION_NONE,
-                             &uri_ksk_continuation,
-                             NULL);
+  {
+    emsg = NULL;
+    uri = GNUNET_FS_uri_parse (uri_string, &emsg);
+    if (uri == NULL)
+    {
+      fprintf (stderr, _("Failed to parse URI: %s\n"), emsg);
+      GNUNET_free (emsg);
       if (namespace != NULL)
-        GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+        GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+      GNUNET_FS_stop (ctx);
+      ret = 1;
       return;
     }
+    GNUNET_FS_publish_ksk (ctx,
+                           topKeywords,
+                           meta,
+                           uri,
+                           &bo,
+                           GNUNET_FS_PUBLISH_OPTION_NONE,
+                           &uri_ksk_continuation, NULL);
+    if (namespace != NULL)
+      GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+    return;
+  }
   plugins = NULL;
-  if (! disable_extractor)
+  if (!disable_extractor)
+  {
+    plugins = EXTRACTOR_plugin_add_defaults (EXTRACTOR_OPTION_DEFAULT_POLICY);
+    if (GNUNET_OK ==
+        GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
     {
-      plugins = EXTRACTOR_plugin_add_defaults (EXTRACTOR_OPTION_DEFAULT_POLICY);
-      if (GNUNET_OK ==
-          GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS",
-                                                 &ex))
-        {
-          if (strlen (ex) > 0)
-            plugins = EXTRACTOR_plugin_add_config (plugins, ex, EXTRACTOR_OPTION_DEFAULT_POLICY);
-          GNUNET_free (ex);
-        }
+      if (strlen (ex) > 0)
+        plugins =
+            EXTRACTOR_plugin_add_config (plugins, ex,
+                                         EXTRACTOR_OPTION_DEFAULT_POLICY);
+      GNUNET_free (ex);
     }
+  }
   emsg = NULL;
   GNUNET_assert (NULL != args[0]);
   if (0 != STAT (args[0], &sbuf))
-    {
-      GNUNET_asprintf (&emsg,
-                       _("Could not access file: %s\n"),
-                       STRERROR (errno));
-      fi = NULL;
-    }
+  {
+    GNUNET_asprintf (&emsg, _("Could not access file: %s\n"), STRERROR (errno));
+    fi = NULL;
+  }
   else if (S_ISDIR (sbuf.st_mode))
-    {
-      fi = GNUNET_FS_file_information_create_from_directory (ctx,
-                                                             NULL,
-                                                             args[0],
-                                                             &GNUNET_FS_directory_scanner_default,
-                                                             plugins,
-                                                             !do_insert,
-                                                             &bo,
-                                                             &emsg);
-    }
+  {
+    fi = GNUNET_FS_file_information_create_from_directory (ctx,
+                                                           NULL,
+                                                           args[0],
+                                                           &GNUNET_FS_directory_scanner_default,
+                                                           plugins,
+                                                           !do_insert,
+                                                           &bo, &emsg);
+  }
   else
-    {
-      if (meta == NULL)
-        meta = GNUNET_CONTAINER_meta_data_create ();
-      GNUNET_FS_meta_data_extract_from_file (meta,
-                                             args[0],
-                                             plugins);
-      keywords = GNUNET_FS_uri_ksk_create_from_meta_data (meta);
-      fi = GNUNET_FS_file_information_create_from_file (ctx,
-                                                        NULL,
-                                                        args[0],
-                                                        keywords,
-                                                        NULL,
-                                                        !do_insert,
-                                                        &bo);
-      GNUNET_break (fi != NULL);
-      GNUNET_FS_uri_destroy (keywords);
-    }
-  EXTRACTOR_plugin_remove_all (plugins);  
+  {
+    if (meta == NULL)
+      meta = GNUNET_CONTAINER_meta_data_create ();
+    GNUNET_FS_meta_data_extract_from_file (meta, args[0], plugins);
+    keywords = GNUNET_FS_uri_ksk_create_from_meta_data (meta);
+    fi = GNUNET_FS_file_information_create_from_file (ctx,
+                                                      NULL,
+                                                      args[0],
+                                                      keywords,
+                                                      NULL, !do_insert, &bo);
+    GNUNET_break (fi != NULL);
+    GNUNET_FS_uri_destroy (keywords);
+  }
+  EXTRACTOR_plugin_remove_all (plugins);
   if (fi == NULL)
-    {
-      fprintf (stderr,
-               _("Could not publish `%s': %s\n"),
-               args[0],
-               emsg);
-      GNUNET_free (emsg);
-      if (namespace != NULL)
-        GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
-      GNUNET_FS_stop (ctx);
-      ret = 1;
-      return;
-    }
-  GNUNET_FS_file_information_inspect (fi,
-                                      &publish_inspector,
-                                      NULL);
+  {
+    fprintf (stderr, _("Could not publish `%s': %s\n"), args[0], emsg);
+    GNUNET_free (emsg);
+    if (namespace != NULL)
+      GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+    GNUNET_FS_stop (ctx);
+    ret = 1;
+    return;
+  }
+  GNUNET_FS_file_information_inspect (fi, &publish_inspector, NULL);
   if (extract_only)
-    {
-      if (namespace != NULL)
-        GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
-      GNUNET_FS_file_information_destroy (fi, NULL, NULL);
-      GNUNET_FS_stop (ctx);
-      return;
-    }
+  {
+    if (namespace != NULL)
+      GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+    GNUNET_FS_file_information_destroy (fi, NULL, NULL);
+    GNUNET_FS_stop (ctx);
+    return;
+  }
   pc = GNUNET_FS_publish_start (ctx,
-                                fi,
-                                namespace,
-                                this_id,
-                                next_id,
-                                (do_simulate) 
-                                ? GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
-                                : GNUNET_FS_PUBLISH_OPTION_NONE);
+                                fi,
+                                namespace,
+                                this_id,
+                                next_id,
+                                (do_simulate)
+                                ? GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
+                                : GNUNET_FS_PUBLISH_OPTION_NONE);
   if (NULL == pc)
-    {
-      fprintf (stderr,
-               _("Could not start publishing.\n"));
-      GNUNET_FS_stop (ctx);
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, _("Could not start publishing.\n"));
+    GNUNET_FS_stop (ctx);
+    ret = 1;
+    return;
+  }
   kill_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                            &do_stop_task,
-                                            NULL);
+                                            &do_stop_task, NULL);
 }
 
 
@@ -634,8 +567,7 @@ main (int argc, char *const *argv)
      ("disable adding the creation time to the metadata of the uploaded file"),
      0, &GNUNET_GETOPT_set_one, &do_disable_creation_time},
     {'D', "disable-extractor", NULL,
-     gettext_noop
-     ("do not use libextractor to add keywords or metadata"),
+     gettext_noop ("do not use libextractor to add keywords or metadata"),
      0, &GNUNET_GETOPT_set_one, &disable_extractor},
     {'e', "extract", NULL,
      gettext_noop
@@ -651,7 +583,7 @@ main (int argc, char *const *argv)
      1, &GNUNET_FS_getopt_set_metadata, &meta},
     {'n', "noindex", NULL,
      gettext_noop ("do not index, perform full insertion (stores entire "
-                   "file in encrypted form in GNUnet database)"),
+                   "file in encrypted form in GNUnet database)"),
      0, &GNUNET_GETOPT_set_one, &do_insert},
     {'N', "next", "ID",
      gettext_noop
@@ -670,26 +602,25 @@ main (int argc, char *const *argv)
      1, &GNUNET_GETOPT_set_uint, &bo.replication_level},
     {'s', "simulate-only", NULL,
      gettext_noop ("only simulate the process but do not do any "
-                   "actual publishing (useful to compute URIs)"),
+                   "actual publishing (useful to compute URIs)"),
      0, &GNUNET_GETOPT_set_one, &do_simulate},
     {'t', "this", "ID",
      gettext_noop ("set the ID of this version of the publication"
-                   " (for namespace insertions only)"),
+                   " (for namespace insertions only)"),
      1, &GNUNET_GETOPT_set_string, &this_id},
     {'u', "uri", "URI",
      gettext_noop ("URI to be published (can be used instead of passing a "
-                   "file to add keywords to the file with the respective URI)"),
-     1, &GNUNET_GETOPT_set_string, &uri_string}, 
+                   "file to add keywords to the file with the respective URI)"),
+     1, &GNUNET_GETOPT_set_string, &uri_string},
     {'V', "verbose", NULL,
      gettext_noop ("be verbose (print progress information)"),
      0, &GNUNET_GETOPT_set_one, &verbose},
     GNUNET_GETOPT_OPTION_END
   };
-  bo.expiration_time = GNUNET_FS_year_to_time (GNUNET_FS_get_current_year () + 2);
+  bo.expiration_time =
+      GNUNET_FS_year_to_time (GNUNET_FS_get_current_year () + 2);
   return (GNUNET_OK ==
-          GNUNET_PROGRAM_run (argc,
-                              argv,
-                              "gnunet-publish [OPTIONS] FILENAME",
+          GNUNET_PROGRAM_run (argc, argv, "gnunet-publish [OPTIONS] FILENAME",
                               gettext_noop
                               ("Publish a file or directory on GNUnet"),
                               options, &run, NULL)) ? ret : 1;
diff --git a/src/fs/gnunet-search.c b/src/fs/gnunet-search.c
index c4c8b2a46..8a3e2ed6a 100644
--- a/src/fs/gnunet-search.c
+++ b/src/fs/gnunet-search.c
@@ -68,32 +68,28 @@ static int local_only;
  * @param data actual meta-data found
  * @param data_size number of bytes in data
  * @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)
+              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) )
+  if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
+      (format != EXTRACTOR_METAFORMAT_C_STRING))
     return 0;
-  if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME) 
+  if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)
     return 0;
   printf ("\t%20s: %s\n",
           dgettext (LIBEXTRACTOR_GETTEXT_DOMAIN,
-                    EXTRACTOR_metatype_to_string (type)),
-          data);
+                    EXTRACTOR_metatype_to_string (type)), data);
   return 0;
 }
 
 
 static void
-clean_task (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+clean_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   size_t dsize;
   void *ddata;
@@ -102,25 +98,23 @@ clean_task (void *cls,
   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 != 
+  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);
-    }
+                            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);
 }
@@ -140,8 +134,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;
   char *uri;
@@ -149,78 +142,72 @@ progress_cb (void *cls,
   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);
+    if (filename != NULL)
     {
-    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);
-      if (filename != NULL)
-        {
-          while (NULL != (dotdot = strstr (filename, "..")))
-            dotdot[0] = dotdot[1] = '_';
-          printf ("gnunet-download -o \"%s\" %s\n", 
-                  filename, 
-                  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_continuation (&clean_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;      
-    default:
-      fprintf (stderr,
-               _("Unexpected status: %d\n"),
-               info->status);
-      break;
+      while (NULL != (dotdot = strstr (filename, "..")))
+        dotdot[0] = dotdot[1] = '_';
+      printf ("gnunet-download -o \"%s\" %s\n", filename, 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_continuation (&clean_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    fprintf (stderr, _("Unexpected status: %d\n"), info->status);
+    break;
+  }
   return NULL;
 }
 
 
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (sc != NULL)
-    {
-      GNUNET_FS_search_stop (sc); 
-      sc = NULL;
-    }
+  {
+    GNUNET_FS_search_stop (sc);
+    sc = NULL;
+  }
 }
 
 
@@ -235,8 +222,7 @@ shutdown_task (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   struct GNUNET_FS_Uri *uri;
   unsigned int argc;
@@ -246,63 +232,49 @@ 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,
-               _("Could not create keyword URI from arguments.\n"));
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, _("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);
+                         "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);
   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);
+  sc = GNUNET_FS_search_start (ctx, uri, anonymity, options, NULL);
   GNUNET_FS_uri_destroy (uri);
   if (NULL == sc)
-    {
-      fprintf (stderr,
-               _("Could not start searching.\n"));
-      GNUNET_FS_stop (ctx);
-      ret = 1;
-      return;
-    }
+  {
+    fprintf (stderr, _("Could not start searching.\n"));
+    GNUNET_FS_stop (ctx);
+    ret = 1;
+    return;
+  }
   if (timeout != 0)
-    {
-      delay.rel_value = timeout;
-      GNUNET_SCHEDULER_add_delayed (delay,
-                                    &shutdown_task,
-                                    NULL);  
-    }
+  {
+    delay.rel_value = timeout;
+    GNUNET_SCHEDULER_add_delayed (delay, &shutdown_task, NULL);
+  }
   else
-    {
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                    &shutdown_task,
-                                    NULL);  
-    }
+  {
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                  &shutdown_task, NULL);
+  }
 }
 
 
@@ -324,12 +296,10 @@ main (int argc, char *const *argv)
      gettext_noop ("only search the local peer (no P2P network search)"),
      0, &GNUNET_GETOPT_set_one, &local_only},
     {'o', "output", "PREFIX",
-     gettext_noop
-     ("write search results to file starting with PREFIX"),
-     1, &GNUNET_GETOPT_set_string, &output_filename}, 
+     gettext_noop ("write search results to file starting with PREFIX"),
+     1, &GNUNET_GETOPT_set_string, &output_filename},
     {'t', "timeout", "VALUE",
-     gettext_noop
-     ("automatically terminate search after VALUE ms"),
+     gettext_noop ("automatically terminate search after VALUE ms"),
      1, &GNUNET_GETOPT_set_ulong, &timeout},
     {'V', "verbose", NULL,
      gettext_noop ("be verbose (print progress information)"),
@@ -339,7 +309,7 @@ main (int argc, char *const *argv)
      ("automatically terminate search after VALUE results are found"),
      1, &GNUNET_GETOPT_set_ulong, &results_limit},
     GNUNET_GETOPT_OPTION_END
-  }; 
+  };
   return (GNUNET_OK ==
           GNUNET_PROGRAM_run (argc,
                               argv,
@@ -350,4 +320,3 @@ main (int argc, char *const *argv)
 }
 
 /* end of gnunet-search.c */
-
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c
index 5ea1bb7c1..4d12b8bfd 100644
--- a/src/fs/gnunet-service-fs.c
+++ b/src/fs/gnunet-service-fs.c
@@ -162,14 +162,12 @@ static struct GNUNET_PeerIdentity my_id;
  * @param tc task context
  */
 static void
-age_cover_counters (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+age_cover_counters (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   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);
+                                                 &age_cover_counters, NULL);
 }
 
 
@@ -186,8 +184,7 @@ 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);
+  GNUNET_LOAD_update (datastore_get_load, delay.rel_value);
 }
 
 
@@ -207,9 +204,9 @@ GSF_test_get_load_too_high_ (uint32_t priority)
 
   ld = GNUNET_LOAD_get_load (datastore_get_load);
   if (ld < 1)
-    return GNUNET_SYSERR;    
-  if (ld <= priority)    
-    return GNUNET_NO;    
+    return GNUNET_SYSERR;
+  if (ld <= priority)
+    return GNUNET_NO;
   return GNUNET_YES;
 }
 
@@ -227,18 +224,18 @@ GSF_test_get_load_too_high_ (uint32_t priority)
  */
 static int
 handle_p2p_put (void *cls,
-                const struct GNUNET_PeerIdentity *other,
-                const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_PeerIdentity *other,
+                const struct GNUNET_MessageHeader *message,
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct GSF_ConnectedPeer *cp;
 
   cp = GSF_peer_get_ (other);
   if (NULL == cp)
-    {
-      GNUNET_break (0);
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
   GSF_cover_content_count++;
   return GSF_handle_p2p_content_ (cp, message);
 }
@@ -255,9 +252,9 @@ handle_p2p_put (void *cls,
  */
 static void
 consider_request_for_forwarding (void *cls,
-                                 const struct GNUNET_PeerIdentity *peer,
-                                 struct GSF_ConnectedPeer *cp,
-                                 const struct GSF_PeerPerformanceData *ppd)
+                                 const struct GNUNET_PeerIdentity *peer,
+                                 struct GSF_ConnectedPeer *cp,
+                                 const struct GSF_PeerPerformanceData *ppd)
 {
   struct GSF_PendingRequest *pr = cls;
 
@@ -277,13 +274,12 @@ consider_request_for_forwarding (void *cls,
  */
 static void
 consider_forwarding (void *cls,
-                     struct GSF_PendingRequest *pr,
-                     enum GNUNET_BLOCK_EvaluationResult result)
+                     struct GSF_PendingRequest *pr,
+                     enum GNUNET_BLOCK_EvaluationResult result)
 {
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
-    return; /* we're done... */
-  GSF_iterate_connected_peers_ (&consider_request_for_forwarding,
-                                pr);
+    return;                     /* we're done... */
+  GSF_iterate_connected_peers_ (&consider_request_for_forwarding, pr);
 }
 
 
@@ -300,18 +296,16 @@ consider_forwarding (void *cls,
  */
 static int
 handle_p2p_get (void *cls,
-                const struct GNUNET_PeerIdentity *other,
-                const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                const struct GNUNET_PeerIdentity *other,
+                const struct GNUNET_MessageHeader *message,
+                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct GSF_PendingRequest *pr;
 
   pr = GSF_handle_p2p_query_ (other, message);
   if (NULL == pr)
     return GNUNET_SYSERR;
-  GSF_local_lookup_ (pr, 
-                     &consider_forwarding,
-                     NULL);
+  GSF_local_lookup_ (pr, &consider_forwarding, NULL);
   return GNUNET_OK;
 }
 
@@ -328,8 +322,8 @@ handle_p2p_get (void *cls,
  */
 static void
 start_p2p_processing (void *cls,
-                      struct GSF_PendingRequest *pr,
-                      enum GNUNET_BLOCK_EvaluationResult result)
+                      struct GSF_PendingRequest *pr,
+                      enum GNUNET_BLOCK_EvaluationResult result)
 {
   struct GNUNET_SERVER_Client *client = cls;
   struct GSF_PendingRequestData *prd;
@@ -337,19 +331,17 @@ start_p2p_processing (void *cls,
   prd = GSF_pending_request_get_data_ (pr);
 #if DEBUG_FS_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Finished database lookup for local request `%s' with result %d\n",
-              GNUNET_h2s (&prd->query),
-              result);
+              "Finished database lookup for local request `%s' with result %d\n",
+              GNUNET_h2s (&prd->query), result);
 #endif
-  GNUNET_SERVER_receive_done (client,
-                              GNUNET_OK);
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
   if (GNUNET_BLOCK_EVALUATION_OK_LAST == result)
-    return; /* we're done, 'pr' was already destroyed... */
-  if (0 != (GSF_PRO_LOCAL_ONLY & prd->options) )
-    {
-      GSF_pending_request_cancel_ (pr, GNUNET_YES);
-      return;
-    }
+    return;                     /* we're done, 'pr' was already destroyed... */
+  if (0 != (GSF_PRO_LOCAL_ONLY & prd->options))
+  {
+    GSF_pending_request_cancel_ (pr, GNUNET_YES);
+    return;
+  }
   GSF_dht_lookup_ (pr);
   consider_forwarding (NULL, pr, result);
 }
@@ -364,20 +356,18 @@ start_p2p_processing (void *cls,
  */
 static void
 handle_start_search (void *cls,
-                     struct GNUNET_SERVER_Client *client,
-                     const struct GNUNET_MessageHeader *message)
+                     struct GNUNET_SERVER_Client *client,
+                     const struct GNUNET_MessageHeader *message)
 {
   struct GSF_PendingRequest *pr;
 
   pr = GSF_local_client_start_search_handler_ (client, message);
   if (NULL == pr)
-    {
-      /* GNUNET_SERVER_receive_done was already called! */
-      return;
-    }
-  GSF_local_lookup_ (pr, 
-                     &start_p2p_processing,
-                     client);
+  {
+    /* GNUNET_SERVER_receive_done was already called! */
+    return;
+  }
+  GSF_local_lookup_ (pr, &start_p2p_processing, client);
 }
 
 
@@ -388,14 +378,13 @@ handle_start_search (void *cls,
  * @param tc unused
  */
 static void
-shutdown_task (void *cls,
-               const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (NULL != GSF_core)
-    {
-      GNUNET_CORE_disconnect (GSF_core);
-      GSF_core = NULL;
-    }
+  {
+    GNUNET_CORE_disconnect (GSF_core);
+    GSF_core = NULL;
+  }
   GSF_put_done_ ();
   GSF_push_done_ ();
   GSF_pending_request_done_ ();
@@ -412,10 +401,10 @@ shutdown_task (void *cls,
   GNUNET_STATISTICS_destroy (GSF_stats, GNUNET_NO);
   GSF_stats = NULL;
   if (GNUNET_SCHEDULER_NO_TASK != cover_age_task)
-    {
-      GNUNET_SCHEDULER_cancel (cover_age_task);
-      cover_age_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (cover_age_task);
+    cover_age_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_FS_indexing_done ();
   GNUNET_LOAD_value_free (datastore_get_load);
   datastore_get_load = NULL;
@@ -436,11 +425,11 @@ shutdown_task (void *cls,
  */
 static int
 consider_peer_for_forwarding (void *cls,
-                              const GNUNET_HashCode *key,
-                              struct GSF_PendingRequest *pr)
+                              const GNUNET_HashCode * key,
+                              struct GSF_PendingRequest *pr)
 {
   struct GSF_ConnectedPeer *cp = cls;
-  
+
   GSF_plan_add_ (cp, pr);
   return GNUNET_YES;
 }
@@ -453,20 +442,19 @@ consider_peer_for_forwarding (void *cls,
  * @param peer peer identity this notification is about
  * @param atsi performance information
  */
-static void 
+static void
 peer_connect_handler (void *cls,
-                      const struct GNUNET_PeerIdentity *peer,
-                      const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                      const struct GNUNET_PeerIdentity *peer,
+                      const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct GSF_ConnectedPeer *cp;
 
   if (0 == memcmp (&my_id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;
-   cp = GSF_peer_connect_handler_ (peer, atsi);
+  cp = GSF_peer_connect_handler_ (peer, atsi);
   if (NULL == cp)
     return;
-  GSF_iterate_pending_requests_ (&consider_peer_for_forwarding,
-                                 cp);
+  GSF_iterate_pending_requests_ (&consider_peer_for_forwarding, cp);
 }
 
 
@@ -484,12 +472,10 @@ peer_connect_handler (void *cls,
  */
 static void
 peer_init_handler (void *cls,
-                   struct GNUNET_CORE_Handle * server,
-                   const struct GNUNET_PeerIdentity *
-                   my_identity,
-                   const struct
-                   GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *
-                   publicKey)
+                   struct GNUNET_CORE_Handle *server,
+                   const struct GNUNET_PeerIdentity *my_identity,
+                   const struct
+                   GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *publicKey)
 {
   my_id = *my_identity;
 }
@@ -503,59 +489,53 @@ peer_init_handler (void *cls,
  */
 static int
 main_init (struct GNUNET_SERVER_Handle *server,
-           const struct GNUNET_CONFIGURATION_Handle *c)
+           const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  static const struct GNUNET_CORE_MessageHandler p2p_handlers[] =
-    {
-      { &handle_p2p_get, 
-        GNUNET_MESSAGE_TYPE_FS_GET, 0 },
-      { &handle_p2p_put, 
-        GNUNET_MESSAGE_TYPE_FS_PUT, 0 },
-      { &GSF_handle_p2p_migration_stop_, 
-        GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
-        sizeof (struct MigrationStopMessage) },
-      { NULL, 0, 0 }
-    };
+  static const struct GNUNET_CORE_MessageHandler p2p_handlers[] = {
+    {&handle_p2p_get,
+     GNUNET_MESSAGE_TYPE_FS_GET, 0},
+    {&handle_p2p_put,
+     GNUNET_MESSAGE_TYPE_FS_PUT, 0},
+    {&GSF_handle_p2p_migration_stop_,
+     GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
+     sizeof (struct MigrationStopMessage)},
+    {NULL, 0, 0}
+  };
   static const struct GNUNET_SERVER_MessageHandler handlers[] = {
-    {&GNUNET_FS_handle_index_start, NULL, 
+    {&GNUNET_FS_handle_index_start, NULL,
      GNUNET_MESSAGE_TYPE_FS_INDEX_START, 0},
-    {&GNUNET_FS_handle_index_list_get, NULL, 
-     GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET, sizeof(struct GNUNET_MessageHeader) },
-    {&GNUNET_FS_handle_unindex, NULL, GNUNET_MESSAGE_TYPE_FS_UNINDEX, 
-     sizeof (struct UnindexMessage) },
-    {&handle_start_search, NULL, GNUNET_MESSAGE_TYPE_FS_START_SEARCH, 
-     0 },
+    {&GNUNET_FS_handle_index_list_get, NULL,
+     GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET,
+     sizeof (struct GNUNET_MessageHeader)},
+    {&GNUNET_FS_handle_unindex, NULL, GNUNET_MESSAGE_TYPE_FS_UNINDEX,
+     sizeof (struct UnindexMessage)},
+    {&handle_start_search, NULL, GNUNET_MESSAGE_TYPE_FS_START_SEARCH,
+     0},
     {NULL, NULL, 0, 0}
   };
 
-  GSF_core = GNUNET_CORE_connect (GSF_cfg,
-                                  2, /* larger? */
-                                  NULL,
-                                  &peer_init_handler,
-                                  &peer_connect_handler,
-                                  &GSF_peer_disconnect_handler_,
-                                  &GSF_peer_status_handler_,
-                                  NULL, GNUNET_NO,
-                                  NULL, GNUNET_NO,
-                                  p2p_handlers);
+  GSF_core = GNUNET_CORE_connect (GSF_cfg, 2,   /* larger? */
+                                  NULL,
+                                  &peer_init_handler,
+                                  &peer_connect_handler,
+                                  &GSF_peer_disconnect_handler_,
+                                  &GSF_peer_status_handler_,
+                                  NULL, GNUNET_NO,
+                                  NULL, GNUNET_NO, p2p_handlers);
   if (NULL == GSF_core)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Failed to connect to `%s' service.\n"),
-                  "core");
-      return GNUNET_SYSERR;
-    }
-  GNUNET_SERVER_disconnect_notify (server, 
-                                   &GSF_client_disconnect_handler_,
-                                   NULL);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                _("Failed to connect to `%s' service.\n"), "core");
+    return GNUNET_SYSERR;
+  }
+  GNUNET_SERVER_disconnect_notify (server,
+                                   &GSF_client_disconnect_handler_, NULL);
   GNUNET_SERVER_add_handlers (server, handlers);
   cover_age_task = GNUNET_SCHEDULER_add_delayed (COVER_AGE_FREQUENCY,
-                                                 &age_cover_counters,
-                                                 NULL);
+                                                 &age_cover_counters, NULL);
   datastore_get_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+                                &shutdown_task, NULL);
   return GNUNET_OK;
 }
 
@@ -573,37 +553,33 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GSF_cfg = cfg;
-  GSF_enable_randomized_delays = GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
+  GSF_enable_randomized_delays =
+      GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
   GSF_dsh = GNUNET_DATASTORE_connect (cfg);
   if (NULL == GSF_dsh)
-    {
-      GNUNET_SCHEDULER_shutdown ();
-      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 ();
-  GNUNET_CONFIGURATION_set_value_string (block_cfg,
-                                         "block",
-                                         "PLUGINS",
-                                         "fs");
+  GNUNET_CONFIGURATION_set_value_string (block_cfg, "block", "PLUGINS", "fs");
   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_dht = GNUNET_DHT_connect (cfg, FS_DHT_HT_SIZE);
   GSF_plan_init ();
   GSF_pending_request_init_ ();
   GSF_connected_peer_init_ ();
   GSF_push_init_ ();
   GSF_put_init_ ();
-  if ( (GNUNET_OK != GNUNET_FS_indexing_init (cfg, GSF_dsh)) ||
-       
-       (GNUNET_OK != main_init (server, cfg)) )
-    {    
-      GNUNET_SCHEDULER_shutdown ();
-      shutdown_task (NULL, NULL);
-      return;   
-    }
+  if ((GNUNET_OK != GNUNET_FS_indexing_init (cfg, GSF_dsh)) ||
+      (GNUNET_OK != main_init (server, cfg)))
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    shutdown_task (NULL, NULL);
+    return;
+  }
 }
 
 
@@ -621,8 +597,7 @@ main (int argc, char *const *argv)
           GNUNET_SERVICE_run (argc,
                               argv,
                               "fs",
-                              GNUNET_SERVICE_OPTION_NONE,
-                              &run, NULL)) ? 0 : 1;
+                              GNUNET_SERVICE_OPTION_NONE, &run, NULL)) ? 0 : 1;
 }
 
 /* end of gnunet-service-fs.c */
diff --git a/src/fs/gnunet-service-fs.h b/src/fs/gnunet-service-fs.h
index bee814318..56604185f 100644
--- a/src/fs/gnunet-service-fs.h
+++ b/src/fs/gnunet-service-fs.h
@@ -167,8 +167,7 @@ extern int GSF_enable_randomized_delays;
  *         GNUNET_NO to process normally (load normal)
  *         GNUNET_SYSERR to process for free (load low)
  */
-int
-GSF_test_get_load_too_high_ (uint32_t priority);
+int GSF_test_get_load_too_high_ (uint32_t priority);
 
 
 /**
@@ -177,8 +176,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);
+void GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start);
 
 
 
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index ea8a84dfe..4e57455b2 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -134,7 +134,7 @@ struct GSF_DelayedHandle
   /**
    * Kept in a doubly-linked list.
    */
-  struct GSF_DelayedHandle *next;  
+  struct GSF_DelayedHandle *next;
 
   /**
    * Kept in a doubly-linked list.
@@ -160,7 +160,7 @@ struct GSF_DelayedHandle
    * Size of the message.
    */
   size_t msize;
-  
+
 };
 
 
@@ -174,7 +174,7 @@ struct PeerRequest
    * Handle to generic request.
    */
   struct GSF_PendingRequest *pr;
-  
+
   /**
    * Handle to specific peer.
    */
@@ -191,7 +191,7 @@ struct PeerRequest
 /**
  * A connected peer.
  */
-struct GSF_ConnectedPeer 
+struct GSF_ConnectedPeer
 {
 
   /**
@@ -330,17 +330,17 @@ get_latency (const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   if (atsi == NULL)
     return GNUNET_TIME_UNIT_SECONDS;
-  while ( (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) &&
-          (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY) )
+  while ((ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) &&
+         (ntohl (atsi->type) != GNUNET_TRANSPORT_ATS_QUALITY_NET_DELAY))
     atsi++;
-  if (ntohl (atsi->type) == GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR) 
-    {
-      GNUNET_break (0);
-      /* how can we not have latency data? */
-      return GNUNET_TIME_UNIT_SECONDS;
-    }
+  if (ntohl (atsi->type) == GNUNET_TRANSPORT_ATS_ARRAY_TERMINATOR)
+  {
+    GNUNET_break (0);
+    /* how can we not have latency data? */
+    return GNUNET_TIME_UNIT_SECONDS;
+  }
   return GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
-                                        ntohl (atsi->value));
+                                        ntohl (atsi->value));
 }
 
 
@@ -352,13 +352,12 @@ get_latency (const struct GNUNET_TRANSPORT_ATS_Information *atsi)
  */
 static void
 update_atsi (struct GSF_ConnectedPeer *cp,
-             const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+             const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct GNUNET_TIME_Relative latency;
 
   latency = get_latency (atsi);
-  GNUNET_LOAD_value_set_decline (cp->ppd.transmission_delay,
-                                 latency);
+  GNUNET_LOAD_value_set_decline (cp->ppd.transmission_delay, latency);
   /* LATER: merge atsi into cp's performance data (if we ever care...) */
 }
 
@@ -384,10 +383,7 @@ GSF_get_peer_performance_data_ (struct GSF_ConnectedPeer *cp)
  * @param buf where to copy the message
  * @return number of bytes copied to buf
  */
-static size_t
-peer_transmit_ready_cb (void *cls,
-                        size_t size,
-                        void *buf);
+static size_t peer_transmit_ready_cb (void *cls, size_t size, void *buf);
 
 
 
@@ -406,11 +402,11 @@ peer_transmit_ready_cb (void *cls,
  */
 static void
 core_reserve_callback (void *cls,
-                       const struct GNUNET_PeerIdentity *peer,
-                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                       int32_t amount,
-                       struct GNUNET_TIME_Relative res_delay,
-                       uint64_t preference);
+                       const struct GNUNET_PeerIdentity *peer,
+                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                       int32_t amount,
+                       struct GNUNET_TIME_Relative res_delay,
+                       uint64_t preference);
 
 
 /**
@@ -426,43 +422,38 @@ schedule_transmission (struct GSF_PeerTransmitHandle *pth)
   struct GNUNET_PeerIdentity target;
   uint64_t ip;
 
-  if ( (NULL != pth->cth) ||
-       (0 != pth->cth_in_progress) )
-    return; /* already done */
+  if ((NULL != pth->cth) || (0 != pth->cth_in_progress))
+    return;                     /* already done */
   cp = pth->cp;
   GNUNET_assert (0 != cp->ppd.pid);
-  GNUNET_PEER_resolve (cp->ppd.pid,
-                       &target);
-  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;
-      ip = cp->inc_preference;
-      cp->inc_preference = 0;
-      cp->irc = GNUNET_CORE_peer_change_preference (GSF_core,
-                                                    &target,
-                                                    GNUNET_TIME_UNIT_FOREVER_REL,
-                                                    GNUNET_BANDWIDTH_VALUE_MAX,
-                                                    DBLOCK_SIZE,
-                                                    ip,
-                                                    &core_reserve_callback,
-                                                    cp);          
-    }
+  GNUNET_PEER_resolve (cp->ppd.pid, &target);
+  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;
+    ip = cp->inc_preference;
+    cp->inc_preference = 0;
+    cp->irc = GNUNET_CORE_peer_change_preference (GSF_core,
+                                                  &target,
+                                                  GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  GNUNET_BANDWIDTH_VALUE_MAX,
+                                                  DBLOCK_SIZE,
+                                                  ip,
+                                                  &core_reserve_callback, cp);
+  }
   GNUNET_assert (pth->cth == NULL);
   pth->cth_in_progress++;
   pth->cth = GNUNET_CORE_notify_transmit_ready (GSF_core,
-                                                GNUNET_YES,
-                                                pth->priority,
-                                                GNUNET_TIME_absolute_get_remaining (pth->timeout),
-                                                &target,
-                                                pth->size,
-                                                &peer_transmit_ready_cb,
-                                                pth);
+                                                GNUNET_YES,
+                                                pth->priority,
+                                                GNUNET_TIME_absolute_get_remaining
+                                                (pth->timeout), &target,
+                                                pth->size,
+                                                &peer_transmit_ready_cb, pth);
   GNUNET_assert (0 < pth->cth_in_progress--);
 }
 
@@ -476,46 +467,43 @@ schedule_transmission (struct GSF_PeerTransmitHandle *pth)
  * @return number of bytes copied to buf
  */
 static size_t
-peer_transmit_ready_cb (void *cls,
-                        size_t size,
-                        void *buf)
+peer_transmit_ready_cb (void *cls, size_t size, void *buf)
 {
   struct GSF_PeerTransmitHandle *pth = cls;
   struct GSF_PeerTransmitHandle *pos;
   struct GSF_ConnectedPeer *cp;
   size_t ret;
 
-  GNUNET_assert ( (NULL == buf) ||
-                  (pth->size <= size) );
+  GNUNET_assert ((NULL == buf) || (pth->size <= size));
   pth->cth = NULL;
   if (pth->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (pth->timeout_task);
-      pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pth->timeout_task);
+    pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   cp = pth->cp;
-  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_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);
-  ret = pth->gmc (pth->gmc_cls, 
-                  size, buf);
+                      GNUNET_TIME_absolute_get_duration
+                      (pth->transmission_request_start_time).rel_value);
+  ret = pth->gmc (pth->gmc_cls, size, buf);
   GNUNET_assert (NULL == pth->cth);
   for (pos = cp->pth_head; pos != NULL; pos = pos->next)
-    {
-      GNUNET_assert (pos != pth);
-      schedule_transmission (pos);
-    }
+  {
+    GNUNET_assert (pos != pth);
+    schedule_transmission (pos);
+  }
   GNUNET_assert (pth->cth == NULL);
   GNUNET_assert (pth->cth_in_progress == 0);
   GNUNET_free (pth);
@@ -530,26 +518,22 @@ peer_transmit_ready_cb (void *cls,
  * @param tc scheduler context
  */
 static void
-retry_reservation (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+retry_reservation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GSF_ConnectedPeer *cp = cls;
   uint64_t ip;
   struct GNUNET_PeerIdentity target;
 
-  GNUNET_PEER_resolve (cp->ppd.pid,
-                       &target);
+  GNUNET_PEER_resolve (cp->ppd.pid, &target);
   cp->irc_delay_task = GNUNET_SCHEDULER_NO_TASK;
   ip = cp->inc_preference;
   cp->inc_preference = 0;
   cp->irc = GNUNET_CORE_peer_change_preference (GSF_core,
-                                                &target,
-                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                                GNUNET_BANDWIDTH_VALUE_MAX,
-                                                DBLOCK_SIZE,
-                                                ip,
-                                                &core_reserve_callback,
-                                                cp);
+                                                &target,
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                GNUNET_BANDWIDTH_VALUE_MAX,
+                                                DBLOCK_SIZE,
+                                                ip, &core_reserve_callback, cp);
 }
 
 
@@ -567,40 +551,37 @@ retry_reservation (void *cls,
  */
 static void
 core_reserve_callback (void *cls,
-                       const struct GNUNET_PeerIdentity *peer,
-                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                       int32_t amount,
-                       struct GNUNET_TIME_Relative res_delay,
-                       uint64_t preference)
+                       const struct GNUNET_PeerIdentity *peer,
+                       struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                       int32_t amount,
+                       struct GNUNET_TIME_Relative res_delay,
+                       uint64_t preference)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GSF_PeerTransmitHandle *pth;
 
   cp->irc = NULL;
   if (0 == amount)
-    {
-      cp->irc_delay_task = GNUNET_SCHEDULER_add_delayed (res_delay,
-                                                         &retry_reservation,
-                                                         cp);
-      return;
-    }
+  {
+    cp->irc_delay_task = GNUNET_SCHEDULER_add_delayed (res_delay,
+                                                       &retry_reservation, cp);
+    return;
+  }
   cp->did_reserve = GNUNET_YES;
   pth = cp->pth_head;
-  if ( (NULL != pth) &&
-       (NULL == pth->cth) )
-    {
-      /* reservation success, try transmission now! */
-      pth->cth_in_progress++;
-      pth->cth = GNUNET_CORE_notify_transmit_ready (GSF_core,
-                                                    GNUNET_YES,
-                                                    pth->priority,
-                                                    GNUNET_TIME_absolute_get_remaining (pth->timeout),
-                                                    peer,
-                                                    pth->size,
-                                                    &peer_transmit_ready_cb,
-                                                    pth);
-      GNUNET_assert (0 < pth->cth_in_progress--);
-    }
+  if ((NULL != pth) && (NULL == pth->cth))
+  {
+    /* reservation success, try transmission now! */
+    pth->cth_in_progress++;
+    pth->cth = GNUNET_CORE_notify_transmit_ready (GSF_core,
+                                                  GNUNET_YES,
+                                                  pth->priority,
+                                                  GNUNET_TIME_absolute_get_remaining
+                                                  (pth->timeout), peer,
+                                                  pth->size,
+                                                  &peer_transmit_ready_cb, pth);
+    GNUNET_assert (0 < pth->cth_in_progress--);
+  }
 }
 
 
@@ -614,7 +595,7 @@ core_reserve_callback (void *cls,
  */
 struct GSF_ConnectedPeer *
 GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
-                           const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                           const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct GSF_ConnectedPeer *cp;
   char *fn;
@@ -624,13 +605,11 @@ GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
   cp->ppd.pid = GNUNET_PEER_intern (peer);
   cp->ppd.transmission_delay = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_ZERO);
   cp->irc = GNUNET_CORE_peer_change_preference (GSF_core,
-                                                peer,
-                                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                                GNUNET_BANDWIDTH_VALUE_MAX,
-                                                DBLOCK_SIZE,
-                                                0,
-                                                &core_reserve_callback,
-                                                cp);
+                                                peer,
+                                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                                GNUNET_BANDWIDTH_VALUE_MAX,
+                                                DBLOCK_SIZE,
+                                                0, &core_reserve_callback, cp);
   fn = get_trust_filename (peer);
   if ((GNUNET_DISK_file_test (fn) == GNUNET_YES) &&
       (sizeof (trust) == GNUNET_DISK_fn_read (fn, &trust, sizeof (trust))))
@@ -638,10 +617,10 @@ GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
   GNUNET_free (fn);
   cp->request_map = GNUNET_CONTAINER_multihashmap_create (128);
   GNUNET_break (GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put (cp_map,
-                                                   &peer->hashPubKey,
-                                                   cp,
-                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+                GNUNET_CONTAINER_multihashmap_put (cp_map,
+                                                   &peer->hashPubKey,
+                                                   cp,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   update_atsi (cp, atsi);
   GSF_push_start_ (cp);
   return cp;
@@ -656,23 +635,20 @@ GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
  * @param tc scheduler context
  */
 static void
-revive_migration (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+revive_migration (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct GNUNET_TIME_Relative bt;
-  
+
   cp->mig_revive_task = GNUNET_SCHEDULER_NO_TASK;
   bt = GNUNET_TIME_absolute_get_remaining (cp->ppd.migration_blocked_until);
   if (0 != bt.rel_value)
-    {
-      /* still time left... */
-      cp->mig_revive_task 
-        = GNUNET_SCHEDULER_add_delayed (bt,
-                                        &revive_migration,
-                                        cp);
-      return;
-    }
+  {
+    /* still time left... */
+    cp->mig_revive_task
+        = GNUNET_SCHEDULER_add_delayed (bt, &revive_migration, cp);
+    return;
+  }
   GSF_push_start_ (cp);
 }
 
@@ -686,9 +662,9 @@ revive_migration (void *cls,
 struct GSF_ConnectedPeer *
 GSF_peer_get_ (const struct GNUNET_PeerIdentity *peer)
 {
-  if (NULL == cp_map) return NULL;
-  return GNUNET_CONTAINER_multihashmap_get (cp_map,
-                                            &peer->hashPubKey);
+  if (NULL == cp_map)
+    return NULL;
+  return GNUNET_CONTAINER_multihashmap_get (cp_map, &peer->hashPubKey);
 }
 
 
@@ -705,36 +681,33 @@ GSF_peer_get_ (const struct GNUNET_PeerIdentity *peer)
  */
 int
 GSF_handle_p2p_migration_stop_ (void *cls,
-                                const struct GNUNET_PeerIdentity *other,
-                                const struct GNUNET_MessageHeader *message,
-                                const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                                const struct GNUNET_PeerIdentity *other,
+                                const struct GNUNET_MessageHeader *message,
+                                const struct GNUNET_TRANSPORT_ATS_Information
+                                *atsi)
 {
-  struct GSF_ConnectedPeer *cp; 
+  struct GSF_ConnectedPeer *cp;
   const struct MigrationStopMessage *msm;
   struct GNUNET_TIME_Relative bt;
 
-  msm = (const struct MigrationStopMessage*) message;
-  cp = GNUNET_CONTAINER_multihashmap_get (cp_map,
-                                          &other->hashPubKey);
+  msm = (const struct MigrationStopMessage *) message;
+  cp = GNUNET_CONTAINER_multihashmap_get (cp_map, &other->hashPubKey);
   if (cp == NULL)
-    {
-      GNUNET_break (0);
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_break (0);
+    return GNUNET_OK;
+  }
   bt = GNUNET_TIME_relative_ntoh (msm->duration);
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              _("Migration of content to peer `%s' blocked for %llu ms\n"),
-              GNUNET_i2s (other),
-              (unsigned long long) bt.rel_value);
+              _("Migration of content to peer `%s' blocked for %llu ms\n"),
+              GNUNET_i2s (other), (unsigned long long) bt.rel_value);
   cp->ppd.migration_blocked_until = GNUNET_TIME_relative_to_absolute (bt);
   if (cp->mig_revive_task == GNUNET_SCHEDULER_NO_TASK)
-    {
-      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);
+  }
   update_atsi (cp, atsi);
   return GNUNET_OK;
 }
@@ -748,32 +721,28 @@ GSF_handle_p2p_migration_stop_ (void *cls,
  * @param buf where to copy the message, NULL on error (peer disconnect)
  * @return number of bytes copied to 'buf', can be 0 (without indicating an error)
  */
-static size_t 
-copy_reply (void *cls,
-            size_t buf_size,
-            void *buf)
+static size_t
+copy_reply (void *cls, size_t buf_size, void *buf)
 {
   struct PutMessage *pm = cls;
   size_t size;
 
   if (buf != NULL)
-    {
-      GNUNET_assert (buf_size >= ntohs (pm->header.size));
-      size = ntohs (pm->header.size);
-      memcpy (buf, pm, size); 
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# replies transmitted to other peers"),
-                                1,
-                                GNUNET_NO); 
-    }
+  {
+    GNUNET_assert (buf_size >= ntohs (pm->header.size));
+    size = ntohs (pm->header.size);
+    memcpy (buf, pm, size);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# replies transmitted to other peers"), 1,
+                              GNUNET_NO);
+  }
   else
-    {
-      size = 0;
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# replies dropped"),
-                                1,
-                                GNUNET_NO); 
-    }
+  {
+    size = 0;
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# replies dropped"), 1, GNUNET_NO);
+  }
   GNUNET_free (pm);
   return size;
 }
@@ -788,9 +757,7 @@ copy_reply (void *cls,
  * @return GNUNET_YES (continue to iterate)
  */
 static int
-cancel_pending_request (void *cls,
-                        const GNUNET_HashCode *query,
-                        void *value)
+cancel_pending_request (void *cls, const GNUNET_HashCode * query, void *value)
 {
   struct PeerRequest *peerreq = value;
   struct GSF_PendingRequest *pr = peerreq->pr;
@@ -798,19 +765,17 @@ cancel_pending_request (void *cls,
   struct GSF_PendingRequestData *prd;
 
   if (peerreq->kill_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (peerreq->kill_task);
-      peerreq->kill_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (peerreq->kill_task);
+    peerreq->kill_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# P2P searches active"),
-                            -1,
-                            GNUNET_NO);
+                            gettext_noop ("# P2P searches active"),
+                            -1, GNUNET_NO);
   prd = GSF_pending_request_get_data_ (pr);
   GNUNET_break (GNUNET_YES ==
-                GNUNET_CONTAINER_multihashmap_remove (cp->request_map,
-                                                      &prd->query,
-                                                      peerreq));
+                GNUNET_CONTAINER_multihashmap_remove (cp->request_map,
+                                                      &prd->query, peerreq));
   GSF_pending_request_cancel_ (pr, GNUNET_NO);
   GNUNET_free (peerreq);
   return GNUNET_OK;
@@ -822,10 +787,9 @@ cancel_pending_request (void *cls,
  *
  * @param cls the request to free
  * @param tc task context
- */ 
+ */
 static void
-peer_request_destroy (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+peer_request_destroy (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PeerRequest *peerreq = cls;
   struct GSF_PendingRequest *pr = peerreq->pr;
@@ -833,9 +797,7 @@ peer_request_destroy (void *cls,
 
   peerreq->kill_task = GNUNET_SCHEDULER_NO_TASK;
   prd = GSF_pending_request_get_data_ (pr);
-  cancel_pending_request (NULL,
-                          &prd->query,
-                          peerreq);
+  cancel_pending_request (NULL, &prd->query, peerreq);
 }
 
 
@@ -846,27 +808,21 @@ peer_request_destroy (void *cls,
  * @param tc scheduler context
  */
 static void
-transmit_delayed_now (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+transmit_delayed_now (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   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);
   if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
-    {
-      GNUNET_free (dh->pm);
-      GNUNET_free (dh);
-      return;
-    }
+  {
+    GNUNET_free (dh->pm);
+    GNUNET_free (dh);
+    return;
+  }
   (void) GSF_peer_transmit_ (cp, GNUNET_NO,
-                             UINT32_MAX,
-                             REPLY_TIMEOUT,
-                             dh->msize,
-                             &copy_reply,
-                             dh->pm);
+                             UINT32_MAX,
+                             REPLY_TIMEOUT, dh->msize, &copy_reply, dh->pm);
   GNUNET_free (dh);
 }
 
@@ -883,12 +839,12 @@ get_randomized_delay ()
 
   /* FIXME: replace 5000 with something relating to current observed P2P message latency */
   ret = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
-                                       GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                                                 5000));
+                                       GNUNET_CRYPTO_random_u32
+                                       (GNUNET_CRYPTO_QUALITY_WEAK, 5000));
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# artificial delays introduced (ms)"),
-                            ret.rel_value,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# artificial delays introduced (ms)"),
+                            ret.rel_value, GNUNET_NO);
 
   return ret;
 }
@@ -913,13 +869,12 @@ get_randomized_delay ()
  */
 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,
-                  enum GNUNET_BLOCK_Type type,
-                  const void *data,
-                  size_t data_len)
+                  enum GNUNET_BLOCK_EvaluationResult eval,
+                  struct GSF_PendingRequest *pr,
+                  uint32_t reply_anonymity_level,
+                  struct GNUNET_TIME_Absolute expiration,
+                  enum GNUNET_BLOCK_Type type,
+                  const void *data, size_t data_len)
 {
   struct PeerRequest *peerreq = cls;
   struct GSF_ConnectedPeer *cp = peerreq->cp;
@@ -927,101 +882,91 @@ handle_p2p_reply (void *cls,
   struct PutMessage *pm;
   size_t msize;
 
-  GNUNET_assert (data_len + sizeof (struct PutMessage) < GNUNET_SERVER_MAX_MESSAGE_SIZE);
+  GNUNET_assert (data_len + sizeof (struct PutMessage) <
+                 GNUNET_SERVER_MAX_MESSAGE_SIZE);
   GNUNET_assert (peerreq->pr == pr);
   prd = GSF_pending_request_get_data_ (pr);
   if (NULL == data)
-    {
-      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);
-      return;
-    }  
+  {
+    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);
+    return;
+  }
   GNUNET_break (type != GNUNET_BLOCK_TYPE_ANY);
-  if ( (prd->type != type) &&
-       (prd->type != GNUNET_BLOCK_TYPE_ANY) )
-    {
-      GNUNET_break (0);
-      return;
-    }
+  if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
+  {
+    GNUNET_break (0);
+    return;
+  }
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Transmitting result for query `%s' to peer\n",
-              GNUNET_h2s (&prd->query));
-#endif  
+              "Transmitting result for query `%s' to peer\n",
+              GNUNET_h2s (&prd->query));
+#endif
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# replies received for other peers"),
-                            1,
-                            GNUNET_NO); 
+                            gettext_noop ("# replies received for other peers"),
+                            1, GNUNET_NO);
   msize = sizeof (struct PutMessage) + data_len;
   if (msize >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  if ((reply_anonymity_level != UINT32_MAX) && (reply_anonymity_level > 1))
+  {
+    if (reply_anonymity_level - 1 > GSF_cover_content_count)
     {
-      GNUNET_break (0);
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop
+                                ("# replies dropped due to insufficient cover traffic"),
+                                1, GNUNET_NO);
       return;
     }
-  if ( (reply_anonymity_level != UINT32_MAX) &&
-       (reply_anonymity_level > 1) )
-    {
-      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);
-    }
-    
+    GSF_cover_content_count -= (reply_anonymity_level - 1);
+  }
+
   pm = GNUNET_malloc (msize);
   pm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_PUT);
   pm->header.size = htons (msize);
   pm->type = htonl (type);
   pm->expiration = GNUNET_TIME_absolute_hton (expiration);
   memcpy (&pm[1], data, data_len);
-  if ( (reply_anonymity_level != UINT32_MAX) &&
-       (reply_anonymity_level != 0) &&
-       (GSF_enable_randomized_delays == GNUNET_YES) )
-    {
-      struct GSF_DelayedHandle *dh;
-
-      dh = GNUNET_malloc (sizeof (struct GSF_DelayedHandle));
-      dh->cp = cp;
-      dh->pm = pm;
-      dh->msize = msize;
-      GNUNET_CONTAINER_DLL_insert (cp->delayed_head,
-                                   cp->delayed_tail,
-                                   dh);
-      dh->delay_task = GNUNET_SCHEDULER_add_delayed (get_randomized_delay (),
-                                                     &transmit_delayed_now,
-                                                     dh);
-    }
+  if ((reply_anonymity_level != UINT32_MAX) &&
+      (reply_anonymity_level != 0) &&
+      (GSF_enable_randomized_delays == GNUNET_YES))
+  {
+    struct GSF_DelayedHandle *dh;
+
+    dh = GNUNET_malloc (sizeof (struct GSF_DelayedHandle));
+    dh->cp = cp;
+    dh->pm = pm;
+    dh->msize = msize;
+    GNUNET_CONTAINER_DLL_insert (cp->delayed_head, cp->delayed_tail, dh);
+    dh->delay_task = GNUNET_SCHEDULER_add_delayed (get_randomized_delay (),
+                                                   &transmit_delayed_now, dh);
+  }
   else
-    {
-      (void) GSF_peer_transmit_ (cp, GNUNET_NO,
-                                 UINT32_MAX,
-                                 REPLY_TIMEOUT,
-                                 msize,
-                                 &copy_reply,
-                                 pm);
-    }
+  {
+    (void) GSF_peer_transmit_ (cp, GNUNET_NO,
+                               UINT32_MAX,
+                               REPLY_TIMEOUT, msize, &copy_reply, pm);
+  }
   if (eval != GNUNET_BLOCK_EVALUATION_OK_LAST)
     return;
   if (GNUNET_SCHEDULER_NO_TASK == 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);
+  }
 }
 
 
@@ -1040,25 +985,25 @@ change_host_trust (struct GSF_ConnectedPeer *cp, int value)
     return 0;
   GNUNET_assert (cp != NULL);
   if (value > 0)
+  {
+    if (cp->ppd.trust + value < cp->ppd.trust)
     {
-      if (cp->ppd.trust + value < cp->ppd.trust)
-        {
-          value = UINT32_MAX - cp->ppd.trust;
-          cp->ppd.trust = UINT32_MAX;
-        }
-      else
-        cp->ppd.trust += value;
+      value = UINT32_MAX - cp->ppd.trust;
+      cp->ppd.trust = UINT32_MAX;
     }
+    else
+      cp->ppd.trust += value;
+  }
   else
+  {
+    if (cp->ppd.trust < -value)
     {
-      if (cp->ppd.trust < -value)
-        {
-          value = -cp->ppd.trust;
-          cp->ppd.trust = 0;
-        }
-      else
-        cp->ppd.trust += value;
+      value = -cp->ppd.trust;
+      cp->ppd.trust = 0;
     }
+    else
+      cp->ppd.trust += value;
+  }
   return value;
 }
 
@@ -1072,8 +1017,7 @@ change_host_trust (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)
   uint32_t ret;
@@ -1082,47 +1026,46 @@ bound_priority (uint32_t prio_in,
 
   ld = GSF_test_get_load_too_high_ (0);
   if (ld == GNUNET_SYSERR)
-    {
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# requests done for free (low load)"),
-                                1,
-                                GNUNET_NO);
-      return 0; /* excess resources */
-    }
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# requests done for free (low load)"), 1,
+                              GNUNET_NO);
+    return 0;                   /* excess resources */
+  }
   if (prio_in > INT32_MAX)
     prio_in = INT32_MAX;
-  ret = - change_host_trust (cp, - (int) prio_in);
+  ret = -change_host_trust (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 ( (ld == GNUNET_YES) && (ret > 0) )
-    {
-      /* try with charging */
-      ld = GSF_test_get_load_too_high_ (ret);
-    }
+  {
+    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 ((ld == GNUNET_YES) && (ret > 0))
+  {
+    /* try with charging */
+    ld = GSF_test_get_load_too_high_ (ret);
+  }
   if (ld == GNUNET_YES)
-    {
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# request dropped, priority insufficient"),
-                                1,
-                                GNUNET_NO);
-      /* undo charge */
-      change_host_trust (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_host_trust (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;
 }
@@ -1144,13 +1087,13 @@ bound_ttl (int32_t ttl_in, uint32_t prio)
 
   if (ttl_in <= 0)
     return ttl_in;
-  allowed = ((unsigned long long) prio) * TTL_DECREMENT / 1000; 
-  if (ttl_in > allowed)      
-    {
-      if (allowed >= (1 << 30))
-        return 1 << 30;
-      return allowed;
-    }
+  allowed = ((unsigned long long) prio) * TTL_DECREMENT / 1000;
+  if (ttl_in > allowed)
+  {
+    if (allowed >= (1 << 30))
+      return 1 << 30;
+    return allowed;
+  }
   return ttl_in;
 }
 
@@ -1168,7 +1111,7 @@ bound_ttl (int32_t ttl_in, uint32_t prio)
  */
 struct GSF_PendingRequest *
 GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
-                       const struct GNUNET_MessageHeader *message)
+                       const struct GNUNET_MessageHeader *message)
 {
   struct PeerRequest *peerreq;
   struct GSF_PendingRequest *pr;
@@ -1177,7 +1120,7 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
   struct GSF_ConnectedPeer *cps;
   const GNUNET_HashCode *namespace;
   const struct GNUNET_PeerIdentity *target;
-  enum GSF_PendingRequestOptions options;                            
+  enum GSF_PendingRequestOptions options;
   uint16_t msize;
   const struct GetMessage *gm;
   unsigned int bits;
@@ -1191,229 +1134,214 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
   GNUNET_PEER_Id spid;
 
   GNUNET_assert (other != NULL);
-  msize = ntohs(message->size);
+  msize = ntohs (message->size);
   if (msize < sizeof (struct GetMessage))
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# GET requests received (from other peers)"),
-                            1,
-                            GNUNET_NO);
-  gm = (const struct GetMessage*) message;
+                            gettext_noop
+                            ("# GET requests received (from other peers)"), 1,
+                            GNUNET_NO);
+  gm = (const struct GetMessage *) message;
   type = ntohl (gm->type);
   bm = ntohl (gm->hash_bitmap);
   bits = 0;
   while (bm > 0)
-    {
-      if (1 == (bm & 1))
-        bits++;
-      bm >>= 1;
-    }
+  {
+    if (1 == (bm & 1))
+      bits++;
+    bm >>= 1;
+  }
   if (msize < sizeof (struct GetMessage) + bits * sizeof (GNUNET_HashCode))
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }  
-  opt = (const GNUNET_HashCode*) &gm[1];
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
+  opt = (const GNUNET_HashCode *) &gm[1];
   bfsize = msize - sizeof (struct GetMessage) - bits * sizeof (GNUNET_HashCode);
   /* bfsize must be power of 2, check! */
-  if (0 != ( (bfsize - 1) & bfsize))
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }
+  if (0 != ((bfsize - 1) & bfsize))
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
   GSF_cover_query_count++;
   bm = ntohl (gm->hash_bitmap);
   bits = 0;
-  cps = GNUNET_CONTAINER_multihashmap_get (cp_map,
-                                           &other->hashPubKey);
+  cps = GNUNET_CONTAINER_multihashmap_get (cp_map, &other->hashPubKey);
   if (NULL == cps)
-    {
-      /* peer must have just disconnected */
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# requests dropped due to initiator not being connected"),
-                                1,
-                                GNUNET_NO);
-      return NULL;
-    }
+  {
+    /* peer must have just disconnected */
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# requests dropped due to initiator not being connected"),
+                              1, GNUNET_NO);
+    return NULL;
+  }
   if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
-    cp = GNUNET_CONTAINER_multihashmap_get (cp_map,
-                                            &opt[bits++]);
+    cp = GNUNET_CONTAINER_multihashmap_get (cp_map, &opt[bits++]);
   else
     cp = cps;
   if (cp == NULL)
-    {
+  {
 #if DEBUG_FS
-      if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Failed to find RETURN-TO peer `%4s' in connection set. Dropping query.\n",
-                    GNUNET_i2s ((const struct GNUNET_PeerIdentity*) &opt[bits-1]));
-      
-      else
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                    "Failed to find peer `%4s' in connection set. Dropping query.\n",
-                    GNUNET_i2s (other));
+    if (0 != (bm & GET_MESSAGE_BIT_RETURN_TO))
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Failed to find RETURN-TO peer `%4s' in connection set. Dropping query.\n",
+                  GNUNET_i2s ((const struct GNUNET_PeerIdentity *)
+                              &opt[bits - 1]));
+
+    else
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Failed to find peer `%4s' in connection set. Dropping query.\n",
+                  GNUNET_i2s (other));
 #endif
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# requests dropped due to missing reverse route"),
-                                1,
-                                GNUNET_NO);
-      return NULL;
-    }
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# requests dropped due to missing reverse route"),
+                              1, GNUNET_NO);
+    return NULL;
+  }
   /* 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... */
+   * peers could find out that we are overloaded by not being
+   * disconnected after sending us a malformed query... */
   priority = bound_priority (ntohl (gm->priority), cps);
   if (priority < 0)
-    {
+  {
 #if DEBUG_FS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Dropping query from `%s', this peer is too busy.\n",
-                  GNUNET_i2s (other));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Dropping query from `%s', this peer is too busy.\n",
+                GNUNET_i2s (other));
 #endif
-      return NULL;
-    }
-#if DEBUG_FS 
+    return NULL;
+  }
+#if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received request for `%s' of type %u from peer `%4s' with flags %u\n",
-              GNUNET_h2s (&gm->query),
-              (unsigned int) type,
-              GNUNET_i2s (other),
-              (unsigned int) bm);
+              "Received request for `%s' of type %u from peer `%4s' with flags %u\n",
+              GNUNET_h2s (&gm->query),
+              (unsigned int) type, GNUNET_i2s (other), (unsigned int) bm);
 #endif
   namespace = (0 != (bm & GET_MESSAGE_BIT_SKS_NAMESPACE)) ? &opt[bits++] : NULL;
-  if ( (type == GNUNET_BLOCK_TYPE_FS_SBLOCK) &&
-       (namespace == NULL) )
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }
-  if ( (type != GNUNET_BLOCK_TYPE_FS_SBLOCK) &&
-       (namespace != NULL) )
-    {
-      GNUNET_break_op (0);
-      return NULL;
-    }
-  target = (0 != (bm & GET_MESSAGE_BIT_TRANSMIT_TO)) ? ((const struct GNUNET_PeerIdentity*) &opt[bits++]) : NULL;
+  if ((type == GNUNET_BLOCK_TYPE_FS_SBLOCK) && (namespace == NULL))
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
+  if ((type != GNUNET_BLOCK_TYPE_FS_SBLOCK) && (namespace != NULL))
+  {
+    GNUNET_break_op (0);
+    return NULL;
+  }
+  target =
+      (0 !=
+       (bm & GET_MESSAGE_BIT_TRANSMIT_TO)) ? ((const struct GNUNET_PeerIdentity
+                                               *) &opt[bits++]) : NULL;
   options = 0;
   spid = 0;
-  if ( (GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1 + priority)) ||
-       (GNUNET_LOAD_get_average (cp->ppd.transmission_delay) > 
-        GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value * 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 */
-      priority = 0;
-      options |= GSF_PRO_FORWARD_ONLY;
-      spid = GNUNET_PEER_intern (other);
-      GNUNET_assert (0 != spid);
-    }
+  if ((GNUNET_LOAD_get_load (cp->ppd.transmission_delay) > 3 * (1 + priority))
+      || (GNUNET_LOAD_get_average (cp->ppd.transmission_delay) >
+          GNUNET_CONSTANTS_MAX_CORK_DELAY.rel_value * 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 */
+    priority = 0;
+    options |= GSF_PRO_FORWARD_ONLY;
+    spid = GNUNET_PEER_intern (other);
+    GNUNET_assert (0 != spid);
+  }
   ttl = bound_ttl (ntohl (gm->ttl), priority);
   /* decrement ttl (always) */
   ttl_decrement = 2 * TTL_DECREMENT +
-    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                              TTL_DECREMENT);
-  if ( (ttl < 0) &&
-       (((int32_t)(ttl - ttl_decrement)) > 0) )
-    {
+      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, TTL_DECREMENT);
+  if ((ttl < 0) && (((int32_t) (ttl - ttl_decrement)) > 0))
+  {
 #if DEBUG_FS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
-                  GNUNET_i2s (other),
-                  ttl,
-                  ttl_decrement);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Dropping query from `%s' due to TTL underflow (%d - %u).\n",
+                GNUNET_i2s (other), ttl, ttl_decrement);
 #endif
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# requests dropped due TTL underflow"),
-                                1,
-                                GNUNET_NO);
-      /* integer underflow => drop (should be very rare)! */      
-      return NULL;
-    } 
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# requests dropped due TTL underflow"), 1,
+                              GNUNET_NO);
+    /* integer underflow => drop (should be very rare)! */
+    return NULL;
+  }
   ttl -= ttl_decrement;
 
   /* test if the request already exists */
-  peerreq = GNUNET_CONTAINER_multihashmap_get (cp->request_map,
-                                               &gm->query);
-  if (peerreq != NULL) 
-    {      
-      pr = peerreq->pr;
-      prd = GSF_pending_request_get_data_ (pr);
-      if ( (prd->type == type) &&
-           ( (type != GNUNET_BLOCK_TYPE_FS_SBLOCK) ||
-             (0 == memcmp (&prd->namespace,
-                           namespace,
-                           sizeof (GNUNET_HashCode))) ) )
-        {
-          if (prd->ttl.abs_value >= GNUNET_TIME_absolute_get().abs_value + ttl)
-            {
-              /* existing request has higher TTL, drop new one! */
-              prd->priority += priority;
+  peerreq = GNUNET_CONTAINER_multihashmap_get (cp->request_map, &gm->query);
+  if (peerreq != NULL)
+  {
+    pr = peerreq->pr;
+    prd = GSF_pending_request_get_data_ (pr);
+    if ((prd->type == type) &&
+        ((type != GNUNET_BLOCK_TYPE_FS_SBLOCK) ||
+         (0 == memcmp (&prd->namespace, namespace, sizeof (GNUNET_HashCode)))))
+    {
+      if (prd->ttl.abs_value >= GNUNET_TIME_absolute_get ().abs_value + ttl)
+      {
+        /* existing request has higher TTL, drop new one! */
+        prd->priority += priority;
 #if DEBUG_FS
-              GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                          "Have existing request with higher TTL, dropping new request.\n",
-                          GNUNET_i2s (other));
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                    "Have existing request with higher TTL, dropping new request.\n",
+                    GNUNET_i2s (other));
 #endif
-              GNUNET_STATISTICS_update (GSF_stats,
-                                        gettext_noop ("# requests dropped due to higher-TTL request"),
-                                        1,
-                                        GNUNET_NO);
-              return NULL;
-            }
-          /* existing request has lower TTL, drop old one! */
-          GNUNET_STATISTICS_update (GSF_stats,
-                                    gettext_noop ("# P2P searches active"),
-                                    -1,
-                                    GNUNET_NO);
-          priority += prd->priority;
-          GSF_pending_request_cancel_ (pr, GNUNET_YES);
-          GNUNET_assert (GNUNET_YES ==
-                         GNUNET_CONTAINER_multihashmap_remove (cp->request_map,
-                                                               &gm->query,
-                                                               peerreq));
-          if (peerreq->kill_task != GNUNET_SCHEDULER_NO_TASK)
-            {
-              GNUNET_SCHEDULER_cancel (peerreq->kill_task);
-              peerreq->kill_task = GNUNET_SCHEDULER_NO_TASK;
-            }
-          GNUNET_free (peerreq);
-        }
+        GNUNET_STATISTICS_update (GSF_stats,
+                                  gettext_noop
+                                  ("# requests dropped due to higher-TTL request"),
+                                  1, GNUNET_NO);
+        return NULL;
+      }
+      /* existing request has lower TTL, drop old one! */
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop ("# P2P searches active"),
+                                -1, GNUNET_NO);
+      priority += prd->priority;
+      GSF_pending_request_cancel_ (pr, GNUNET_YES);
+      GNUNET_assert (GNUNET_YES ==
+                     GNUNET_CONTAINER_multihashmap_remove (cp->request_map,
+                                                           &gm->query,
+                                                           peerreq));
+      if (peerreq->kill_task != GNUNET_SCHEDULER_NO_TASK)
+      {
+        GNUNET_SCHEDULER_cancel (peerreq->kill_task);
+        peerreq->kill_task = GNUNET_SCHEDULER_NO_TASK;
+      }
+      GNUNET_free (peerreq);
     }
-  
+  }
+
   peerreq = GNUNET_malloc (sizeof (struct PeerRequest));
-  peerreq->cp = cp; 
+  peerreq->cp = cp;
   pr = GSF_pending_request_create_ (options,
-                                    type,
-                                    &gm->query,
-                                    namespace,
-                                    target,
-                                    (bfsize > 0) ? (const char*)&opt[bits] : NULL,
-                                    bfsize,
-                                    ntohl (gm->filter_mutator),
-                                    1 /* anonymity */,
-                                    (uint32_t) priority,
-                                    ttl,
-                                    spid,
-                                    NULL, 0, /* replies_seen */
-                                    &handle_p2p_reply,
-                                    peerreq);
+                                    type,
+                                    &gm->query,
+                                    namespace,
+                                    target,
+                                    (bfsize >
+                                     0) ? (const char *) &opt[bits] : NULL,
+                                    bfsize, ntohl (gm->filter_mutator),
+                                    1 /* anonymity */ ,
+                                    (uint32_t) priority, ttl, spid, NULL, 0,    /* replies_seen */
+                                    &handle_p2p_reply, peerreq);
   GNUNET_assert (NULL != pr);
   peerreq->pr = pr;
   GNUNET_break (GNUNET_OK ==
-                GNUNET_CONTAINER_multihashmap_put (cp->request_map,
-                                                   &gm->query,
-                                                   peerreq,
-                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
-  GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# P2P query messages received and processed"),
-                            1,
-                            GNUNET_NO);
+                GNUNET_CONTAINER_multihashmap_put (cp->request_map,
+                                                   &gm->query,
+                                                   peerreq,
+                                                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE));
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# P2P searches active"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# P2P query messages received and processed"), 1,
+                            GNUNET_NO);
+  GNUNET_STATISTICS_update (GSF_stats, gettext_noop ("# P2P searches active"),
+                            1, GNUNET_NO);
   return pr;
 }
 
@@ -1426,34 +1354,29 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
  * @param tc scheduler context
  */
 static void
-peer_transmit_timeout (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+peer_transmit_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GSF_PeerTransmitHandle *pth = cls;
   struct GSF_ConnectedPeer *cp;
 
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Timeout trying to transmit to other peer\n");
-#endif  
+              "Timeout trying to transmit to other peer\n");
+#endif
   pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   cp = pth->cp;
-  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)
-    GNUNET_assert (0 < cp->ppd.pending_queries--);    
+    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,
-                      UINT64_MAX);
+  GNUNET_LOAD_update (cp->ppd.transmission_delay, UINT64_MAX);
   if (NULL != pth->cth)
-    {
-      GNUNET_CORE_notify_transmit_ready_cancel (pth->cth);
-      pth->cth = NULL;
-    }
-  pth->gmc (pth->gmc_cls, 
-            0, NULL);
+  {
+    GNUNET_CORE_notify_transmit_ready_cancel (pth->cth);
+    pth->cth = NULL;
+  }
+  pth->gmc (pth->gmc_cls, 0, NULL);
   GNUNET_assert (0 == pth->cth_in_progress);
   GNUNET_free (pth);
 }
@@ -1475,12 +1398,10 @@ peer_transmit_timeout (void *cls,
  */
 struct GSF_PeerTransmitHandle *
 GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
-                    int is_query,
-                    uint32_t priority,
-                    struct GNUNET_TIME_Relative timeout,
-                    size_t size,
-                    GSF_GetMessageCallback gmc,
-                    void *gmc_cls)
+                    int is_query,
+                    uint32_t priority,
+                    struct GNUNET_TIME_Relative timeout,
+                    size_t size, GSF_GetMessageCallback gmc, void *gmc_cls)
 {
   struct GSF_PeerTransmitHandle *pth;
   struct GSF_PeerTransmitHandle *pos;
@@ -1498,28 +1419,22 @@ GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
   /* insertion sort (by priority, descending) */
   prev = NULL;
   pos = cp->pth_head;
-  while ( (pos != NULL) &&
-          (pos->priority > priority) )
-    {
-      prev = pos;
-      pos = pos->next;
-    }
+  while ((pos != NULL) && (pos->priority > priority))
+  {
+    prev = pos;
+    pos = pos->next;
+  }
   if (prev == NULL)
-    GNUNET_CONTAINER_DLL_insert (cp->pth_head,
-                                 cp->pth_tail,
-                                 pth);
+    GNUNET_CONTAINER_DLL_insert (cp->pth_head, cp->pth_tail, pth);
   else
-    GNUNET_CONTAINER_DLL_insert_after (cp->pth_head,
-                                       cp->pth_tail,
-                                       prev,
-                                       pth);
+    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++;
   pth->timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
-                                                    &peer_transmit_timeout,
-                                                    pth);
+                                                    &peer_transmit_timeout,
+                                                    pth);
   schedule_transmission (pth);
   return pth;
 }
@@ -1536,21 +1451,19 @@ GSF_peer_transmit_cancel_ (struct GSF_PeerTransmitHandle *pth)
   struct GSF_ConnectedPeer *cp;
 
   if (pth->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    {
-      GNUNET_SCHEDULER_cancel (pth->timeout_task);
-      pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pth->timeout_task);
+    pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL != pth->cth)
-    {
-      GNUNET_CORE_notify_transmit_ready_cancel (pth->cth);
-      pth->cth = NULL;
-    }
+  {
+    GNUNET_CORE_notify_transmit_ready_cancel (pth->cth);
+    pth->cth = NULL;
+  }
   cp = pth->cp;
-  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)
-    GNUNET_assert (0 < cp->ppd.pending_queries--);    
+    GNUNET_assert (0 < cp->ppd.pending_queries--);
   else if (GNUNET_NO == pth->is_query)
     GNUNET_assert (0 < cp->ppd.pending_replies--);
   GNUNET_assert (0 == pth->cth_in_progress);
@@ -1567,14 +1480,18 @@ GSF_peer_transmit_cancel_ (struct GSF_PeerTransmitHandle *pth)
  */
 void
 GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp,
-                              struct GNUNET_TIME_Absolute request_time,
-                              uint32_t request_priority)
+                              struct GNUNET_TIME_Absolute request_time,
+                              uint32_t request_priority)
 {
   struct GNUNET_TIME_Relative delay;
 
-  delay = GNUNET_TIME_absolute_get_duration (request_time);  
-  cp->ppd.avg_reply_delay.rel_value = (cp->ppd.avg_reply_delay.rel_value * (RUNAVG_DELAY_N-1) + delay.rel_value) / RUNAVG_DELAY_N;
-  cp->ppd.avg_priority = (cp->ppd.avg_priority * (RUNAVG_DELAY_N-1) + request_priority) / RUNAVG_DELAY_N;
+  delay = GNUNET_TIME_absolute_get_duration (request_time);
+  cp->ppd.avg_reply_delay.rel_value =
+      (cp->ppd.avg_reply_delay.rel_value * (RUNAVG_DELAY_N - 1) +
+       delay.rel_value) / RUNAVG_DELAY_N;
+  cp->ppd.avg_priority =
+      (cp->ppd.avg_priority * (RUNAVG_DELAY_N - 1) +
+       request_priority) / RUNAVG_DELAY_N;
 }
 
 
@@ -1587,9 +1504,10 @@ GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_peer_update_responder_client_ (struct GSF_ConnectedPeer *cp,
-                                   struct GSF_LocalClient *initiator_client)
+                                   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;
 }
 
 
@@ -1602,7 +1520,7 @@ GSF_peer_update_responder_client_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_peer_update_responder_peer_ (struct GSF_ConnectedPeer *cp,
-                                 const struct GSF_ConnectedPeer *initiator_peer)
+                                 const struct GSF_ConnectedPeer *initiator_peer)
 {
   unsigned int woff;
 
@@ -1627,16 +1545,15 @@ GSF_peer_update_responder_peer_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_peer_status_handler_ (void *cls,
-                          const struct GNUNET_PeerIdentity *peer,
-                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
-                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                          struct GNUNET_TIME_Absolute timeout,
-                          const struct GNUNET_TRANSPORT_ATS_Information *atsi)
+                          const struct GNUNET_PeerIdentity *peer,
+                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                          struct GNUNET_TIME_Absolute timeout,
+                          const struct GNUNET_TRANSPORT_ATS_Information *atsi)
 {
   struct GSF_ConnectedPeer *cp;
 
-  cp = GNUNET_CONTAINER_multihashmap_get (cp_map,
-                                          &peer->hashPubKey);
+  cp = GNUNET_CONTAINER_multihashmap_get (cp_map, &peer->hashPubKey);
   GNUNET_assert (NULL != cp);
   update_atsi (cp, atsi);
 }
@@ -1650,40 +1567,36 @@ GSF_peer_status_handler_ (void *cls,
  * @param peer identity of peer that connected
  */
 void
-GSF_peer_disconnect_handler_ (void *cls,
-                              const struct GNUNET_PeerIdentity *peer)
+GSF_peer_disconnect_handler_ (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   struct GSF_ConnectedPeer *cp;
   struct GSF_PeerTransmitHandle *pth;
   struct GSF_DelayedHandle *dh;
 
-  cp = GNUNET_CONTAINER_multihashmap_get (cp_map,
-                                          &peer->hashPubKey);
+  cp = GNUNET_CONTAINER_multihashmap_get (cp_map, &peer->hashPubKey);
   if (NULL == cp)
-    return; /* must have been disconnect from core with
-               'peer' == my_id, ignore */
+    return;                     /* must have been disconnect from core with
+                                 * 'peer' == my_id, ignore */
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (cp_map,
-                                                       &peer->hashPubKey,
-                                                       cp));
+                 GNUNET_CONTAINER_multihashmap_remove (cp_map,
+                                                       &peer->hashPubKey, cp));
   if (NULL != cp->migration_pth)
-    {
-      GSF_peer_transmit_cancel_ (cp->migration_pth);
-      cp->migration_pth = NULL;
-    }
+  {
+    GSF_peer_transmit_cancel_ (cp->migration_pth);
+    cp->migration_pth = NULL;
+  }
   if (NULL != cp->irc)
-    {
-      GNUNET_CORE_peer_change_preference_cancel (cp->irc);
-      cp->irc = NULL;
-    }
+  {
+    GNUNET_CORE_peer_change_preference_cancel (cp->irc);
+    cp->irc = NULL;
+  }
   if (GNUNET_SCHEDULER_NO_TASK != cp->irc_delay_task)
-    {
-      GNUNET_SCHEDULER_cancel (cp->irc_delay_task);
-      cp->irc_delay_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (cp->irc_delay_task);
+    cp->irc_delay_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_CONTAINER_multihashmap_iterate (cp->request_map,
-                                         &cancel_pending_request,
-                                         cp);
+                                         &cancel_pending_request, cp);
   GNUNET_CONTAINER_multihashmap_destroy (cp->request_map);
   cp->request_map = NULL;
   GSF_plan_notify_peer_disconnect_ (cp);
@@ -1692,40 +1605,35 @@ GSF_peer_disconnect_handler_ (void *cls,
   memset (cp->ppd.last_p2p_replies, 0, sizeof (cp->ppd.last_p2p_replies));
   GSF_push_stop_ (cp);
   while (NULL != (pth = cp->pth_head))
+  {
+    if (NULL != pth->cth)
     {
-      if (NULL != pth->cth)
-        {
-          GNUNET_CORE_notify_transmit_ready_cancel (pth->cth);
-          pth->cth = NULL;
-        }
-      if (pth->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-        {
-          GNUNET_SCHEDULER_cancel (pth->timeout_task);
-          pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      GNUNET_CONTAINER_DLL_remove (cp->pth_head,
-                                   cp->pth_tail,
-                                   pth);
-      GNUNET_assert (0 == pth->cth_in_progress);
-      pth->gmc (pth->gmc_cls, 
-                0, NULL);
-      GNUNET_free (pth);
+      GNUNET_CORE_notify_transmit_ready_cancel (pth->cth);
+      pth->cth = NULL;
     }
-  while (NULL != (dh = cp->delayed_head))
+    if (pth->timeout_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_CONTAINER_DLL_remove (cp->delayed_head,
-                                   cp->delayed_tail,
-                                   dh);
-      GNUNET_SCHEDULER_cancel (dh->delay_task);
-      GNUNET_free (dh->pm);
-      GNUNET_free (dh);
+      GNUNET_SCHEDULER_cancel (pth->timeout_task);
+      pth->timeout_task = GNUNET_SCHEDULER_NO_TASK;
     }
+    GNUNET_CONTAINER_DLL_remove (cp->pth_head, cp->pth_tail, pth);
+    GNUNET_assert (0 == pth->cth_in_progress);
+    pth->gmc (pth->gmc_cls, 0, NULL);
+    GNUNET_free (pth);
+  }
+  while (NULL != (dh = cp->delayed_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (cp->delayed_head, cp->delayed_tail, dh);
+    GNUNET_SCHEDULER_cancel (dh->delay_task);
+    GNUNET_free (dh->pm);
+    GNUNET_free (dh);
+  }
   GNUNET_PEER_change_rc (cp->ppd.pid, -1);
   if (GNUNET_SCHEDULER_NO_TASK != cp->mig_revive_task)
-    {
-      GNUNET_SCHEDULER_cancel (cp->mig_revive_task);
-      cp->mig_revive_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (cp->mig_revive_task);
+    cp->mig_revive_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_free (cp);
 }
 
@@ -1756,17 +1664,12 @@ struct IterationContext
  * @return GNUNET_YES to continue iteration
  */
 static int
-call_iterator (void *cls,
-               const GNUNET_HashCode *key,
-               void *value)
+call_iterator (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct IterationContext *ic = cls;
   struct GSF_ConnectedPeer *cp = value;
-  
-  ic->it (ic->it_cls,
-          (const struct GNUNET_PeerIdentity*) key,
-          cp,
-          &cp->ppd);
+
+  ic->it (ic->it_cls, (const struct GNUNET_PeerIdentity *) key, cp, &cp->ppd);
   return GNUNET_YES;
 }
 
@@ -1778,16 +1681,13 @@ call_iterator (void *cls,
  * @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)
 {
   struct IterationContext ic;
 
   ic.it = it;
   ic.it_cls = it_cls;
-  GNUNET_CONTAINER_multihashmap_iterate (cp_map,
-                                         &call_iterator,
-                                         &ic);
+  GNUNET_CONTAINER_multihashmap_iterate (cp_map, &call_iterator, &ic);
 }
 
 
@@ -1799,11 +1699,10 @@ GSF_iterate_connected_peers_ (GSF_ConnectedPeerIterator it,
  */
 void
 GSF_connected_peer_get_identity_ (const struct GSF_ConnectedPeer *cp,
-                                  struct GNUNET_PeerIdentity *id)
+                                  struct GNUNET_PeerIdentity *id)
 {
   GNUNET_assert (0 != cp->ppd.pid);
-  GNUNET_PEER_resolve (cp->ppd.pid,
-                       id);
+  GNUNET_PEER_resolve (cp->ppd.pid, id);
 }
 
 
@@ -1816,9 +1715,7 @@ GSF_connected_peer_get_identity_ (const struct GSF_ConnectedPeer *cp,
  * @return number of bytes copied to buf
  */
 static size_t
-create_migration_stop_message (void *cls,
-                               size_t size,
-                               void *buf)
+create_migration_stop_message (void *cls, size_t size, void *buf)
 {
   struct GSF_ConnectedPeer *cp = cls;
   struct MigrationStopMessage msm;
@@ -1830,7 +1727,9 @@ create_migration_stop_message (void *cls,
   msm.header.size = htons (sizeof (struct MigrationStopMessage));
   msm.header.type = htons (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));
+  msm.duration =
+      GNUNET_TIME_relative_hton (GNUNET_TIME_absolute_get_remaining
+                                 (cp->last_migration_block));
   memcpy (buf, &msm, sizeof (struct MigrationStopMessage));
   return sizeof (struct MigrationStopMessage);
 }
@@ -1845,33 +1744,35 @@ create_migration_stop_message (void *cls,
  */
 void
 GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
-                           struct GNUNET_TIME_Relative block_time)
+                           struct GNUNET_TIME_Relative block_time)
 {
-  if (GNUNET_TIME_absolute_get_remaining (cp->last_migration_block).rel_value > block_time.rel_value)
-    {
+  if (GNUNET_TIME_absolute_get_remaining (cp->last_migration_block).rel_value >
+      block_time.rel_value)
+  {
 #if DEBUG_FS && 0
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-          "Migration already blocked for another %llu ms\n",
-                  (unsigned long long) GNUNET_TIME_absolute_get_remaining (cp->last_migration_block).rel_value);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Migration already blocked for another %llu ms\n",
+                (unsigned long long)
+                GNUNET_TIME_absolute_get_remaining
+                (cp->last_migration_block).rel_value);
 #endif
-      return; /* already blocked */
-    }
+    return;                     /* already blocked */
+  }
 #if DEBUG_FS && 0
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking to stop migration for %llu ms\n",
-              (unsigned long long) block_time.rel_value);
+              "Asking to stop migration for %llu ms\n",
+              (unsigned long long) block_time.rel_value);
 #endif
   cp->last_migration_block = GNUNET_TIME_relative_to_absolute (block_time);
   if (cp->migration_pth != NULL)
     GSF_peer_transmit_cancel_ (cp->migration_pth);
-  cp->migration_pth 
-    = GSF_peer_transmit_ (cp,
-                          GNUNET_SYSERR,
-                          UINT32_MAX,
-                          GNUNET_TIME_UNIT_FOREVER_REL,
-                          sizeof (struct MigrationStopMessage),
-                          &create_migration_stop_message,
-                          cp);
+  cp->migration_pth
+      = GSF_peer_transmit_ (cp,
+                            GNUNET_SYSERR,
+                            UINT32_MAX,
+                            GNUNET_TIME_UNIT_FOREVER_REL,
+                            sizeof (struct MigrationStopMessage),
+                            &create_migration_stop_message, cp);
 }
 
 
@@ -1884,9 +1785,7 @@ GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
  * @return GNUNET_OK to continue iteration
  */
 static int
-flush_trust (void *cls,
-             const GNUNET_HashCode *key,
-             void *value)
+flush_trust (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GSF_ConnectedPeer *cp = value;
   char *fn;
@@ -1894,26 +1793,27 @@ flush_trust (void *cls,
   struct GNUNET_PeerIdentity pid;
 
   if (cp->ppd.trust == cp->disk_trust)
-    return GNUNET_OK;                     /* unchanged */
+    return GNUNET_OK;           /* unchanged */
   GNUNET_assert (0 != cp->ppd.pid);
-  GNUNET_PEER_resolve (cp->ppd.pid,
-                       &pid);
+  GNUNET_PEER_resolve (cp->ppd.pid, &pid);
   fn = get_trust_filename (&pid);
   if (cp->ppd.trust == 0)
-    {
-      if ((0 != UNLINK (fn)) && (errno != ENOENT))
-        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
-                                  GNUNET_ERROR_TYPE_BULK, "unlink", fn);
-    }
+  {
+    if ((0 != UNLINK (fn)) && (errno != ENOENT))
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING |
+                                GNUNET_ERROR_TYPE_BULK, "unlink", fn);
+  }
   else
-    {
-      trust = htonl (cp->ppd.trust);
-      if (sizeof(uint32_t) == GNUNET_DISK_fn_write (fn, &trust, 
-                                                    sizeof(uint32_t),
-                                                    GNUNET_DISK_PERM_USER_READ | GNUNET_DISK_PERM_USER_WRITE
-                                                    | GNUNET_DISK_PERM_GROUP_READ | GNUNET_DISK_PERM_OTHER_READ))
-        cp->disk_trust = cp->ppd.trust;
-    }
+  {
+    trust = htonl (cp->ppd.trust);
+    if (sizeof (uint32_t) == GNUNET_DISK_fn_write (fn, &trust,
+                                                   sizeof (uint32_t),
+                                                   GNUNET_DISK_PERM_USER_READ |
+                                                   GNUNET_DISK_PERM_USER_WRITE |
+                                                   GNUNET_DISK_PERM_GROUP_READ |
+                                                   GNUNET_DISK_PERM_OTHER_READ))
+      cp->disk_trust = cp->ppd.trust;
+  }
   GNUNET_free (fn);
   return GNUNET_OK;
 }
@@ -1930,7 +1830,7 @@ flush_trust (void *cls,
  */
 void
 GSF_connected_peer_change_preference_ (struct GSF_ConnectedPeer *cp,
-                                       uint64_t pref)
+                                       uint64_t pref)
 {
   cp->inc_preference += pref;
 }
@@ -1943,22 +1843,17 @@ GSF_connected_peer_change_preference_ (struct GSF_ConnectedPeer *cp,
  * @param tc task context, not used
  */
 static void
-cron_flush_trust (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+cron_flush_trust (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
   if (NULL == cp_map)
     return;
-  GNUNET_CONTAINER_multihashmap_iterate (cp_map,
-                                         &flush_trust,
-                                         NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (cp_map, &flush_trust, NULL);
   if (NULL == tc)
     return;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
-  GNUNET_SCHEDULER_add_delayed (TRUST_FLUSH_FREQ, 
-                                &cron_flush_trust, 
-                                NULL);
+  GNUNET_SCHEDULER_add_delayed (TRUST_FLUSH_FREQ, &cron_flush_trust, NULL);
 }
 
 
@@ -1976,7 +1871,7 @@ GSF_connected_peer_init_ ()
                                                           &trustDirectory));
   GNUNET_DISK_directory_create (trustDirectory);
   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                      &cron_flush_trust, NULL);
+                                      &cron_flush_trust, NULL);
 }
 
 
@@ -1988,13 +1883,10 @@ GSF_connected_peer_init_ ()
  * @param value value in the hash map (peer entry)
  * @return GNUNET_YES (we should continue to iterate)
  */
-static int 
-clean_peer (void *cls,
-            const GNUNET_HashCode * key,
-            void *value)
+static int
+clean_peer (void *cls, const GNUNET_HashCode * key, void *value)
 {
-  GSF_peer_disconnect_handler_ (NULL, 
-                                (const struct GNUNET_PeerIdentity*) key);
+  GSF_peer_disconnect_handler_ (NULL, (const struct GNUNET_PeerIdentity *) key);
   return GNUNET_YES;
 }
 
@@ -2006,9 +1898,7 @@ void
 GSF_connected_peer_done_ ()
 {
   cron_flush_trust (NULL, NULL);
-  GNUNET_CONTAINER_multihashmap_iterate (cp_map,
-                                         &clean_peer,
-                                         NULL);
+  GNUNET_CONTAINER_multihashmap_iterate (cp_map, &clean_peer, NULL);
   GNUNET_CONTAINER_multihashmap_destroy (cp_map);
   cp_map = NULL;
   GNUNET_free (trustDirectory);
@@ -2024,16 +1914,14 @@ GSF_connected_peer_done_ ()
  * @param value value in the hash map (peer entry)
  * @return GNUNET_YES (we should continue to iterate)
  */
-static int 
-clean_local_client (void *cls,
-                    const GNUNET_HashCode * key,
-                    void *value)
+static int
+clean_local_client (void *cls, const GNUNET_HashCode * key, void *value)
 {
   const struct GSF_LocalClient *lc = cls;
   struct GSF_ConnectedPeer *cp = value;
   unsigned int i;
 
-  for (i=0;i<CS2P_SUCCESS_LIST_SIZE;i++)
+  for (i = 0; i < CS2P_SUCCESS_LIST_SIZE; i++)
     if (cp->ppd.last_client_replies[i] == lc)
       cp->ppd.last_client_replies[i] = NULL;
   return GNUNET_YES;
@@ -2050,10 +1938,9 @@ void
 GSF_handle_local_client_disconnect_ (const struct GSF_LocalClient *lc)
 {
   if (NULL == cp_map)
-    return; /* already cleaned up */
+    return;                     /* already cleaned up */
   GNUNET_CONTAINER_multihashmap_iterate (cp_map,
-                                         &clean_local_client,
-                                         (void*) lc);
+                                         &clean_local_client, (void *) lc);
 }
 
 
diff --git a/src/fs/gnunet-service-fs_cp.h b/src/fs/gnunet-service-fs_cp.h
index 2925dd8ae..c9485f23b 100644
--- a/src/fs/gnunet-service-fs_cp.h
+++ b/src/fs/gnunet-service-fs_cp.h
@@ -59,7 +59,7 @@ struct GSF_PeerPerformanceData
    * getting a reply (only calculated over the requests for
    * which we actually got a reply).   Calculated
    * as a moving average: new_delay = ((n-1)*last_delay+curr_delay) / n
-   */ 
+   */
   struct GNUNET_TIME_Relative avg_reply_delay;
 
   /**
@@ -125,10 +125,11 @@ struct GSF_PeerPerformanceData
  * @param cp handle to the connected peer record
  * @param perf peer performance data
  */
-typedef void (*GSF_ConnectedPeerIterator)(void *cls,
-                                          const struct GNUNET_PeerIdentity *peer,
-                                          struct GSF_ConnectedPeer *cp,
-                                          const struct GSF_PeerPerformanceData *ppd);
+typedef void (*GSF_ConnectedPeerIterator) (void *cls,
+                                           const struct GNUNET_PeerIdentity *
+                                           peer, struct GSF_ConnectedPeer * cp,
+                                           const struct GSF_PeerPerformanceData
+                                           * ppd);
 
 
 /**
@@ -139,9 +140,8 @@ typedef void (*GSF_ConnectedPeerIterator)(void *cls,
  * @param buf where to copy the message, NULL on error (peer disconnect)
  * @return number of bytes copied to 'buf', can be 0 (without indicating an error)
  */
-typedef size_t (*GSF_GetMessageCallback)(void *cls,
-                                         size_t buf_size,
-                                         void *buf);
+typedef size_t (*GSF_GetMessageCallback) (void *cls,
+                                          size_t buf_size, void *buf);
 
 
 /**
@@ -151,9 +151,9 @@ typedef size_t (*GSF_GetMessageCallback)(void *cls,
  * @param cp handle to the connected peer record
  * @param success GNUNET_YES on success, GNUNET_NO on failure
  */
-typedef void (*GSF_PeerReserveCallback)(void *cls,
-                                        struct GSF_ConnectedPeer *cp,
-                                        int success);
+typedef void (*GSF_PeerReserveCallback) (void *cls,
+                                         struct GSF_ConnectedPeer * cp,
+                                         int success);
 
 
 /**
@@ -170,9 +170,11 @@ struct GSF_PeerTransmitHandle;
  * @param atsi performance data for the connection
  * @return handle to connected peer entry
  */
-struct GSF_ConnectedPeer *
-GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
-                           const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+struct GSF_ConnectedPeer *GSF_peer_connect_handler_ (const struct
+                                                     GNUNET_PeerIdentity *peer,
+                                                     const struct
+                                                     GNUNET_TRANSPORT_ATS_Information
+                                                     *atsi);
 
 
 /**
@@ -181,8 +183,8 @@ GSF_peer_connect_handler_ (const struct GNUNET_PeerIdentity *peer,
  * @param peer peer's identity
  * @return NULL if this peer is not currently connected
  */
-struct GSF_ConnectedPeer *
-GSF_peer_get_ (const struct GNUNET_PeerIdentity *peer);
+struct GSF_ConnectedPeer *GSF_peer_get_ (const struct GNUNET_PeerIdentity
+                                         *peer);
 
 
 /**
@@ -199,14 +201,13 @@ GSF_peer_get_ (const struct GNUNET_PeerIdentity *peer);
  * @param gmc_cls closure for gmc
  * @return handle to cancel request
  */
-struct GSF_PeerTransmitHandle *
-GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
-                    int is_query,
-                    uint32_t priority,
-                    struct GNUNET_TIME_Relative timeout,
-                    size_t size,
-                    GSF_GetMessageCallback gmc,
-                    void *gmc_cls);
+struct GSF_PeerTransmitHandle *GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
+                                                   int is_query,
+                                                   uint32_t priority,
+                                                   struct GNUNET_TIME_Relative
+                                                   timeout, size_t size,
+                                                   GSF_GetMessageCallback gmc,
+                                                   void *gmc_cls);
 
 
 /**
@@ -214,8 +215,7 @@ GSF_peer_transmit_ (struct GSF_ConnectedPeer *cp,
  *
  * @param pth request to cancel
  */
-void
-GSF_peer_transmit_cancel_ (struct GSF_PeerTransmitHandle *pth);
+void GSF_peer_transmit_cancel_ (struct GSF_PeerTransmitHandle *pth);
 
 
 /**
@@ -227,8 +227,8 @@ GSF_peer_transmit_cancel_ (struct GSF_PeerTransmitHandle *pth);
  */
 void
 GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp,
-                              struct GNUNET_TIME_Absolute request_time,
-                              uint32_t request_priority);
+                              struct GNUNET_TIME_Absolute request_time,
+                              uint32_t request_priority);
 
 
 /**
@@ -240,7 +240,7 @@ GSF_peer_update_performance_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_peer_update_responder_client_ (struct GSF_ConnectedPeer *cp,
-                                   struct GSF_LocalClient *initiator_client);
+                                   struct GSF_LocalClient *initiator_client);
 
 
 /**
@@ -252,7 +252,8 @@ GSF_peer_update_responder_client_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_peer_update_responder_peer_ (struct GSF_ConnectedPeer *cp,
-                                 const struct GSF_ConnectedPeer *initiator_peer);
+                                 const struct GSF_ConnectedPeer
+                                 *initiator_peer);
 
 
 /**
@@ -268,11 +269,11 @@ GSF_peer_update_responder_peer_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_peer_status_handler_ (void *cls,
-                          const struct GNUNET_PeerIdentity *peer,
-                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
-                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
-                          struct GNUNET_TIME_Absolute timeout,
-                          const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+                          const struct GNUNET_PeerIdentity *peer,
+                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in,
+                          struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out,
+                          struct GNUNET_TIME_Absolute timeout,
+                          const struct GNUNET_TRANSPORT_ATS_Information *atsi);
 
 
 /**
@@ -288,9 +289,10 @@ GSF_peer_status_handler_ (void *cls,
  */
 int
 GSF_handle_p2p_migration_stop_ (void *cls,
-                                const struct GNUNET_PeerIdentity *other,
-                                const struct GNUNET_MessageHeader *message,
-                                const struct GNUNET_TRANSPORT_ATS_Information *atsi);
+                                const struct GNUNET_PeerIdentity *other,
+                                const struct GNUNET_MessageHeader *message,
+                                const struct GNUNET_TRANSPORT_ATS_Information
+                                *atsi);
 
 
 /**
@@ -304,9 +306,11 @@ GSF_handle_p2p_migration_stop_ (void *cls,
  * @param message the actual message
  * @return pending request handle, NULL on error
  */
-struct GSF_PendingRequest *
-GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
-                       const struct GNUNET_MessageHeader *message);
+struct GSF_PendingRequest *GSF_handle_p2p_query_ (const struct
+                                                  GNUNET_PeerIdentity *other,
+                                                  const struct
+                                                  GNUNET_MessageHeader
+                                                  *message);
 
 
 /**
@@ -315,8 +319,9 @@ GSF_handle_p2p_query_ (const struct GNUNET_PeerIdentity *other,
  * @param cp peer to query
  * @return performance data record for the peer
  */
-struct GSF_PeerPerformanceData *
-GSF_get_peer_performance_data_ (struct GSF_ConnectedPeer *cp);
+struct GSF_PeerPerformanceData *GSF_get_peer_performance_data_ (struct
+                                                                GSF_ConnectedPeer
+                                                                *cp);
 
 
 /**
@@ -328,7 +333,7 @@ GSF_get_peer_performance_data_ (struct GSF_ConnectedPeer *cp);
  */
 void
 GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
-                           struct GNUNET_TIME_Relative block_time);
+                           struct GNUNET_TIME_Relative block_time);
 
 
 /**
@@ -340,7 +345,7 @@ GSF_block_peer_migration_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_peer_disconnect_handler_ (void *cls,
-                              const struct GNUNET_PeerIdentity *peer);
+                              const struct GNUNET_PeerIdentity *peer);
 
 
 /**
@@ -349,8 +354,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);
+void GSF_handle_local_client_disconnect_ (const struct GSF_LocalClient *lc);
 
 
 /**
@@ -364,7 +368,7 @@ GSF_handle_local_client_disconnect_ (const struct GSF_LocalClient *lc);
  */
 void
 GSF_connected_peer_change_preference_ (struct GSF_ConnectedPeer *cp,
-                                       uint64_t pref);
+                                       uint64_t pref);
 
 
 /**
@@ -375,7 +379,7 @@ GSF_connected_peer_change_preference_ (struct GSF_ConnectedPeer *cp,
  */
 void
 GSF_connected_peer_get_identity_ (const struct GSF_ConnectedPeer *cp,
-                                  struct GNUNET_PeerIdentity *id);
+                                  struct GNUNET_PeerIdentity *id);
 
 
 /**
@@ -384,23 +388,19 @@ GSF_connected_peer_get_identity_ (const struct GSF_ConnectedPeer *cp,
  * @param it function to call for each peer
  * @param it_cls closure for it
  */
-void
-GSF_iterate_connected_peers_ (GSF_ConnectedPeerIterator it,
-                              void *it_cls);
+void GSF_iterate_connected_peers_ (GSF_ConnectedPeerIterator it, void *it_cls);
 
 
 /**
  * Initialize peer management subsystem.
  */
-void
-GSF_connected_peer_init_ (void);
+void GSF_connected_peer_init_ (void);
 
 
 /**
  * Shutdown peer management subsystem.
  */
-void
-GSF_connected_peer_done_ (void);
+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 f92997f49..4bf02adb0 100644
--- a/src/fs/gnunet-service-fs_indexing.c
+++ b/src/fs/gnunet-service-fs_indexing.c
@@ -41,7 +41,7 @@
  */
 struct IndexInfo
 {
-  
+
   /**
    * This is a linked list.
    */
@@ -63,7 +63,7 @@ struct IndexInfo
    * Context for hashing of the file.
    */
   struct GNUNET_CRYPTO_FileHashContext *fhc;
-  
+
   /**
    * Hash of the contents of the file.
    */
@@ -98,57 +98,48 @@ static struct GNUNET_DATASTORE_Handle *dsh;
 
 /**
  * Write the current index information list to disk.
- */ 
+ */
 static void
 write_index_list ()
 {
   struct GNUNET_BIO_WriteHandle *wh;
   char *fn;
-  struct IndexInfo *pos;  
+  struct IndexInfo *pos;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                               "FS",
-                                               "INDEXDB",
-                                               &fn))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  _("Configuration option `%s' in section `%s' missing.\n"),
-                  "INDEXDB",
-                  "FS");
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                _("Configuration option `%s' in section `%s' missing.\n"),
+                "INDEXDB", "FS");
+    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;
+  }
   pos = indexed_files;
   while (pos != NULL)
-    {
-      if ( (GNUNET_OK !=
-            GNUNET_BIO_write (wh,
-                              &pos->file_id,
-                              sizeof (GNUNET_HashCode))) ||
-           (GNUNET_OK !=
-            GNUNET_BIO_write_string (wh,
-                                     pos->filename)) )
-        break;
-      pos = pos->next;
-    }
-  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;
-    }
+  {
+    if ((GNUNET_OK !=
+         GNUNET_BIO_write (wh,
+                           &pos->file_id,
+                           sizeof (GNUNET_HashCode))) ||
+        (GNUNET_OK != GNUNET_BIO_write_string (wh, pos->filename)))
+      break;
+    pos = pos->next;
+  }
+  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);
 }
 
@@ -161,73 +152,65 @@ read_index_list ()
 {
   struct GNUNET_BIO_ReadHandle *rh;
   char *fn;
-  struct IndexInfo *pos;  
+  struct IndexInfo *pos;
   char *fname;
   GNUNET_HashCode hc;
   size_t slen;
   char *emsg;
 
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_filename (cfg,
-                                               "FS",
-                                               "INDEXDB",
-                                               &fn))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  _("Configuration option `%s' in section `%s' missing.\n"),
-                  "INDEXDB",
-                  "FS");
-      return;
-    }
+      GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
+                _("Configuration option `%s' in section `%s' missing.\n"),
+                "INDEXDB", "FS");
+    return;
+  }
   if (GNUNET_NO == GNUNET_DISK_file_test (fn))
-    {
-      /* no index info yet */
-      GNUNET_free (fn);
-      return;
-    }
+  {
+    /* 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;
+  }
+  while ((GNUNET_OK ==
+          GNUNET_BIO_read (rh,
+                           "Hash of indexed file",
+                           &hc,
+                           sizeof (GNUNET_HashCode))) &&
+         (GNUNET_OK ==
+          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];
+    memcpy (&pos[1], fname, slen);
+    if (GNUNET_SYSERR ==
+        GNUNET_CONTAINER_multihashmap_put (ifm,
+                                           &hc,
+                                           (void *) pos->filename,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
     {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
-                  _("Could not open `%s'.\n"),
-                  fn);
-      GNUNET_free (fn);
-      return;
+      GNUNET_free (pos);
     }
-  while ( (GNUNET_OK ==
-           GNUNET_BIO_read (rh,
-                            "Hash of indexed file",
-                            &hc,
-                            sizeof (GNUNET_HashCode))) &&
-          (GNUNET_OK ==
-           GNUNET_BIO_read_string (rh, 
-                                   "Name of indexed file",
-                                   &fname,
-                                   1024 * 16)) &&
-          (fname != NULL) )
+    else
     {
-      slen = strlen (fname) + 1;
-      pos = GNUNET_malloc (sizeof (struct IndexInfo) + slen);
-      pos->file_id = hc;
-      pos->filename = (const char *) &pos[1];
-      memcpy (&pos[1], fname, slen);
-      if (GNUNET_SYSERR ==
-          GNUNET_CONTAINER_multihashmap_put (ifm,
-                                             &hc,
-                                             (void*) pos->filename,
-                                             GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-        {
-          GNUNET_free (pos);
-        }
-      else
-        {
-          pos->next = indexed_files;
-          indexed_files = pos;
-        }
-      GNUNET_free (fname);
+      pos->next = indexed_files;
+      indexed_files = pos;
     }
-  if (GNUNET_OK != 
-      GNUNET_BIO_read_close (rh, &emsg))
+    GNUNET_free (fname);
+  }
+  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
     GNUNET_free (emsg);
   GNUNET_free (fn);
 }
@@ -244,31 +227,29 @@ signal_index_ok (struct IndexInfo *ii)
 {
   if (GNUNET_SYSERR ==
       GNUNET_CONTAINER_multihashmap_put (ifm,
-                                         &ii->file_id,
-                                         (void*) ii->filename,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Index request received for file `%s' is already indexed as `%s'.  Permitting anyway.\n"),
-                  ii->filename,
-                  (const char*) GNUNET_CONTAINER_multihashmap_get (ifm,
-                                                                   &ii->file_id));
-      GNUNET_SERVER_transmit_context_append_data (ii->tc,
-                                                  NULL, 0,
-                                                  GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
-      GNUNET_SERVER_transmit_context_run (ii->tc,
-                                          GNUNET_TIME_UNIT_MINUTES);
-      GNUNET_free (ii);
-      return;
-    }
+                                         &ii->file_id,
+                                         (void *) ii->filename,
+                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Index request received for file `%s' is already indexed as `%s'.  Permitting anyway.\n"),
+                ii->filename,
+                (const char *) GNUNET_CONTAINER_multihashmap_get (ifm,
+                                                                  &ii->file_id));
+    GNUNET_SERVER_transmit_context_append_data (ii->tc, NULL, 0,
+                                                GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
+    GNUNET_SERVER_transmit_context_run (ii->tc, GNUNET_TIME_UNIT_MINUTES);
+    GNUNET_free (ii);
+    return;
+  }
   ii->next = indexed_files;
   indexed_files = ii;
   write_index_list ();
   GNUNET_SERVER_transmit_context_append_data (ii->tc,
-                                              NULL, 0,
-                                              GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
-  GNUNET_SERVER_transmit_context_run (ii->tc,
-                                      GNUNET_TIME_UNIT_MINUTES);
+                                              NULL, 0,
+                                              GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
+  GNUNET_SERVER_transmit_context_run (ii->tc, GNUNET_TIME_UNIT_MINUTES);
   ii->tc = NULL;
 }
 
@@ -280,36 +261,30 @@ signal_index_ok (struct IndexInfo *ii)
  * @param cls closure, our publishing context
  * @param res resulting hash, NULL on error
  */
-static void 
-hash_for_index_val (void *cls,
-                    const GNUNET_HashCode *
-                    res)
+static void
+hash_for_index_val (void *cls, const GNUNET_HashCode * res)
 {
   struct IndexInfo *ii = cls;
 
   ii->fhc = NULL;
-  if ( (res == NULL) ||
-       (0 != memcmp (res,
-                     &ii->file_id,
-                     sizeof(GNUNET_HashCode))) )
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Hash mismatch trying to index file `%s' which has hash `%s'\n"),
-                  ii->filename,
-                  GNUNET_h2s (res));
+  if ((res == NULL) ||
+      (0 != memcmp (res, &ii->file_id, sizeof (GNUNET_HashCode))))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("Hash mismatch trying to index file `%s' which has hash `%s'\n"),
+                ii->filename, GNUNET_h2s (res));
 #if DEBUG_FS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Wanted `%s'\n",
-                  GNUNET_h2s (&ii->file_id));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Wanted `%s'\n", GNUNET_h2s (&ii->file_id));
 #endif
-      GNUNET_SERVER_transmit_context_append_data (ii->tc,
-                                                  NULL, 0,
-                                                  GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
-      GNUNET_SERVER_transmit_context_run (ii->tc,
-                                          GNUNET_TIME_UNIT_MINUTES);
-      GNUNET_free (ii);
-      return;
-    }
+    GNUNET_SERVER_transmit_context_append_data (ii->tc,
+                                                NULL, 0,
+                                                GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
+    GNUNET_SERVER_transmit_context_run (ii->tc, GNUNET_TIME_UNIT_MINUTES);
+    GNUNET_free (ii);
+    return;
+  }
   signal_index_ok (ii);
 }
 
@@ -323,8 +298,8 @@ hash_for_index_val (void *cls,
  */
 void
 GNUNET_FS_handle_index_start (void *cls,
-                              struct GNUNET_SERVER_Client *client,
-                              const struct GNUNET_MessageHeader *message)
+                              struct GNUNET_SERVER_Client *client,
+                              const struct GNUNET_MessageHeader *message)
 {
   const struct IndexStartMessage *ism;
   char *fn;
@@ -336,77 +311,70 @@ GNUNET_FS_handle_index_start (void *cls,
   uint64_t mydev;
   uint64_t myino;
 
-  msize = ntohs(message->size);
-  if ( (msize <= sizeof (struct IndexStartMessage)) ||
-       ( ((const char *)message)[msize-1] != '\0') )
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client,
-                                  GNUNET_SYSERR);
-      return;
-    }
-  ism = (const struct IndexStartMessage*) message;
+  msize = ntohs (message->size);
+  if ((msize <= sizeof (struct IndexStartMessage)) ||
+      (((const char *) message)[msize - 1] != '\0'))
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+  ism = (const struct IndexStartMessage *) message;
   if (0 != ism->reserved)
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client,
-                                  GNUNET_SYSERR);
-      return;
-    }
-  fn = GNUNET_STRINGS_filename_expand ((const char*) &ism[1]);
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
+  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
   if (fn == NULL)
-    {
-      GNUNET_SERVER_receive_done (client,
-                                  GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   dev = GNUNET_ntohll (ism->device);
   ino = GNUNET_ntohll (ism->inode);
-  ism = (const struct IndexStartMessage*) message;
+  ism = (const struct IndexStartMessage *) message;
   slen = strlen (fn) + 1;
   ii = GNUNET_malloc (sizeof (struct IndexInfo) + slen);
-  ii->filename = (const char*) &ii[1];
+  ii->filename = (const char *) &ii[1];
   memcpy (&ii[1], fn, slen);
-  ii->file_id = ism->file_id;  
+  ii->file_id = ism->file_id;
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received `%s' message for file `%s'\n",
-              "START_INDEX",
-              ii->filename);
+              "Received `%s' message for file `%s'\n",
+              "START_INDEX", ii->filename);
 #endif
 
   ii->tc = GNUNET_SERVER_transmit_context_create (client);
   mydev = 0;
   myino = 0;
-  if ( ( (dev != 0) ||
-         (ino != 0) ) &&
-       (GNUNET_OK == GNUNET_DISK_file_get_identifiers (fn,
-                                                       &mydev,
-                                                       &myino)) &&
-       ( (dev == mydev) &&
-         (ino == myino) ) )
-    {      
-      /* fast validation OK! */
-      signal_index_ok (ii);
-      GNUNET_free (fn);
-      return;
-    }
+  if (((dev != 0) ||
+       (ino != 0)) &&
+      (GNUNET_OK == GNUNET_DISK_file_get_identifiers (fn,
+                                                      &mydev,
+                                                      &myino)) &&
+      ((dev == mydev) && (ino == myino)))
+  {
+    /* fast validation OK! */
+    signal_index_ok (ii);
+    GNUNET_free (fn);
+    return;
+  }
 #if DEBUG_FS
   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);
+              "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);
 #endif
   /* slow validation, need to hash full file (again) */
   ii->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                     fn,
-                                     HASHING_BLOCKSIZE,
-                                     &hash_for_index_val,
-                                     ii);
-  if (ii->fhc == NULL)    
-    hash_for_index_val (ii, NULL);    
+                                     fn,
+                                     HASHING_BLOCKSIZE,
+                                     &hash_for_index_val, ii);
+  if (ii->fhc == NULL)
+    hash_for_index_val (ii, NULL);
   GNUNET_free (fn);
 }
 
@@ -420,8 +388,8 @@ GNUNET_FS_handle_index_start (void *cls,
  */
 void
 GNUNET_FS_handle_index_list_get (void *cls,
-                                 struct GNUNET_SERVER_Client *client,
-                                 const struct GNUNET_MessageHeader *message)
+                                 struct GNUNET_SERVER_Client *client,
+                                 const struct GNUNET_MessageHeader *message)
 {
   struct GNUNET_SERVER_TransmitContext *tc;
   struct IndexInfoMessage *iim;
@@ -431,31 +399,30 @@ GNUNET_FS_handle_index_list_get (void *cls,
   struct IndexInfo *pos;
 
   tc = GNUNET_SERVER_transmit_context_create (client);
-  iim = (struct IndexInfoMessage*) buf;
+  iim = (struct IndexInfoMessage *) buf;
   pos = indexed_files;
   while (NULL != pos)
+  {
+    fn = pos->filename;
+    slen = strlen (fn) + 1;
+    if (slen + sizeof (struct IndexInfoMessage) >=
+        GNUNET_SERVER_MAX_MESSAGE_SIZE)
     {
-      fn = pos->filename;
-      slen = strlen (fn) + 1;
-      if (slen + sizeof (struct IndexInfoMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
-        {
-          GNUNET_break (0);
-          break;
-        }
-      iim->header.type = htons (GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY);
-      iim->header.size = htons (slen + sizeof (struct IndexInfoMessage));
-      iim->reserved = 0;
-      iim->file_id = pos->file_id;
-      memcpy (&iim[1], fn, slen);
-      GNUNET_SERVER_transmit_context_append_message (tc,
-                                                     &iim->header);
-      pos = pos->next;
+      GNUNET_break (0);
+      break;
     }
+    iim->header.type = htons (GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY);
+    iim->header.size = htons (slen + sizeof (struct IndexInfoMessage));
+    iim->reserved = 0;
+    iim->file_id = pos->file_id;
+    memcpy (&iim[1], fn, slen);
+    GNUNET_SERVER_transmit_context_append_message (tc, &iim->header);
+    pos = pos->next;
+  }
   GNUNET_SERVER_transmit_context_append_data (tc,
-                                              NULL, 0,
-                                              GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END);
-  GNUNET_SERVER_transmit_context_run (tc,
-                                      GNUNET_TIME_UNIT_MINUTES);
+                                              NULL, 0,
+                                              GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END);
+  GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_MINUTES);
 }
 
 
@@ -468,8 +435,8 @@ GNUNET_FS_handle_index_list_get (void *cls,
  */
 void
 GNUNET_FS_handle_unindex (void *cls,
-                          struct GNUNET_SERVER_Client *client,
-                          const struct GNUNET_MessageHeader *message)
+                          struct GNUNET_SERVER_Client *client,
+                          const struct GNUNET_MessageHeader *message)
 {
   const struct UnindexMessage *um;
   struct IndexInfo *pos;
@@ -478,55 +445,51 @@ GNUNET_FS_handle_unindex (void *cls,
   struct GNUNET_SERVER_TransmitContext *tc;
   int found;
 
-  um = (const struct UnindexMessage*) message;
+  um = (const struct UnindexMessage *) message;
   if (0 != um->reserved)
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client,
-                                  GNUNET_SYSERR);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return;
+  }
   found = GNUNET_NO;
   prev = NULL;
   pos = indexed_files;
   while (NULL != pos)
+  {
+    next = pos->next;
+    if (0 == memcmp (&pos->file_id, &um->file_id, sizeof (GNUNET_HashCode)))
     {
-      next = pos->next;
-      if (0 == memcmp (&pos->file_id,
-                       &um->file_id,
-                       sizeof (GNUNET_HashCode)))
-        {
-          if (prev == NULL)
-            indexed_files = next;
-          else
-            prev->next = next;
-          GNUNET_break (GNUNET_OK ==
-                        GNUNET_CONTAINER_multihashmap_remove (ifm,
-                                                              &pos->file_id,
-                                                              (void*) pos->filename));
-          GNUNET_free (pos);
-          found = GNUNET_YES;
-        }
+      if (prev == NULL)
+        indexed_files = next;
       else
-        {
-          prev = pos;
-        }
-      pos = next;
+        prev->next = next;
+      GNUNET_break (GNUNET_OK ==
+                    GNUNET_CONTAINER_multihashmap_remove (ifm,
+                                                          &pos->file_id,
+                                                          (void *)
+                                                          pos->filename));
+      GNUNET_free (pos);
+      found = GNUNET_YES;
     }
+    else
+    {
+      prev = pos;
+    }
+    pos = next;
+  }
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Client requested unindexing of file `%s': %s\n",
-              GNUNET_h2s (&um->file_id),
-              found ? "found" : "not found");
+              "Client requested unindexing of file `%s': %s\n",
+              GNUNET_h2s (&um->file_id), found ? "found" : "not found");
 #endif
-  if (GNUNET_YES == found)    
+  if (GNUNET_YES == found)
     write_index_list ();
   tc = GNUNET_SERVER_transmit_context_create (client);
   GNUNET_SERVER_transmit_context_append_data (tc,
-                                              NULL, 0,
-                                              GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
-  GNUNET_SERVER_transmit_context_run (tc,
-                                      GNUNET_TIME_UNIT_MINUTES);
+                                              NULL, 0,
+                                              GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
+  GNUNET_SERVER_transmit_context_run (tc, GNUNET_TIME_UNIT_MINUTES);
 }
 
 
@@ -539,14 +502,11 @@ GNUNET_FS_handle_unindex (void *cls,
  * @param msg error message
  */
 static void
-remove_cont (void *cls,
-             int success,
-             const char *msg)
+remove_cont (void *cls, int success, const char *msg)
 {
   if (GNUNET_OK != success)
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                _("Failed to delete bogus block: %s\n"),
-                msg);
+                _("Failed to delete bogus block: %s\n"), msg);
 }
 
 
@@ -571,15 +531,15 @@ remove_cont (void *cls,
  */
 int
 GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key,
-                                  uint32_t size,
-                                  const void *data,
-                                  enum GNUNET_BLOCK_Type type,
-                                  uint32_t priority,
-                                  uint32_t anonymity,
-                                  struct GNUNET_TIME_Absolute
-                                  expiration, uint64_t uid,
-                                  GNUNET_DATASTORE_DatumProcessor cont,
-                                  void *cont_cls)
+                                  uint32_t size,
+                                  const void *data,
+                                  enum GNUNET_BLOCK_Type type,
+                                  uint32_t priority,
+                                  uint32_t anonymity,
+                                  struct GNUNET_TIME_Absolute
+                                  expiration, uint64_t uid,
+                                  GNUNET_DATASTORE_DatumProcessor cont,
+                                  void *cont_cls)
 {
   const struct OnDemandBlock *odb;
   GNUNET_HashCode nkey;
@@ -594,99 +554,72 @@ GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key,
   uint64_t off;
 
   if (size != sizeof (struct OnDemandBlock))
-    {
-      GNUNET_break (0);
-      GNUNET_DATASTORE_remove (dsh,
-                               key,
-                               size,
-                               data,
-                               -1, -1,
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               &remove_cont,
-                               NULL);
-      return GNUNET_SYSERR;
-    }
-  odb = (const struct OnDemandBlock*) data;
+  {
+    GNUNET_break (0);
+    GNUNET_DATASTORE_remove (dsh,
+                             key,
+                             size,
+                             data,
+                             -1, -1,
+                             GNUNET_TIME_UNIT_FOREVER_REL, &remove_cont, NULL);
+    return GNUNET_SYSERR;
+  }
+  odb = (const struct OnDemandBlock *) data;
   off = GNUNET_ntohll (odb->offset);
-  fn = (const char*) GNUNET_CONTAINER_multihashmap_get (ifm,
-                                                        &odb->file_id);
+  fn = (const char *) GNUNET_CONTAINER_multihashmap_get (ifm, &odb->file_id);
   fh = NULL;
-  if ( (NULL == fn) ||
-       (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,
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               &remove_cont,
-                               NULL);
-      return GNUNET_SYSERR;
-    }
+  if ((NULL == fn) ||
+      (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,
+                             GNUNET_TIME_UNIT_FOREVER_REL, &remove_cont, NULL);
+    return GNUNET_SYSERR;
+  }
   GNUNET_DISK_file_close (fh);
-  GNUNET_CRYPTO_hash (ndata,
-                      nsize,
-                      &nkey);
+  GNUNET_CRYPTO_hash (ndata, nsize, &nkey);
   GNUNET_CRYPTO_hash_to_aes_key (&nkey, &skey, &iv);
-  GNUNET_CRYPTO_aes_encrypt (ndata,
-                             nsize,
-                             &skey,
-                             &iv,
-                             edata);
-  GNUNET_CRYPTO_hash (edata,
-                      nsize,
-                      &query);
-  if (0 != memcmp (&query, 
-                   key,
-                   sizeof (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,
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               &remove_cont,
-                               NULL);
-      return GNUNET_SYSERR;
-    }
+  GNUNET_CRYPTO_aes_encrypt (ndata, nsize, &skey, &iv, edata);
+  GNUNET_CRYPTO_hash (edata, nsize, &query);
+  if (0 != memcmp (&query, key, sizeof (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,
+                             GNUNET_TIME_UNIT_FOREVER_REL, &remove_cont, NULL);
+    return GNUNET_SYSERR;
+  }
 #if DEBUG_FS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "On-demand encoded block for query `%s'\n",
-                  GNUNET_h2s (key));
-#endif  
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "On-demand encoded block for query `%s'\n", GNUNET_h2s (key));
+#endif
   cont (cont_cls,
-        key,
-        nsize,
-        edata,
-        GNUNET_BLOCK_TYPE_FS_DBLOCK,
-        priority,
-        anonymity,
-        expiration,
-        uid);
+        key,
+        nsize,
+        edata,
+        GNUNET_BLOCK_TYPE_FS_DBLOCK, priority, anonymity, expiration, uid);
   return GNUNET_OK;
 }
 
@@ -697,17 +630,17 @@ GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key,
 void
 GNUNET_FS_indexing_done ()
 {
-  struct IndexInfo *pos;  
+  struct IndexInfo *pos;
 
   GNUNET_CONTAINER_multihashmap_destroy (ifm);
   ifm = NULL;
   while (NULL != (pos = indexed_files))
-    {
-      indexed_files = pos->next;
-      if (pos->fhc != NULL)
-        GNUNET_CRYPTO_hash_file_cancel (pos->fhc);
-      GNUNET_free (pos);
-    }
+  {
+    indexed_files = pos->next;
+    if (pos->fhc != NULL)
+      GNUNET_CRYPTO_hash_file_cancel (pos->fhc);
+    GNUNET_free (pos);
+  }
   cfg = NULL;
 }
 
@@ -720,7 +653,7 @@ GNUNET_FS_indexing_done ()
  */
 int
 GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c,
-                         struct GNUNET_DATASTORE_Handle *d)
+                         struct GNUNET_DATASTORE_Handle *d)
 {
   cfg = c;
   dsh = d;
diff --git a/src/fs/gnunet-service-fs_indexing.h b/src/fs/gnunet-service-fs_indexing.h
index e1154830b..c6ef53351 100644
--- a/src/fs/gnunet-service-fs_indexing.h
+++ b/src/fs/gnunet-service-fs_indexing.h
@@ -56,15 +56,15 @@
  */
 int
 GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key,
-                                  uint32_t size,
-                                  const void *data,
-                                  enum GNUNET_BLOCK_Type type,
-                                  uint32_t priority,
-                                  uint32_t anonymity,
-                                  struct GNUNET_TIME_Absolute
-                                  expiration, uint64_t uid,
-                                  GNUNET_DATASTORE_DatumProcessor cont,
-                                  void *cont_cls);
+                                  uint32_t size,
+                                  const void *data,
+                                  enum GNUNET_BLOCK_Type type,
+                                  uint32_t priority,
+                                  uint32_t anonymity,
+                                  struct GNUNET_TIME_Absolute
+                                  expiration, uint64_t uid,
+                                  GNUNET_DATASTORE_DatumProcessor cont,
+                                  void *cont_cls);
 
 /**
  * Handle INDEX_START-message.
@@ -75,8 +75,8 @@ GNUNET_FS_handle_on_demand_block (const GNUNET_HashCode * key,
  */
 void
 GNUNET_FS_handle_index_start (void *cls,
-                              struct GNUNET_SERVER_Client *client,
-                              const struct GNUNET_MessageHeader *message);
+                              struct GNUNET_SERVER_Client *client,
+                              const struct GNUNET_MessageHeader *message);
 
 
 /**
@@ -88,8 +88,8 @@ GNUNET_FS_handle_index_start (void *cls,
  */
 void
 GNUNET_FS_handle_index_list_get (void *cls,
-                                 struct GNUNET_SERVER_Client *client,
-                                 const struct GNUNET_MessageHeader *message);
+                                 struct GNUNET_SERVER_Client *client,
+                                 const struct GNUNET_MessageHeader *message);
 
 
 /**
@@ -101,8 +101,8 @@ GNUNET_FS_handle_index_list_get (void *cls,
  */
 void
 GNUNET_FS_handle_unindex (void *cls,
-                          struct GNUNET_SERVER_Client *client,
-                          const struct GNUNET_MessageHeader *message);
+                          struct GNUNET_SERVER_Client *client,
+                          const struct GNUNET_MessageHeader *message);
 
 
 /**
@@ -114,14 +114,13 @@ GNUNET_FS_handle_unindex (void *cls,
  */
 int
 GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c,
-                         struct GNUNET_DATASTORE_Handle *d);
+                         struct GNUNET_DATASTORE_Handle *d);
 
 
 /**
  * Shutdown the module.
  */
-void
-GNUNET_FS_indexing_done (void);
+void GNUNET_FS_indexing_done (void);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_lc.c b/src/fs/gnunet-service-fs_lc.c
index 18f5c10dc..aa6569387 100644
--- a/src/fs/gnunet-service-fs_lc.c
+++ b/src/fs/gnunet-service-fs_lc.c
@@ -170,16 +170,13 @@ GSF_local_client_lookup_ (struct GNUNET_SERVER_Client *client)
   struct GSF_LocalClient *pos;
 
   pos = client_head;
-  while ( (pos != NULL) &&
-          (pos->client != client) )
+  while ((pos != NULL) && (pos->client != client))
     pos = pos->next;
   if (pos != NULL)
     return pos;
   pos = GNUNET_malloc (sizeof (struct GSF_LocalClient));
   pos->client = client;
-  GNUNET_CONTAINER_DLL_insert (client_head,
-                               client_tail,
-                               pos);
+  GNUNET_CONTAINER_DLL_insert (client_head, client_tail, pos);
   return pos;
 }
 
@@ -189,24 +186,21 @@ GSF_local_client_lookup_ (struct GNUNET_SERVER_Client *client)
  *
  * @param cls the client request to free
  * @param tc task context
- */ 
+ */
 static void
 client_request_destroy (void *cls,
-                        const struct GNUNET_SCHEDULER_TaskContext *tc)
+                        const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ClientRequest *cr = cls;
   struct GSF_LocalClient *lc;
 
   cr->kill_task = GNUNET_SCHEDULER_NO_TASK;
   lc = cr->lc;
-  GNUNET_CONTAINER_DLL_remove (lc->cr_head,
-                               lc->cr_tail,
-                               cr);
+  GNUNET_CONTAINER_DLL_remove (lc->cr_head, lc->cr_tail, cr);
   GSF_pending_request_cancel_ (cr->pr, GNUNET_NO);
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# client searches active"),
-                            - 1,
-                            GNUNET_NO);
+                            gettext_noop ("# client searches active"),
+                            -1, GNUNET_NO);
   GNUNET_free (cr);
 }
 
@@ -230,13 +224,12 @@ client_request_destroy (void *cls,
  */
 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,
-                         enum GNUNET_BLOCK_Type type,
-                         const void *data,
-                         size_t data_len)
+                         enum GNUNET_BLOCK_EvaluationResult eval,
+                         struct GSF_PendingRequest *pr,
+                         uint32_t reply_anonymity_level,
+                         struct GNUNET_TIME_Absolute expiration,
+                         enum GNUNET_BLOCK_Type type,
+                         const void *data, size_t data_len)
 {
   struct ClientRequest *cr = cls;
   struct GSF_LocalClient *lc;
@@ -245,47 +238,44 @@ client_response_handler (void *cls,
   size_t msize;
 
   if (NULL == data)
-    {
-      /* ugh, request 'timed out' -- how can this be? */
-      GNUNET_break (0);
-      return;
-    }
+  {
+    /* ugh, request 'timed out' -- how can this be? */
+    GNUNET_break (0);
+    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;
-    }
+  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);
+                            gettext_noop
+                            ("# replies received for local clients"), 1,
+                            GNUNET_NO);
   GNUNET_assert (pr == cr->pr);
   lc = cr->lc;
   msize = sizeof (struct PutMessage) + data_len;
   {
     char buf[msize];
-    
-    pm = (struct PutMessage*) buf;
+
+    pm = (struct PutMessage *) buf;
     pm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_PUT);
     pm->header.size = htons (msize);
     pm->type = htonl (type);
     pm->expiration = GNUNET_TIME_absolute_hton (expiration);
-    memcpy (&pm[1], data, data_len);      
+    memcpy (&pm[1], data, data_len);
     GSF_local_client_transmit_ (lc, &pm->header);
   }
 #if DEBUG_FS_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Queued reply to query `%s' for local client\n",
-              GNUNET_h2s (&prd->query),
-              (unsigned int) prd->type);
+              "Queued reply to query `%s' for local client\n",
+              GNUNET_h2s (&prd->query), (unsigned int) prd->type);
 #endif
   if (eval != GNUNET_BLOCK_EVALUATION_OK_LAST)
     return;
-  cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
-                                            cr);
+  cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy, cr);
 }
 
 
@@ -298,7 +288,8 @@ client_response_handler (void *cls,
  */
 struct GSF_PendingRequest *
 GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
-                                        const struct GNUNET_MessageHeader *message)
+                                        const struct GNUNET_MessageHeader
+                                        *message)
 {
   static GNUNET_HashCode all_zeros;
   const struct SearchMessage *sm;
@@ -311,99 +302,84 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
   enum GSF_PendingRequestOptions options;
 
   msize = ntohs (message->size);
-  if ( (msize < sizeof (struct SearchMessage)) ||
-       (0 != (msize - sizeof (struct SearchMessage)) % sizeof (GNUNET_HashCode)) )
-    {
-      GNUNET_break (0);
-      GNUNET_SERVER_receive_done (client,
-                                  GNUNET_SYSERR);
-      return NULL;
-    }
+  if ((msize < sizeof (struct SearchMessage)) ||
+      (0 != (msize - sizeof (struct SearchMessage)) % sizeof (GNUNET_HashCode)))
+  {
+    GNUNET_break (0);
+    GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+    return NULL;
+  }
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# client searches received"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# client searches received"),
+                            1, GNUNET_NO);
   sc = (msize - sizeof (struct SearchMessage)) / sizeof (GNUNET_HashCode);
-  sm = (const struct SearchMessage*) message;
+  sm = (const struct SearchMessage *) message;
   type = ntohl (sm->type);
 #if DEBUG_FS_CLIENT
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Received request for `%s' of type %u from local client\n",
-              GNUNET_h2s (&sm->query),
-              (unsigned int) type);
+              "Received request for `%s' of type %u from local client\n",
+              GNUNET_h2s (&sm->query), (unsigned int) type);
 #endif
   lc = GSF_local_client_lookup_ (client);
 
   /* detect duplicate KBLOCK requests */
-  if ( (type == GNUNET_BLOCK_TYPE_FS_KBLOCK) ||
-       (type == GNUNET_BLOCK_TYPE_FS_NBLOCK) ||
-       (type == GNUNET_BLOCK_TYPE_ANY) )
+  if ((type == GNUNET_BLOCK_TYPE_FS_KBLOCK) ||
+      (type == GNUNET_BLOCK_TYPE_FS_NBLOCK) || (type == GNUNET_BLOCK_TYPE_ANY))
+  {
+    /* FIXME: this does currently not work to filter duplicate
+     * results from *local* datastore since the local store is
+     * queried before we continue to process additional
+     * messages from the client! -- fix protocol? */
+    cr = lc->cr_head;
+    while (cr != NULL)
+    {
+      prd = GSF_pending_request_get_data_ (cr->pr);
+      if ((0 != memcmp (&prd->query,
+                        &sm->query,
+                        sizeof (GNUNET_HashCode))) && (prd->type == type))
+        break;
+      cr = cr->next;
+    }
+    if (cr != NULL)
     {
-      /* FIXME: this does currently not work to filter duplicate
-         results from *local* datastore since the local store is
-         queried before we continue to process additional
-         messages from the client! -- fix protocol? */
-      cr = lc->cr_head;
-      while (cr != NULL) 
-        {
-          prd = GSF_pending_request_get_data_ (cr->pr);
-          if ( (0 != memcmp (&prd->query,
-                             &sm->query,
-                             sizeof (GNUNET_HashCode))) &&
-               (prd->type == type) )
-            break;
-          cr = cr->next;
-        }
-      if (cr != NULL)   
-        { 
 #if DEBUG_FS_CLIENT
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Have existing request, merging content-seen lists.\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Have existing request, merging content-seen lists.\n");
 #endif
-          GSF_pending_request_update_ (cr->pr,
-                                       (const GNUNET_HashCode*) &sm[1],
-                                       sc);
-          GNUNET_STATISTICS_update (GSF_stats,
-                                    gettext_noop ("# client searches updated (merged content seen list)"),
-                                    1,
-                                    GNUNET_NO);
-          GNUNET_SERVER_receive_done (client,
-                                      GNUNET_OK);
-          return NULL;
-        }
+      GSF_pending_request_update_ (cr->pr,
+                                   (const GNUNET_HashCode *) &sm[1], sc);
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop
+                                ("# client searches updated (merged content seen list)"),
+                                1, GNUNET_NO);
+      GNUNET_SERVER_receive_done (client, GNUNET_OK);
+      return NULL;
     }
+  }
 
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# client searches active"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# client searches active"),
+                            1, GNUNET_NO);
   cr = GNUNET_malloc (sizeof (struct ClientRequest));
   cr->lc = lc;
-  GNUNET_CONTAINER_DLL_insert (lc->cr_head,
-                               lc->cr_tail,
-                               cr);
-  options = GSF_PRO_LOCAL_REQUEST;  
+  GNUNET_CONTAINER_DLL_insert (lc->cr_head, lc->cr_tail, cr);
+  options = GSF_PRO_LOCAL_REQUEST;
   if (0 != (1 & ntohl (sm->options)))
     options |= GSF_PRO_LOCAL_ONLY;
-  cr->pr = GSF_pending_request_create_ (options,
-                                        type,
-                                        &sm->query,
-                                        (type == GNUNET_BLOCK_TYPE_FS_SBLOCK)
-                                        ? &sm->target /* namespace */
-                                        : NULL,
-                                        (0 != memcmp (&sm->target,
-                                                      &all_zeros,
-                                                      sizeof (GNUNET_HashCode)))
-                                        ? (const struct GNUNET_PeerIdentity*) &sm->target
-                                        : NULL,
-                                        NULL, 0, 0 /* bf */, 
-                                        ntohl (sm->anonymity_level),
-                                        0 /* priority */,
-                                        0 /* ttl */,
-                                        0 /* sender PID */,
-                                        (const GNUNET_HashCode*) &sm[1], sc,
-                                        &client_response_handler,
-                                        cr);
+  cr->pr = GSF_pending_request_create_ (options, type, &sm->query, (type == GNUNET_BLOCK_TYPE_FS_SBLOCK) ? &sm->target  /* namespace */
+                                        : NULL,
+                                        (0 != memcmp (&sm->target,
+                                                      &all_zeros,
+                                                      sizeof (GNUNET_HashCode)))
+                                        ? (const struct GNUNET_PeerIdentity *)
+                                        &sm->target : NULL, NULL, 0,
+                                        0 /* bf */ ,
+                                        ntohl (sm->anonymity_level),
+                                        0 /* priority */ ,
+                                        0 /* ttl */ ,
+                                        0 /* sender PID */ ,
+                                        (const GNUNET_HashCode *) &sm[1], sc,
+                                        &client_response_handler, cr);
   return cr->pr;
 }
 
@@ -422,36 +398,30 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
  * @return number of bytes written to buf
  */
 static size_t
-transmit_to_client (void *cls,
-                    size_t size,
-                    void *buf)
+transmit_to_client (void *cls, size_t size, void *buf)
 {
   struct GSF_LocalClient *lc = cls;
   char *cbuf = buf;
   struct ClientResponse *res;
   size_t msize;
-  
+
   lc->th = NULL;
   if (NULL == buf)
     return 0;
   msize = 0;
-  while ( (NULL != (res = lc->res_head) ) &&
-          (res->msize <= size) )
-    {
-      memcpy (&cbuf[msize], &res[1], res->msize);
-      msize += res->msize;
-      size -= res->msize;
-      GNUNET_CONTAINER_DLL_remove (lc->res_head,
-                                   lc->res_tail,
-                                   res);
-      GNUNET_free (res);
-    }
+  while ((NULL != (res = lc->res_head)) && (res->msize <= size))
+  {
+    memcpy (&cbuf[msize], &res[1], res->msize);
+    msize += res->msize;
+    size -= res->msize;
+    GNUNET_CONTAINER_DLL_remove (lc->res_head, lc->res_tail, res);
+    GNUNET_free (res);
+  }
   if (NULL != res)
     lc->th = GNUNET_SERVER_notify_transmit_ready (lc->client,
-                                                  res->msize,
-                                                  GNUNET_TIME_UNIT_FOREVER_REL,
-                                                  &transmit_to_client,
-                                                  lc);
+                                                  res->msize,
+                                                  GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  &transmit_to_client, lc);
   return msize;
 }
 
@@ -466,7 +436,7 @@ transmit_to_client (void *cls,
  */
 void
 GSF_local_client_transmit_ (struct GSF_LocalClient *lc,
-                            const struct GNUNET_MessageHeader *msg)
+                            const struct GNUNET_MessageHeader *msg)
 {
   struct ClientResponse *res;
   size_t msize;
@@ -476,15 +446,12 @@ GSF_local_client_transmit_ (struct GSF_LocalClient *lc,
   res->lc = lc;
   res->msize = msize;
   memcpy (&res[1], msg, msize);
-  GNUNET_CONTAINER_DLL_insert_tail (lc->res_head,
-                                    lc->res_tail,
-                                    res);
+  GNUNET_CONTAINER_DLL_insert_tail (lc->res_head, lc->res_tail, res);
   if (NULL == lc->th)
     lc->th = GNUNET_SERVER_notify_transmit_ready (lc->client,
-                                                  msize,
-                                                  GNUNET_TIME_UNIT_FOREVER_REL,
-                                                  &transmit_to_client,
-                                                  lc);
+                                                  msize,
+                                                  GNUNET_TIME_UNIT_FOREVER_REL,
+                                                  &transmit_to_client, lc);
 }
 
 
@@ -496,49 +463,40 @@ GSF_local_client_transmit_ (struct GSF_LocalClient *lc,
  * @param client handle of the client
  */
 void
-GSF_client_disconnect_handler_ (void *cls,
-                                struct GNUNET_SERVER_Client *client)
+GSF_client_disconnect_handler_ (void *cls, struct GNUNET_SERVER_Client *client)
 {
   struct GSF_LocalClient *pos;
   struct ClientRequest *cr;
   struct ClientResponse *res;
 
   pos = client_head;
-  while ( (pos != NULL) &&
-          (pos->client != client) )
+  while ((pos != NULL) && (pos->client != client))
     pos = pos->next;
   if (pos == NULL)
     return;
   while (NULL != (cr = pos->cr_head))
-    {      
-      GNUNET_CONTAINER_DLL_remove (pos->cr_head,
-                                   pos->cr_tail,
-                                   cr);
-      GSF_pending_request_cancel_ (cr->pr, GNUNET_NO);
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# client searches active"),
-                                - 1,
-                                GNUNET_NO);
-      if (GNUNET_SCHEDULER_NO_TASK != cr->kill_task)
-        GNUNET_SCHEDULER_cancel (cr->kill_task);
-      GNUNET_free (cr);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (pos->cr_head, pos->cr_tail, cr);
+    GSF_pending_request_cancel_ (cr->pr, GNUNET_NO);
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# client searches active"),
+                              -1, GNUNET_NO);
+    if (GNUNET_SCHEDULER_NO_TASK != cr->kill_task)
+      GNUNET_SCHEDULER_cancel (cr->kill_task);
+    GNUNET_free (cr);
+  }
   while (NULL != (res = pos->res_head))
-    {
-      GNUNET_CONTAINER_DLL_remove (pos->res_head,
-                                   pos->res_tail,
-                                   res);
-      GNUNET_free (res);
-    }
+  {
+    GNUNET_CONTAINER_DLL_remove (pos->res_head, pos->res_tail, res);
+    GNUNET_free (res);
+  }
   if (pos->th != NULL)
-    {
-      GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
-      pos->th = NULL;
-    }
+  {
+    GNUNET_CONNECTION_notify_transmit_ready_cancel (pos->th);
+    pos->th = NULL;
+  }
   GSF_handle_local_client_disconnect_ (pos);
-  GNUNET_CONTAINER_DLL_remove (client_head,
-                               client_tail,
-                               pos);
+  GNUNET_CONTAINER_DLL_remove (client_head, client_tail, pos);
   GNUNET_free (pos);
 }
 
diff --git a/src/fs/gnunet-service-fs_lc.h b/src/fs/gnunet-service-fs_lc.h
index fb63a3571..c9d8ce191 100644
--- a/src/fs/gnunet-service-fs_lc.h
+++ b/src/fs/gnunet-service-fs_lc.h
@@ -36,8 +36,8 @@
  * @param client handle of the client
  * @return handle to local client entry
  */
-struct GSF_LocalClient *
-GSF_local_client_lookup_ (struct GNUNET_SERVER_Client *client);
+struct GSF_LocalClient *GSF_local_client_lookup_ (struct GNUNET_SERVER_Client
+                                                  *client);
 
 
 /**
@@ -50,9 +50,12 @@ GSF_local_client_lookup_ (struct GNUNET_SERVER_Client *client);
  * @param message the actual message
  * @return pending request handle for the request, NULL on error
  */
-struct GSF_PendingRequest *
-GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
-                                        const struct GNUNET_MessageHeader *message);
+struct GSF_PendingRequest *GSF_local_client_start_search_handler_ (struct
+                                                                   GNUNET_SERVER_Client
+                                                                   *client,
+                                                                   const struct
+                                                                   GNUNET_MessageHeader
+                                                                   *message);
 
 
 /**
@@ -65,7 +68,7 @@ GSF_local_client_start_search_handler_ (struct GNUNET_SERVER_Client *client,
  */
 void
 GSF_local_client_transmit_ (struct GSF_LocalClient *lc,
-                            const struct GNUNET_MessageHeader *msg);
+                            const struct GNUNET_MessageHeader *msg);
 
 
 /**
@@ -75,8 +78,7 @@ GSF_local_client_transmit_ (struct GSF_LocalClient *lc,
  * @param client handle of the client
  */
 void
-GSF_client_disconnect_handler_ (void *cls,
-                                struct GNUNET_SERVER_Client *client);
+GSF_client_disconnect_handler_ (void *cls, struct GNUNET_SERVER_Client *client);
 
 
 #endif
diff --git a/src/fs/gnunet-service-fs_pe.c b/src/fs/gnunet-service-fs_pe.c
index 789642fc6..d3ab5026b 100644
--- a/src/fs/gnunet-service-fs_pe.c
+++ b/src/fs/gnunet-service-fs_pe.c
@@ -43,7 +43,7 @@ struct PendingRequestList;
  */
 struct GSF_RequestPlanReference
 {
-  
+
   /**
    * This is a doubly-linked list.
    */
@@ -123,12 +123,12 @@ struct GSF_RequestPlan
   /**
    * Head of list of associated pending requests.
    */
-  struct PendingRequestList *prl_head;  
+  struct PendingRequestList *prl_head;
 
   /**
    * Tail of list of associated pending requests.
    */
-  struct PendingRequestList *prl_tail;  
+  struct PendingRequestList *prl_tail;
 
   /**
    * Earliest time we'd be happy to (re)transmit this request.
@@ -209,7 +209,7 @@ static unsigned long long plan_count;
  */
 static void
 schedule_peer_transmission (void *cls,
-                            const struct GNUNET_SCHEDULER_TaskContext *tc);
+                            const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -219,42 +219,36 @@ schedule_peer_transmission (void *cls,
  * @param rp request to plan
  */
 static void
-plan (struct PeerPlan *pp,
-      struct GSF_RequestPlan *rp)
+plan (struct PeerPlan *pp, struct GSF_RequestPlan *rp)
 {
   struct GSF_PendingRequestData *prd;
   struct GNUNET_TIME_Relative delay;
 
   GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop ("# average retransmission delay (ms)"),
-                         total_delay * 1000LL / plan_count,
-                         GNUNET_NO);
+                         gettext_noop ("# average retransmission delay (ms)"),
+                         total_delay * 1000LL / plan_count, GNUNET_NO);
   prd = GSF_pending_request_get_data_ (rp->prl_head->pr);
   // FIXME: calculate 'rp->priority'!  
   if (rp->transmission_counter < 32)
     delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                           1LL << rp->transmission_counter);
+                                           1LL << rp->transmission_counter);
   else
-    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                           UINT_MAX);
-  rp->earliest_transmission 
-    = GNUNET_TIME_relative_to_absolute (delay);
+    delay = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, UINT_MAX);
+  rp->earliest_transmission = GNUNET_TIME_relative_to_absolute (delay);
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Earliest (re)transmission for `%s' in %us\n",
-              GNUNET_h2s (&prd->query),
-              rp->transmission_counter);
-#endif 
+              "Earliest (re)transmission for `%s' in %us\n",
+              GNUNET_h2s (&prd->query), rp->transmission_counter);
+#endif
 
   GNUNET_assert (rp->hn == NULL);
-  if (GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value == 0)
-    rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
-                                           rp,
-                                           rp->priority);
+  if (GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value
+      == 0)
+    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);
+                                           rp,
+                                           rp->earliest_transmission.abs_value);
   if (GNUNET_SCHEDULER_NO_TASK != pp->task)
     GNUNET_SCHEDULER_cancel (pp->task);
   pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
@@ -277,13 +271,13 @@ get_latest (const struct GSF_RequestPlan *rp)
   ret = prl->pr;
   prl = prl->next;
   while (NULL != prl)
-    {
-      if (GSF_pending_request_get_data_ (prl->pr)->ttl.abs_value >
-          GSF_pending_request_get_data_ (ret)->ttl.abs_value)
-        ret = prl->pr;
-      prl = prl->next;
-    }
-  return ret;  
+  {
+    if (GSF_pending_request_get_data_ (prl->pr)->ttl.abs_value >
+        GSF_pending_request_get_data_ (ret)->ttl.abs_value)
+      ret = prl->pr;
+    prl = prl->next;
+  }
+  return ret;
 }
 
 
@@ -295,10 +289,8 @@ get_latest (const struct GSF_RequestPlan *rp)
  * @param buf where to copy the message, NULL on error (peer disconnect)
  * @return number of bytes copied to 'buf', can be 0 (without indicating an error)
  */
-static size_t 
-transmit_message_callback (void *cls,
-                           size_t buf_size,
-                           void *buf)
+static size_t
+transmit_message_callback (void *cls, size_t buf_size, void *buf)
 {
   struct PeerPlan *pp = cls;
   struct GSF_RequestPlan *rp;
@@ -306,24 +298,24 @@ transmit_message_callback (void *cls,
 
   pp->pth = NULL;
   if (NULL == buf)
-    {
-      /* failed, try again... */
-      pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
-      return 0;
-    }
+  {
+    /* failed, try again... */
+    pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
+    return 0;
+  }
   rp = GNUNET_CONTAINER_heap_peek (pp->priority_heap);
   if (NULL == rp)
-    {
-      pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
-      return 0;
-    }
+  {
+    pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
+    return 0;
+  }
   msize = GSF_pending_request_get_message_ (get_latest (rp), buf_size, buf);
   if (msize > buf_size)
-    {
-      /* buffer to small (message changed), try again */
-      pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
-      return 0;
-    }
+  {
+    /* buffer to small (message changed), try again */
+    pp->task = GNUNET_SCHEDULER_add_now (&schedule_peer_transmission, pp);
+    return 0;
+  }
   /* remove from root, add again elsewhere... */
   GNUNET_assert (rp == GNUNET_CONTAINER_heap_remove_root (pp->priority_heap));
   rp->hn = NULL;
@@ -332,15 +324,14 @@ transmit_message_callback (void *cls,
   total_delay++;
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Executing plan %p executed %u times, planning retransmission\n",
-              rp,
-              rp->transmission_counter);
-#endif    
+              "Executing plan %p executed %u times, planning retransmission\n",
+              rp, rp->transmission_counter);
+#endif
   plan (pp, rp);
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# queries messages sent to other peers"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop
+                            ("# queries messages sent to other peers"), 1,
+                            GNUNET_NO);
   return msize;
 }
 
@@ -353,7 +344,7 @@ transmit_message_callback (void *cls,
  */
 static void
 schedule_peer_transmission (void *cls,
-                            const struct GNUNET_SCHEDULER_TaskContext *tc)
+                            const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PeerPlan *pp = cls;
   struct GSF_RequestPlan *rp;
@@ -361,59 +352,55 @@ schedule_peer_transmission (void *cls,
 
   pp->task = GNUNET_SCHEDULER_NO_TASK;
   if (pp->pth != NULL)
-    {
-      GSF_peer_transmit_cancel_ (pp->pth);
-      pp->pth = NULL;
-    }
+  {
+    GSF_peer_transmit_cancel_ (pp->pth);
+    pp->pth = NULL;
+  }
   /* move ready requests to priority queue */
-  while ( (NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&
-          (GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value == 0) )
-    {
-      GNUNET_assert (rp == GNUNET_CONTAINER_heap_remove_root (pp->delay_heap));
-      rp->hn = GNUNET_CONTAINER_heap_insert (pp->priority_heap,
-                                             rp, 
-                                             rp->priority);                                     
-    }   
+  while ((NULL != (rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap))) &&
+         (GNUNET_TIME_absolute_get_remaining
+          (rp->earliest_transmission).rel_value == 0))
+  {
+    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)
     {
-      /* priority heap (still) empty, check for delay... */
-      rp = GNUNET_CONTAINER_heap_peek (pp->delay_heap);
-      if (NULL == rp)
-        {
-#if DEBUG_FS
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "No active requests for plan %p.\n",
-                      pp);
-#endif
-          return; /* both queues empty */
-        }
 #if DEBUG_FS
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Sleeping for %llu ms before retrying requests on plan %p.\n",
-                  (unsigned long long) GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission).rel_value,
-                  pp);
+                  "No active requests for plan %p.\n", pp);
 #endif
-      pp->task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining (rp->earliest_transmission),
-                                               &schedule_peer_transmission,
-                                               pp);
-      return;
+      return;                   /* both queues empty */
     }
+#if DEBUG_FS
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Sleeping for %llu ms before retrying requests on plan %p.\n",
+                (unsigned long long)
+                GNUNET_TIME_absolute_get_remaining
+                (rp->earliest_transmission).rel_value, pp);
+#endif
+    pp->task =
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining
+                                      (rp->earliest_transmission),
+                                      &schedule_peer_transmission, pp);
+    return;
+  }
   /* process from priority heap */
   rp = GNUNET_CONTAINER_heap_peek (pp->priority_heap);
 #if DEBUG_FS > 1
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Executing query plan %p\n",
-              rp);
-#endif    
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing query plan %p\n", rp);
+#endif
   GNUNET_assert (NULL != rp);
   msize = GSF_pending_request_get_message_ (get_latest (rp), 0, NULL);
   pp->pth = GSF_peer_transmit_ (pp->cp,
-                                GNUNET_YES,
-                                rp->priority,
-                                GNUNET_TIME_UNIT_FOREVER_REL,
-                                msize,
-                                &transmit_message_callback,
-                                pp);
+                                GNUNET_YES,
+                                rp->priority,
+                                GNUNET_TIME_UNIT_FOREVER_REL,
+                                msize, &transmit_message_callback, pp);
   GNUNET_assert (NULL != pp->pth);
 }
 
@@ -444,9 +431,8 @@ struct MergeContext
  */
 static int
 merge_pr (void *cls,
-          struct GNUNET_CONTAINER_HeapNode *node,
-          void *element,
-          GNUNET_CONTAINER_HeapCostType cost)
+          struct GNUNET_CONTAINER_HeapNode *node,
+          void *element, GNUNET_CONTAINER_HeapCostType cost)
 {
   struct MergeContext *mpr = cls;
   struct GSF_RequestPlan *rp = element;
@@ -456,37 +442,30 @@ merge_pr (void *cls,
   struct GSF_PendingRequest *latest;
 
   if (GNUNET_OK !=
-      GSF_pending_request_is_compatible_ (mpr->pr, 
-                                          rp->prl_head->pr))
+      GSF_pending_request_is_compatible_ (mpr->pr, rp->prl_head->pr))
     return GNUNET_YES;
   /* merge new request with existing request plan */
-  rpr = GNUNET_malloc (sizeof (struct GSF_RequestPlanReference));  
-  prl = GNUNET_malloc (sizeof (struct PendingRequestList));  
+  rpr = GNUNET_malloc (sizeof (struct GSF_RequestPlanReference));
+  prl = GNUNET_malloc (sizeof (struct PendingRequestList));
   rpr->rp = rp;
   rpr->prl = prl;
   prl->rpr = rpr;
   prl->pr = mpr->pr;
   prd = GSF_pending_request_get_data_ (mpr->pr);
-  GNUNET_CONTAINER_DLL_insert (prd->rpr_head,
-                               prd->rpr_tail,
-                               rpr);
-  GNUNET_CONTAINER_DLL_insert (rp->prl_head,
-                               rp->prl_tail,
-                               prl);
+  GNUNET_CONTAINER_DLL_insert (prd->rpr_head, prd->rpr_tail, rpr);
+  GNUNET_CONTAINER_DLL_insert (rp->prl_head, rp->prl_tail, prl);
   mpr->merged = GNUNET_YES;
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# requests merged"),
-                            1,
-                            GNUNET_NO);  
+                            gettext_noop ("# requests merged"), 1, GNUNET_NO);
   latest = get_latest (rp);
-  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value < prd->ttl.abs_value)
-    {
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# requests refreshed"),
-                                1,
-                                GNUNET_NO);  
-      rp->transmission_counter = 0; /* reset */         
-    }
+  if (GSF_pending_request_get_data_ (latest)->ttl.abs_value <
+      prd->ttl.abs_value)
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop ("# requests refreshed"),
+                              1, GNUNET_NO);
+    rp->transmission_counter = 0;       /* reset */
+  }
   return GNUNET_NO;
 }
 
@@ -498,8 +477,7 @@ 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)
 {
   struct GNUNET_PeerIdentity id;
   struct PeerPlan *pp;
@@ -511,19 +489,20 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
 
   GNUNET_assert (NULL != cp);
   GSF_connected_peer_get_identity_ (cp, &id);
-  pp = GNUNET_CONTAINER_multihashmap_get (plans,
-                                          &id.hashPubKey);
+  pp = GNUNET_CONTAINER_multihashmap_get (plans, &id.hashPubKey);
   if (NULL == pp)
-    {
-      pp = GNUNET_malloc (sizeof (struct PeerPlan));
-      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_CONTAINER_multihashmap_put (plans,
-                                         &id.hashPubKey,
-                                         pp,
-                                         GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
-    }
+  {
+    pp = GNUNET_malloc (sizeof (struct PeerPlan));
+    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_CONTAINER_multihashmap_put (plans,
+                                       &id.hashPubKey,
+                                       pp,
+                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  }
   mpc.merged = GNUNET_NO;
   mpc.pr = pr;
   GNUNET_CONTAINER_heap_iterate (pp->priority_heap, &merge_pr, &mpc);
@@ -534,29 +513,23 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
     return;
   plan_count++;
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# query plan entries"),
-                            1,
-                            GNUNET_NO);  
+                            gettext_noop ("# query plan entries"),
+                            1, GNUNET_NO);
   prd = GSF_pending_request_get_data_ (pr);
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Planning transmission of query `%s' to peer `%s'\n",
-              GNUNET_h2s (&prd->query),
-              GNUNET_i2s (&id));
-#endif    
+              "Planning transmission of query `%s' to peer `%s'\n",
+              GNUNET_h2s (&prd->query), GNUNET_i2s (&id));
+#endif
   rp = GNUNET_malloc (sizeof (struct GSF_RequestPlan));
-  rpr = GNUNET_malloc (sizeof (struct GSF_RequestPlanReference));  
-  prl = GNUNET_malloc (sizeof (struct PendingRequestList));  
+  rpr = GNUNET_malloc (sizeof (struct GSF_RequestPlanReference));
+  prl = GNUNET_malloc (sizeof (struct PendingRequestList));
   rpr->rp = rp;
   rpr->prl = prl;
   prl->rpr = rpr;
   prl->pr = pr;
-  GNUNET_CONTAINER_DLL_insert (prd->rpr_head,
-                               prd->rpr_tail,
-                               rpr);
-  GNUNET_CONTAINER_DLL_insert (rp->prl_head,
-                               rp->prl_tail,
-                               prl);
+  GNUNET_CONTAINER_DLL_insert (prd->rpr_head, prd->rpr_tail, rpr);
+  GNUNET_CONTAINER_DLL_insert (rp->prl_head, rp->prl_tail, prl);
   plan (pp, rp);
 }
 
@@ -577,58 +550,47 @@ GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp)
   struct PendingRequestList *prl;
 
   GSF_connected_peer_get_identity_ (cp, &id);
-  pp = GNUNET_CONTAINER_multihashmap_get (plans,
-                                          &id.hashPubKey);
+  pp = GNUNET_CONTAINER_multihashmap_get (plans, &id.hashPubKey);
   if (NULL == pp)
-    return; /* nothing was ever planned for this peer */
+    return;                     /* nothing was ever planned for this peer */
   GNUNET_assert (GNUNET_YES ==
-                 GNUNET_CONTAINER_multihashmap_remove (plans,
-                                                       &id.hashPubKey,
-                                                       pp));
+                 GNUNET_CONTAINER_multihashmap_remove (plans,
+                                                       &id.hashPubKey, pp));
   if (NULL != pp->pth)
     GSF_peer_transmit_cancel_ (pp->pth);
   if (GNUNET_SCHEDULER_NO_TASK != pp->task)
-    {
-      GNUNET_SCHEDULER_cancel (pp->task);
-      pp->task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pp->task);
+    pp->task = GNUNET_SCHEDULER_NO_TASK;
+  }
   while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->priority_heap)))
+  {
+    while (NULL != (prl = rp->prl_head))
     {
-      while (NULL != (prl = rp->prl_head))
-        {
-          GNUNET_CONTAINER_DLL_remove (rp->prl_head,
-                                       rp->prl_tail,
-                                       prl);
-          prd = GSF_pending_request_get_data_ (prl->pr);
-          GNUNET_CONTAINER_DLL_remove (prd->rpr_head,
-                                       prd->rpr_tail,
-                                       prl->rpr);
-          GNUNET_free (prl->rpr);
-          GNUNET_free (prl);
-        }
-      GNUNET_free (rp);
+      GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, prl);
+      prd = GSF_pending_request_get_data_ (prl->pr);
+      GNUNET_CONTAINER_DLL_remove (prd->rpr_head, prd->rpr_tail, prl->rpr);
+      GNUNET_free (prl->rpr);
+      GNUNET_free (prl);
     }
+    GNUNET_free (rp);
+  }
   GNUNET_CONTAINER_heap_destroy (pp->priority_heap);
   while (NULL != (rp = GNUNET_CONTAINER_heap_remove_root (pp->delay_heap)))
+  {
+    while (NULL != (prl = rp->prl_head))
     {
-      while (NULL != (prl = rp->prl_head))
-        {
-          GNUNET_CONTAINER_DLL_remove (rp->prl_head,
-                                       rp->prl_tail,
-                                       prl);
-          prd = GSF_pending_request_get_data_ (prl->pr);
-          GNUNET_CONTAINER_DLL_remove (prd->rpr_head,
-                                       prd->rpr_tail,
-                                       prl->rpr);
-          GNUNET_free (prl->rpr);
-          GNUNET_free (prl);
-        }
-      GNUNET_free (rp);
+      GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, prl);
+      prd = GSF_pending_request_get_data_ (prl->pr);
+      GNUNET_CONTAINER_DLL_remove (prd->rpr_head, prd->rpr_tail, prl->rpr);
+      GNUNET_free (prl->rpr);
+      GNUNET_free (prl);
     }
+    GNUNET_free (rp);
+  }
   GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop ("# query plan entries"),
-                         plan_count,
-                         GNUNET_NO);
+                         gettext_noop ("# query plan entries"),
+                         plan_count, GNUNET_NO);
 
   GNUNET_CONTAINER_heap_destroy (pp->delay_heap);
   GNUNET_free (pp);
@@ -650,27 +612,22 @@ GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr)
 
   prd = GSF_pending_request_get_data_ (pr);
   while (NULL != (rpr = prd->rpr_head))
+  {
+    GNUNET_CONTAINER_DLL_remove (prd->rpr_head, prd->rpr_tail, rpr);
+    rp = rpr->rp;
+    GNUNET_CONTAINER_DLL_remove (rp->prl_head, rp->prl_tail, rpr->prl);
+    GNUNET_free (rpr->prl);
+    GNUNET_free (rpr);
+    if (rp->prl_head == 0)
     {
-      GNUNET_CONTAINER_DLL_remove (prd->rpr_head,
-                                   prd->rpr_tail,
-                                   rpr);
-      rp = rpr->rp;
-      GNUNET_CONTAINER_DLL_remove (rp->prl_head,
-                                   rp->prl_tail,
-                                   rpr->prl);
-      GNUNET_free (rpr->prl);
-      GNUNET_free (rpr);
-      if (rp->prl_head == 0)
-        {
-          GNUNET_CONTAINER_heap_remove_node (rp->hn);
-          plan_count--;
-          GNUNET_free (rp);
-        }
+      GNUNET_CONTAINER_heap_remove_node (rp->hn);
+      plan_count--;
+      GNUNET_free (rp);
     }
+  }
   GNUNET_STATISTICS_set (GSF_stats,
-                         gettext_noop ("# query plan entries"),
-                         plan_count,
-                         GNUNET_NO);  
+                         gettext_noop ("# query plan entries"),
+                         plan_count, GNUNET_NO);
 }
 
 
@@ -690,8 +647,7 @@ GSF_plan_init ()
 void
 GSF_plan_done ()
 {
-  GNUNET_assert (0 == 
-                 GNUNET_CONTAINER_multihashmap_size (plans));
+  GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (plans));
   GNUNET_CONTAINER_multihashmap_destroy (plans);
 }
 
diff --git a/src/fs/gnunet-service-fs_pe.h b/src/fs/gnunet-service-fs_pe.h
index 37280adc6..7fbf9fc4a 100644
--- a/src/fs/gnunet-service-fs_pe.h
+++ b/src/fs/gnunet-service-fs_pe.h
@@ -36,8 +36,7 @@
  * @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);
 
 
 /**
@@ -46,8 +45,7 @@ GSF_plan_add_ (struct GSF_ConnectedPeer *cp,
  *
  * @param cp connected peer 
  */
-void
-GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp);
+void GSF_plan_notify_peer_disconnect_ (const struct GSF_ConnectedPeer *cp);
 
 
 /**
@@ -56,22 +54,19 @@ 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);
+void GSF_plan_notify_request_done_ (struct GSF_PendingRequest *pr);
 
 
 /**
  * Initialize plan subsystem.
  */
-void
-GSF_plan_init (void);
+void GSF_plan_init (void);
 
 
 /**
  * Shutdown plan subsystem.
  */
-void
-GSF_plan_done (void);
+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 d3ea241a5..e637be664 100644
--- a/src/fs/gnunet-service-fs_pr.c
+++ b/src/fs/gnunet-service-fs_pr.c
@@ -43,7 +43,7 @@ struct GSF_PendingRequest
 {
   /**
    * Public data for the request.
-   */ 
+   */
   struct GSF_PendingRequestData public_data;
 
   /**
@@ -236,23 +236,19 @@ refresh_bloomfilter (struct GSF_PendingRequest *pr)
   GNUNET_HashCode mhash;
 
   nsize = compute_bloomfilter_size (pr->replies_seen_count);
-  if ( (pr->bf != NULL) &&
-       (nsize == GNUNET_CONTAINER_bloomfilter_get_size (pr->bf)) )
-    return GNUNET_NO; /* size not changed */
+  if ((pr->bf != NULL) &&
+      (nsize == GNUNET_CONTAINER_bloomfilter_get_size (pr->bf)))
+    return GNUNET_NO;           /* size not changed */
   if (pr->bf != NULL)
     GNUNET_CONTAINER_bloomfilter_free (pr->bf);
-  pr->mingle = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 
-                                         UINT32_MAX);
-  pr->bf = GNUNET_CONTAINER_bloomfilter_init (NULL, 
-                                              nsize,
-                                              BLOOMFILTER_K);
-  for (i=0;i<pr->replies_seen_count;i++)
-    {
-      GNUNET_BLOCK_mingle_hash (&pr->replies_seen[i],
-                                pr->mingle,
-                                &mhash);
-      GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
-    }
+  pr->mingle = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                         UINT32_MAX);
+  pr->bf = GNUNET_CONTAINER_bloomfilter_init (NULL, nsize, BLOOMFILTER_K);
+  for (i = 0; i < pr->replies_seen_count; i++)
+  {
+    GNUNET_BLOCK_mingle_hash (&pr->replies_seen[i], pr->mingle, &mhash);
+    GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
+  }
   return GNUNET_YES;
 }
 
@@ -280,118 +276,115 @@ refresh_bloomfilter (struct GSF_PendingRequest *pr)
  */
 struct GSF_PendingRequest *
 GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
-                             enum GNUNET_BLOCK_Type type,
-                             const GNUNET_HashCode *query,
-                             const GNUNET_HashCode *namespace,
-                             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,
-                             const GNUNET_HashCode *replies_seen,
-                             unsigned int replies_seen_count,
-                             GSF_PendingRequestReplyHandler rh,
-                             void *rh_cls)
+                             enum GNUNET_BLOCK_Type type,
+                             const GNUNET_HashCode * query,
+                             const GNUNET_HashCode * namespace,
+                             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,
+                             const GNUNET_HashCode * replies_seen,
+                             unsigned int replies_seen_count,
+                             GSF_PendingRequestReplyHandler rh, void *rh_cls)
 {
   struct GSF_PendingRequest *pr;
   struct GSF_PendingRequest *dpr;
-  
+
 #if DEBUG_FS > 1
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Creating request handle for `%s' of type %d\n",
-              GNUNET_h2s (query),
-              type);
-#endif 
+              "Creating request handle for `%s' of type %d\n",
+              GNUNET_h2s (query), type);
+#endif
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# Pending requests created"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# Pending requests created"),
+                            1, GNUNET_NO);
   pr = GNUNET_malloc (sizeof (struct GSF_PendingRequest));
-  pr->local_result_offset = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                                      UINT64_MAX);                                                       
+  pr->local_result_offset =
+      GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK, UINT64_MAX);
   pr->public_data.query = *query;
   if (GNUNET_BLOCK_TYPE_FS_SBLOCK == type)
-    {
-      GNUNET_assert (NULL != namespace);
-      pr->public_data.namespace = *namespace;
-    }
+  {
+    GNUNET_assert (NULL != namespace);
+    pr->public_data.namespace = *namespace;
+  }
   if (NULL != target)
-    {
-      pr->public_data.target = *target;
-      pr->public_data.has_target = GNUNET_YES;
-    }
+  {
+    pr->public_data.target = *target;
+    pr->public_data.has_target = GNUNET_YES;
+  }
   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.type = type;
   pr->public_data.start_time = GNUNET_TIME_absolute_get ();
   pr->sender_pid = sender_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.start_time,
-                                                         GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                                                                        (uint32_t) (- ttl)));
+    pr->public_data.ttl =
+        GNUNET_TIME_absolute_subtract (pr->public_data.start_time,
+                                       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_malloc (sizeof (GNUNET_HashCode) * pr->replies_seen_size);
-      memcpy (pr->replies_seen,
-              replies_seen,
-              replies_seen_count * sizeof (GNUNET_HashCode));
-      pr->replies_seen_count = replies_seen_count;
-    }
-  if (NULL != bf_data)    
-    {
-      pr->bf = GNUNET_CONTAINER_bloomfilter_init (bf_data,
-                                                  bf_size,
-                                                  BLOOMFILTER_K);
-      pr->mingle = mingle;
-    }
-  else if ( (replies_seen_count > 0) &&
-            (0 != (options & GSF_PRO_BLOOMFILTER_FULL_REFRESH)) )
-    {
-      GNUNET_assert (GNUNET_YES == refresh_bloomfilter (pr));
-    }
+  {
+    pr->replies_seen_size = replies_seen_count;
+    pr->replies_seen =
+        GNUNET_malloc (sizeof (GNUNET_HashCode) * pr->replies_seen_size);
+    memcpy (pr->replies_seen, replies_seen,
+            replies_seen_count * sizeof (GNUNET_HashCode));
+    pr->replies_seen_count = replies_seen_count;
+  }
+  if (NULL != bf_data)
+  {
+    pr->bf = GNUNET_CONTAINER_bloomfilter_init (bf_data,
+                                                bf_size, BLOOMFILTER_K);
+    pr->mingle = mingle;
+  }
+  else if ((replies_seen_count > 0) &&
+           (0 != (options & GSF_PRO_BLOOMFILTER_FULL_REFRESH)))
+  {
+    GNUNET_assert (GNUNET_YES == refresh_bloomfilter (pr));
+  }
   GNUNET_CONTAINER_multihashmap_put (pr_map,
-                                     query,
-                                     pr,
-                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
+                                     query,
+                                     pr,
+                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
   if (0 != (options & GSF_PRO_REQUEST_EXPIRES))
+  {
+    pr->hnode = GNUNET_CONTAINER_heap_insert (requests_by_expiration_heap,
+                                              pr,
+                                              pr->public_data.ttl.abs_value);
+    /* 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);
-      /* 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 (dpr != NULL);
-          if (pr == dpr)
-            break; /* let the request live briefly... */
-          dpr->rh (dpr->rh_cls,
-                   GNUNET_BLOCK_EVALUATION_REQUEST_VALID,
-                   dpr,
-                   UINT32_MAX,
-                   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 (dpr != NULL);
+      if (pr == dpr)
+        break;                  /* let the request live briefly... */
+      dpr->rh (dpr->rh_cls,
+               GNUNET_BLOCK_EVALUATION_REQUEST_VALID,
+               dpr,
+               UINT32_MAX,
+               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);
+                            gettext_noop ("# Pending requests active"),
+                            1, GNUNET_NO);
   return pr;
 }
 
@@ -420,16 +413,15 @@ GSF_pending_request_get_data_ (struct GSF_PendingRequest *pr)
  */
 int
 GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
-                                    struct GSF_PendingRequest *prb)
+                                    struct GSF_PendingRequest *prb)
 {
-  if ( (pra->public_data.type != prb->public_data.type) ||
-       (0 != memcmp (&pra->public_data.query,
-                     &prb->public_data.query,
-                     sizeof (GNUNET_HashCode))) ||
-       ( (pra->public_data.type == GNUNET_BLOCK_TYPE_FS_SBLOCK) &&
-         (0 != memcmp (&pra->public_data.namespace,
-                       &prb->public_data.namespace,
-                       sizeof (GNUNET_HashCode))) ) )
+  if ((pra->public_data.type != prb->public_data.type) ||
+      (0 != memcmp (&pra->public_data.query,
+                    &prb->public_data.query,
+                    sizeof (GNUNET_HashCode))) ||
+      ((pra->public_data.type == GNUNET_BLOCK_TYPE_FS_SBLOCK) &&
+       (0 != memcmp (&pra->public_data.namespace,
+                     &prb->public_data.namespace, sizeof (GNUNET_HashCode)))))
     return GNUNET_NO;
   return GNUNET_OK;
 }
@@ -446,57 +438,53 @@ GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
  */
 void
 GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
-                             const GNUNET_HashCode *replies_seen,
-                             unsigned int replies_seen_count)
+                             const GNUNET_HashCode * replies_seen,
+                             unsigned int replies_seen_count)
 {
   unsigned int i;
   GNUNET_HashCode mhash;
 
   if (replies_seen_count + pr->replies_seen_count < pr->replies_seen_count)
-    return; /* integer overflow */
+    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);
+    memcpy (&pr->replies_seen[pr->replies_seen_count],
+            replies_seen, sizeof (GNUNET_HashCode) * replies_seen_count);
+    pr->replies_seen_count += replies_seen_count;
+    if (GNUNET_NO == refresh_bloomfilter (pr))
     {
-      /* 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);
-      memcpy (&pr->replies_seen[pr->replies_seen_count],
-              replies_seen,
-              sizeof (GNUNET_HashCode) * replies_seen_count);
-      pr->replies_seen_count += replies_seen_count;
-      if (GNUNET_NO == refresh_bloomfilter (pr))
-        {
-          /* bf not recalculated, simply extend it with new bits */
-          for (i=0;i<replies_seen_count;i++)
-            {
-              GNUNET_BLOCK_mingle_hash (&replies_seen[i],
-                                        pr->mingle,
-                                        &mhash);
-              GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
-            }
-        }
+      /* bf not recalculated, simply extend it with new bits */
+      for (i = 0; i < replies_seen_count; i++)
+      {
+        GNUNET_BLOCK_mingle_hash (&replies_seen[i], pr->mingle, &mhash);
+        GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
+      }
     }
+  }
   else
+  {
+    if (NULL == pr->bf)
+    {
+      /* we're not the initiator, but the initiator did not give us
+       * any bloom-filter, so we need to create one on-the-fly */
+      pr->mingle = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
+                                             UINT32_MAX);
+      pr->bf = GNUNET_CONTAINER_bloomfilter_init (NULL,
+                                                  compute_bloomfilter_size
+                                                  (replies_seen_count),
+                                                  BLOOMFILTER_K);
+    }
+    for (i = 0; i < pr->replies_seen_count; i++)
     {
-      if (NULL == pr->bf)
-        {
-          /* we're not the initiator, but the initiator did not give us
-             any bloom-filter, so we need to create one on-the-fly */
-          pr->mingle = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 
-                                                 UINT32_MAX);
-          pr->bf = GNUNET_CONTAINER_bloomfilter_init (NULL,
-                                                      compute_bloomfilter_size (replies_seen_count),
-                                                      BLOOMFILTER_K);
-        }
-      for (i=0;i<pr->replies_seen_count;i++)
-        {
-          GNUNET_BLOCK_mingle_hash (&replies_seen[i],
-                                    pr->mingle,
-                                    &mhash);
-          GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
-        }
+      GNUNET_BLOCK_mingle_hash (&replies_seen[i], pr->mingle, &mhash);
+      GNUNET_CONTAINER_bloomfilter_add (pr->bf, &mhash);
     }
+  }
 }
 
 
@@ -511,8 +499,7 @@ GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
  */
 size_t
 GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
-                                  size_t buf_size,
-                                  void *buf)
+                                  size_t buf_size, void *buf)
 {
   char lbuf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
   struct GetMessage *gm;
@@ -529,45 +516,44 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
 #if DEBUG_FS
   if (buf_size > 0)
     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);
-#endif 
+                "Building request message for `%s' of type %d\n",
+                GNUNET_h2s (&pr->public_data.query), pr->public_data.type);
+#endif
   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 (GNUNET_BLOCK_TYPE_FS_SBLOCK == pr->public_data.type)
-    {
-      bm |= GET_MESSAGE_BIT_SKS_NAMESPACE;
-      k++;
-    }
+  {
+    bm |= GET_MESSAGE_BIT_SKS_NAMESPACE;
+    k++;
+  }
   if (GNUNET_YES == pr->public_data.has_target)
-    {
-      bm |= GET_MESSAGE_BIT_TRANSMIT_TO;
-      k++;
-    }
+  {
+    bm |= GET_MESSAGE_BIT_TRANSMIT_TO;
+    k++;
+  }
   bf_size = GNUNET_CONTAINER_bloomfilter_get_size (pr->bf);
-  msize = sizeof (struct GetMessage) + bf_size + k * sizeof(GNUNET_HashCode);
+  msize = sizeof (struct GetMessage) + bf_size + k * sizeof (GNUNET_HashCode);
   GNUNET_assert (msize < GNUNET_SERVER_MAX_MESSAGE_SIZE);
   if (buf_size < msize)
-    return msize;  
-  gm = (struct GetMessage*) lbuf;
+    return msize;
+  gm = (struct GetMessage *) lbuf;
   gm->header.type = htons (GNUNET_MESSAGE_TYPE_FS_GET);
   gm->header.size = htons (msize);
   gm->type = htonl (pr->public_data.type);
   if (do_route)
     prio = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
-                                     pr->public_data.priority + 1);
+                                     pr->public_data.priority + 1);
   else
     prio = 0;
   pr->public_data.priority -= prio;
@@ -575,25 +561,23 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
   now = GNUNET_TIME_absolute_get ();
   ttl = (int64_t) (pr->public_data.ttl.abs_value - now.abs_value);
   gm->ttl = htonl (ttl / 1000);
-  gm->filter_mutator = htonl(pr->mingle); 
+  gm->filter_mutator = htonl (pr->mingle);
   gm->hash_bitmap = htonl (bm);
   gm->query = pr->public_data.query;
-  ext = (GNUNET_HashCode*) &gm[1];
-  k = 0;  
-  if (! do_route)
-    GNUNET_PEER_resolve (pr->sender_pid, 
-                         (struct GNUNET_PeerIdentity*) &ext[k++]);
+  ext = (GNUNET_HashCode *) & gm[1];
+  k = 0;
+  if (!do_route)
+    GNUNET_PEER_resolve (pr->sender_pid,
+                         (struct GNUNET_PeerIdentity *) &ext[k++]);
   if (GNUNET_BLOCK_TYPE_FS_SBLOCK == pr->public_data.type)
-    memcpy (&ext[k++], 
-            &pr->public_data.namespace, 
-            sizeof (GNUNET_HashCode));
+    memcpy (&ext[k++], &pr->public_data.namespace, sizeof (GNUNET_HashCode));
   if (GNUNET_YES == pr->public_data.has_target)
     ext[k++] = pr->public_data.target.hashPubKey;
   if (pr->bf != NULL)
     GNUNET_assert (GNUNET_SYSERR !=
-                   GNUNET_CONTAINER_bloomfilter_get_raw_data (pr->bf,
-                                                              (char*) &ext[k],
-                                                              bf_size));
+                   GNUNET_CONTAINER_bloomfilter_get_raw_data (pr->bf,
+                                                              (char *) &ext[k],
+                                                              bf_size));
   memcpy (buf, gm, msize);
   return msize;
 }
@@ -607,63 +591,57 @@ GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
  * @param value value in the hash map (pending request)
  * @return GNUNET_YES (we should continue to iterate)
  */
-static int 
-clean_request (void *cls,
-               const GNUNET_HashCode * key,
-               void *value)
+static int
+clean_request (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct GSF_PendingRequest *pr = value;
   GSF_LocalLookupContinuation cont;
 
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Cleaning up pending request for `%s'.\n",
-              GNUNET_h2s (key));
-#endif  
+              "Cleaning up pending request for `%s'.\n", GNUNET_h2s (key));
+#endif
   if (NULL != (cont = pr->llc_cont))
-    {
-      pr->llc_cont = NULL;
-      cont (pr->llc_cont_cls,
-            pr,
-            pr->local_result);
-    } 
+  {
+    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);
   if (NULL != pr->bf)
-    {
-      GNUNET_CONTAINER_bloomfilter_free (pr->bf);
-      pr->bf = NULL;
-    }
+  {
+    GNUNET_CONTAINER_bloomfilter_free (pr->bf);
+    pr->bf = NULL;
+  }
   GNUNET_PEER_change_rc (pr->sender_pid, -1);
   pr->sender_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 (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
-    {
-      GNUNET_SCHEDULER_cancel (pr->warn_task);
-      pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pr->warn_task);
+    pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_CONTAINER_multihashmap_remove (pr_map,
-                                                       &pr->public_data.query,
-                                                       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);
+                            gettext_noop ("# Pending requests active"),
+                            -1, GNUNET_NO);
   GNUNET_free (pr);
   return GNUNET_YES;
 }
@@ -676,46 +654,43 @@ clean_request (void *cls,
  * @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 (NULL == pr_map)
+    return;                     /* already cleaned up! */
   if (GNUNET_YES != 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 != (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 != (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 (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
-        {
-          GNUNET_SCHEDULER_cancel (pr->warn_task);
-          pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      return;
+      GNUNET_DHT_get_stop (pr->gh);
+      pr->gh = NULL;
+    }
+    if (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
+    {
+      GNUNET_SCHEDULER_cancel (pr->warn_task);
+      pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
     }
+    return;
+  }
   GNUNET_assert (GNUNET_YES ==
-                 clean_request (NULL, &pr->public_data.query, pr));  
+                 clean_request (NULL, &pr->public_data.query, pr));
 }
 
 
@@ -726,12 +701,11 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr,
  * @param cls closure for it
  */
 void
-GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it,
-                               void *cls)
+GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls)
 {
   GNUNET_CONTAINER_multihashmap_iterate (pr_map,
-                                         (GNUNET_CONTAINER_HashMapIterator) it,
-                                         cls);
+                                         (GNUNET_CONTAINER_HashMapIterator) it,
+                                         cls);
 }
 
 
@@ -798,15 +772,14 @@ struct ProcessReplyClosure
  */
 static void
 update_request_performance_data (struct ProcessReplyClosure *prq,
-                                 struct GSF_PendingRequest *pr)
+                                 struct GSF_PendingRequest *pr)
 {
   if (prq->sender == NULL)
-    return;      
+    return;
   GSF_peer_update_performance_ (prq->sender,
-                                pr->public_data.start_time,
-                                prq->priority);
+                                pr->public_data.start_time, prq->priority);
 }
-                                
+
 
 /**
  * We have received a reply; handle it!
@@ -817,9 +790,7 @@ update_request_performance_data (struct ProcessReplyClosure *prq,
  * @return GNUNET_YES (we should continue to iterate)
  */
 static int
-process_reply (void *cls,
-               const GNUNET_HashCode *key,
-               void *value)
+process_reply (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct ProcessReplyClosure *prq = cls;
   struct GSF_PendingRequest *pr = value;
@@ -829,88 +800,81 @@ process_reply (void *cls,
     return GNUNET_YES;
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Matched result (type %u) for query `%s' with pending request\n",
-              (unsigned int) prq->type,
-              GNUNET_h2s (key));
-#endif  
+              "Matched result (type %u) for query `%s' with pending request\n",
+              (unsigned int) prq->type, GNUNET_h2s (key));
+#endif
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# replies received and matched"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# replies received and matched"),
+                            1, GNUNET_NO);
   prq->eval = GNUNET_BLOCK_evaluate (GSF_block_ctx,
-                                     prq->type,
-                                     key,
-                                     &pr->bf,
-                                     pr->mingle,
-                                     &pr->public_data.namespace, 
-                                     (prq->type == GNUNET_BLOCK_TYPE_FS_SBLOCK) ? sizeof (GNUNET_HashCode) : 0,
-                                     prq->data,
-                                     prq->size);
+                                     prq->type,
+                                     key,
+                                     &pr->bf,
+                                     pr->mingle,
+                                     &pr->public_data.namespace,
+                                     (prq->type ==
+                                      GNUNET_BLOCK_TYPE_FS_SBLOCK) ?
+                                     sizeof (GNUNET_HashCode) : 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);
-      /* pass on to other peers / local clients */
-      pr->rh (pr->rh_cls,             
-              prq->eval,
-              pr,
-              prq->anonymity_level,
-              prq->expiration,
-              prq->type,
-              prq->data, prq->size);
-      return GNUNET_YES;
-    case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# duplicate replies discarded (bloomfilter)"),
-                                1,
-                                GNUNET_NO);
+  {
+  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);
+    /* pass on to other peers / local clients */
+    pr->rh (pr->rh_cls,
+            prq->eval,
+            pr,
+            prq->anonymity_level,
+            prq->expiration, prq->type, prq->data, prq->size);
+    return GNUNET_YES;
+  case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# duplicate replies discarded (bloomfilter)"),
+                              1, GNUNET_NO);
 #if DEBUG_FS && 0
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Duplicate response `%s', discarding.\n",
-                  GNUNET_h2s (&mhash));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Duplicate response `%s', discarding.\n", GNUNET_h2s (&mhash));
 #endif
-      return GNUNET_YES; /* duplicate */
-    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;
-    }
+    return GNUNET_YES;          /* duplicate */
+  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);
+  GNUNET_CRYPTO_hash (prq->data, prq->size, &chash);
   GSF_pending_request_update_ (pr, &chash, 1);
   if (NULL == prq->sender)
-    {
+  {
 #if DEBUG_FS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Found result for query `%s' in local datastore\n",
-                  GNUNET_h2s (key));
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found result for query `%s' in local datastore\n",
+                GNUNET_h2s (key));
 #endif
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# results found locally"),
-                                1,
-                                GNUNET_NO);      
-    }
+    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;
@@ -918,12 +882,10 @@ process_reply (void *cls,
   prq->request_found = GNUNET_YES;
   /* finally, pass on to other peer / local client */
   pr->rh (pr->rh_cls,
-          prq->eval,
-          pr, 
-          prq->anonymity_level,
-          prq->expiration,
-          prq->type,
-          prq->data, prq->size);
+          prq->eval,
+          pr,
+          prq->anonymity_level,
+          prq->expiration, prq->type, prq->data, prq->size);
   return GNUNET_YES;
 }
 
@@ -960,52 +922,50 @@ struct PutMigrationContext
  * @param success GNUNET_SYSERR on failure
  * @param msg NULL on success, otherwise an error message
  */
-static void 
-put_migration_continuation (void *cls,
-                            int success,
-                            const char *msg)
+static void
+put_migration_continuation (void *cls, int success, const char *msg)
 {
   struct PutMigrationContext *pmc = cls;
   struct GNUNET_TIME_Relative delay;
-  struct GNUNET_TIME_Relative block_time;  
+  struct GNUNET_TIME_Relative block_time;
   struct GSF_ConnectedPeer *cp;
   struct GSF_PeerPerformanceData *ppd;
-                         
+
   delay = GNUNET_TIME_absolute_get_duration (pmc->start);
   cp = GSF_peer_get_ (&pmc->origin);
-  if ( (GNUNET_OK != success) &&
-       (GNUNET_NO == pmc->requested) )
+  if ((GNUNET_OK != success) && (GNUNET_NO == pmc->requested))
+  {
+    /* block migration for a bit... */
+    if (NULL != cp)
     {
-      /* block migration for a bit... */
-      if (NULL != cp)
-        {
-          ppd = GSF_get_peer_performance_data_ (cp);
-          ppd->migration_duplication++;
-          block_time = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
-                                                      5 * ppd->migration_duplication + 
-                                                      GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 5));
-          GSF_block_peer_migration_ (cp, block_time);
-        }
+      ppd = GSF_get_peer_performance_data_ (cp);
+      ppd->migration_duplication++;
+      block_time = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS,
+                                                  5 *
+                                                  ppd->migration_duplication +
+                                                  GNUNET_CRYPTO_random_u32
+                                                  (GNUNET_CRYPTO_QUALITY_WEAK,
+                                                   5));
+      GSF_block_peer_migration_ (cp, block_time);
     }
+  }
   else
+  {
+    if (NULL != cp)
     {
-      if (NULL != cp)
-        {
-          ppd = GSF_get_peer_performance_data_ (cp);
-          ppd->migration_duplication = 0; /* reset counter */
-        }
+      ppd = GSF_get_peer_performance_data_ (cp);
+      ppd->migration_duplication = 0;   /* reset counter */
     }
+  }
   GNUNET_free (pmc);
   /* FIXME: should we really update the load value on failure? */
   if (NULL != datastore_put_load)
-    GNUNET_LOAD_update (datastore_put_load,
-                        delay.rel_value);
+    GNUNET_LOAD_update (datastore_put_load, delay.rel_value);
   if (GNUNET_OK == success)
     return;
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# Datastore `PUT' failures"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# Datastore `PUT' failures"),
+                            1, GNUNET_NO);
 }
 
 
@@ -1025,14 +985,14 @@ test_put_load_too_high (uint32_t priority)
   if (NULL == datastore_put_load)
     return GNUNET_NO;
   if (GNUNET_LOAD_get_average (datastore_put_load) < 50)
-    return GNUNET_NO; /* very fast */
+    return GNUNET_NO;           /* very fast */
   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);
+                            gettext_noop
+                            ("# storage requests dropped due to high load"), 1,
+                            GNUNET_NO);
   return GNUNET_YES;
 }
 
@@ -1054,54 +1014,49 @@ test_put_load_too_high (uint32_t priority)
  */
 static void
 handle_dht_reply (void *cls,
-                  struct GNUNET_TIME_Absolute exp,
-                  const GNUNET_HashCode *key,
-                  const struct GNUNET_PeerIdentity * const *get_path,
-                  const struct GNUNET_PeerIdentity * const *put_path,
-                  enum GNUNET_BLOCK_Type type,
-                  size_t size,
-                  const void *data)
+                  struct GNUNET_TIME_Absolute exp,
+                  const GNUNET_HashCode * key,
+                  const struct GNUNET_PeerIdentity *const *get_path,
+                  const struct GNUNET_PeerIdentity *const *put_path,
+                  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);
+                            gettext_noop ("# Replies received from DHT"),
+                            1, GNUNET_NO);
   memset (&prq, 0, sizeof (prq));
   prq.data = data;
   prq.expiration = exp;
-  prq.size = size;  
+  prq.size = size;
   prq.type = type;
   process_reply (&prq, key, pr);
-  if ( (GNUNET_YES == active_to_migration) &&
-       (GNUNET_NO == test_put_load_too_high (prq.priority)) )
-    {      
+  if ((GNUNET_YES == active_to_migration) &&
+      (GNUNET_NO == test_put_load_too_high (prq.priority)))
+  {
 #if DEBUG_FS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Replicating result for query `%s' with priority %u\n",
-                  GNUNET_h2s (key),
-                  prq.priority);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Replicating result for query `%s' with priority %u\n",
+                GNUNET_h2s (key), prq.priority);
 #endif
-      pmc = GNUNET_malloc (sizeof (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,
-                                GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                &put_migration_continuation, 
-                                pmc))
-        {
-          put_migration_continuation (pmc, GNUNET_NO, NULL);    
-        }
+    pmc = GNUNET_malloc (sizeof (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,
+                              GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                              &put_migration_continuation, pmc))
+    {
+      put_migration_continuation (pmc, GNUNET_NO, NULL);
     }
+  }
 }
 
 
@@ -1121,38 +1076,34 @@ 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 (GNUNET_BLOCK_TYPE_FS_SBLOCK == pr->public_data.type)
-    {
-      xquery = buf;
-      memcpy (buf, &pr->public_data.namespace, sizeof (GNUNET_HashCode));
-      xquery_size = sizeof (GNUNET_HashCode);
-    }
+  {
+    xquery = buf;
+    memcpy (buf, &pr->public_data.namespace, sizeof (GNUNET_HashCode));
+    xquery_size = sizeof (GNUNET_HashCode);
+  }
   if (0 != (pr->public_data.options & GSF_PRO_FORWARD_ONLY))
-    {
-      GNUNET_assert (0 != pr->sender_pid);
-      GNUNET_PEER_resolve (pr->sender_pid,
-                           &pi);
-      memcpy (&buf[xquery_size], &pi, sizeof (struct GNUNET_PeerIdentity));
-      xquery_size += sizeof (struct GNUNET_PeerIdentity);
-    }
+  {
+    GNUNET_assert (0 != pr->sender_pid);
+    GNUNET_PEER_resolve (pr->sender_pid, &pi);
+    memcpy (&buf[xquery_size], &pi, sizeof (struct GNUNET_PeerIdentity));
+    xquery_size += sizeof (struct GNUNET_PeerIdentity);
+  }
   pr->gh = GNUNET_DHT_get_start (GSF_dht,
-                                 GNUNET_TIME_UNIT_FOREVER_REL,
-                                 pr->public_data.type,
-                                 &pr->public_data.query,
-                                 DEFAULT_GET_REPLICATION,
-                                 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                                 pr->bf,
-                                 pr->mingle,
-                                 xquery,
-                                 xquery_size,
-                                 &handle_dht_reply,
-                                 pr);
+                                 GNUNET_TIME_UNIT_FOREVER_REL,
+                                 pr->public_data.type,
+                                 &pr->public_data.query,
+                                 DEFAULT_GET_REPLICATION,
+                                 GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                                 pr->bf,
+                                 pr->mingle,
+                                 xquery, xquery_size, &handle_dht_reply, pr);
 }
 
 
@@ -1163,17 +1114,17 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr)
  * @param tc task context
  */
 static void
-warn_delay_task (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+warn_delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GSF_PendingRequest *pr = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              _("Datastore lookup already took %llu ms!\n"),
-              (unsigned long long) GNUNET_TIME_absolute_get_duration (pr->qe_start).rel_value);
-  pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                &warn_delay_task,
-                                                pr);
+              _("Datastore lookup already took %llu ms!\n"),
+              (unsigned long long)
+              GNUNET_TIME_absolute_get_duration (pr->qe_start).rel_value);
+  pr->warn_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &warn_delay_task,
+                                    pr);
 }
 
 
@@ -1184,17 +1135,17 @@ warn_delay_task (void *cls,
  * @param tc task context
  */
 static void
-odc_warn_delay_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+odc_warn_delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GSF_PendingRequest *pr = cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-              _("On-demand lookup already took %llu ms!\n"),
-              (unsigned long long) GNUNET_TIME_absolute_get_duration (pr->qe_start).rel_value);
-  pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                &odc_warn_delay_task,
-                                                pr);
+              _("On-demand lookup already took %llu ms!\n"),
+              (unsigned long long)
+              GNUNET_TIME_absolute_get_duration (pr->qe_start).rel_value);
+  pr->warn_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                    &odc_warn_delay_task, pr);
 }
 
 
@@ -1217,14 +1168,13 @@ odc_warn_delay_task (void *cls,
  */
 static void
 process_local_reply (void *cls,
-                     const GNUNET_HashCode *key,
-                     size_t size,
-                     const void *data,
-                     enum GNUNET_BLOCK_Type type,
-                     uint32_t priority,
-                     uint32_t anonymity,
-                     struct GNUNET_TIME_Absolute expiration, 
-                     uint64_t uid)
+                     const GNUNET_HashCode * key,
+                     size_t size,
+                     const void *data,
+                     enum GNUNET_BLOCK_Type type,
+                     uint32_t priority,
+                     uint32_t anonymity,
+                     struct GNUNET_TIME_Absolute expiration, uint64_t uid)
 {
   struct GSF_PendingRequest *pr = cls;
   GSF_LocalLookupContinuation cont;
@@ -1235,236 +1185,228 @@ process_local_reply (void *cls,
   GNUNET_SCHEDULER_cancel (pr->warn_task);
   pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
   if (NULL != pr->qe)
+  {
+    pr->qe = NULL;
+    if (NULL == key)
     {
-      pr->qe = NULL;
-      if (NULL == key)
-        {
-          GNUNET_STATISTICS_update (GSF_stats,
-                                    gettext_noop ("# Datastore lookups concluded (no results)"),
-                                    1,
-                                    GNUNET_NO);
-        }
-      if (GNUNET_NO == pr->have_first_uid)
-        {
-          pr->first_uid = uid;
-          pr->have_first_uid = 1;
-        }
-      else
-        {
-          if ( (uid == pr->first_uid) && (key != NULL) )
-            {
-              GNUNET_STATISTICS_update (GSF_stats,
-                                        gettext_noop ("# Datastore lookups concluded (seen all)"),
-                                        1,
-                                        GNUNET_NO);
-              key = NULL; /* all replies seen! */
-            }
-          pr->have_first_uid++;
-          if ( (pr->have_first_uid > MAX_RESULTS) && (key != NULL) )
-            {
-              GNUNET_STATISTICS_update (GSF_stats,
-                                        gettext_noop ("# Datastore lookups aborted (more than MAX_RESULTS)"),
-                                        1,
-                                        GNUNET_NO);
-              key = NULL; /* all replies seen! */
-            }
-        }
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop
+                                ("# Datastore lookups concluded (no results)"),
+                                1, GNUNET_NO);
     }
-  if (NULL == key)
+    if (GNUNET_NO == pr->have_first_uid)
+    {
+      pr->first_uid = uid;
+      pr->have_first_uid = 1;
+    }
+    else
     {
+      if ((uid == pr->first_uid) && (key != NULL))
+      {
+        GNUNET_STATISTICS_update (GSF_stats,
+                                  gettext_noop
+                                  ("# Datastore lookups concluded (seen all)"),
+                                  1, GNUNET_NO);
+        key = NULL;             /* all replies seen! */
+      }
+      pr->have_first_uid++;
+      if ((pr->have_first_uid > MAX_RESULTS) && (key != NULL))
+      {
+        GNUNET_STATISTICS_update (GSF_stats,
+                                  gettext_noop
+                                  ("# Datastore lookups aborted (more than MAX_RESULTS)"),
+                                  1, GNUNET_NO);
+        key = NULL;             /* all replies seen! */
+      }
+    }
+  }
+  if (NULL == key)
+  {
 #if DEBUG_FS > 1
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No further local responses available.\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No further local responses available.\n");
 #endif
-      if ( (pr->public_data.type == GNUNET_BLOCK_TYPE_FS_DBLOCK) ||
-           (pr->public_data.type == GNUNET_BLOCK_TYPE_FS_IBLOCK) )
-        GNUNET_STATISTICS_update (GSF_stats,
-                                  gettext_noop ("# requested DBLOCK or IBLOCK not found"),
-                                  1,
-                                  GNUNET_NO);
-      goto check_error_and_continue;
-    }
+    if ((pr->public_data.type == GNUNET_BLOCK_TYPE_FS_DBLOCK) ||
+        (pr->public_data.type == GNUNET_BLOCK_TYPE_FS_IBLOCK))
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop
+                                ("# requested DBLOCK or IBLOCK not found"), 1,
+                                GNUNET_NO);
+    goto check_error_and_continue;
+  }
 #if DEBUG_FS
   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);
+              "Received reply for `%s' of type %d with UID %llu from datastore.\n",
+              GNUNET_h2s (key), type, (unsigned long long) uid);
 #endif
   if (type == GNUNET_BLOCK_TYPE_FS_ONDEMAND)
-    {
+  {
 #if DEBUG_FS > 1
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Found ONDEMAND block, performing on-demand encoding\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Found ONDEMAND block, performing on-demand encoding\n");
 #endif
+    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, expiration, uid,
+                                          &process_local_reply, pr))
+    {
       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, 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 */
-        }
+                                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);
+    pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
+                                                  &warn_delay_task, pr);
+    pr->qe = GNUNET_DATASTORE_get_key (GSF_dsh,
+                                       pr->local_result_offset - 1,
+                                       &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 :
+                                       1
+                                       /* max queue size */ ,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       &process_local_reply, pr);
+    if (NULL != pr->qe)
+    {
       GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# on-demand lookups failed"),
-                                1,
-                                GNUNET_NO);
-      GNUNET_SCHEDULER_cancel (pr->warn_task);
-      pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                    &warn_delay_task,
-                                                    pr);        
-      pr->qe = GNUNET_DATASTORE_get_key (GSF_dsh,
-                                         pr->local_result_offset - 1,
-                                         &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
-                                         : 1 /* max queue size */,
-                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                         &process_local_reply,
-                                         pr);
-      if (NULL != pr->qe)
-        {
-          GNUNET_STATISTICS_update (GSF_stats,
-                                    gettext_noop ("# Datastore lookups concluded (error queueing)"),
-                                    1,
-                                    GNUNET_NO);
-          return; /* we're done */      
-        }
-      goto check_error_and_continue;
+                                gettext_noop
+                                ("# Datastore lookups concluded (error queueing)"),
+                                1, GNUNET_NO);
+      return;                   /* we're done */
     }
+    goto check_error_and_continue;
+  }
   old_rf = pr->public_data.results_found;
   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))
+  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,
+                             -1, -1, GNUNET_TIME_UNIT_FOREVER_REL, NULL, NULL);
+    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,
+                                       pr->local_result_offset - 1,
+                                       &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 :
+                                       1
+                                       /* max queue size */ ,
+                                       GNUNET_TIME_UNIT_FOREVER_REL,
+                                       &process_local_reply, pr);
+    if (pr->qe == NULL)
     {
-      GNUNET_break (0);
-      GNUNET_DATASTORE_remove (GSF_dsh,
-                               key,
-                               size, data,
-                               -1, -1, 
-                               GNUNET_TIME_UNIT_FOREVER_REL,
-                               NULL, NULL);
-      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,
-                                         pr->local_result_offset - 1,
-                                         &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
-                                         : 1 /* max queue size */,
-                                         GNUNET_TIME_UNIT_FOREVER_REL,
-                                         &process_local_reply,
-                                         pr);
-      if (pr->qe == NULL)       
-        {
-          GNUNET_STATISTICS_update (GSF_stats,
-                                    gettext_noop ("# Datastore lookups concluded (error queueing)"),
-                                    1,
-                                    GNUNET_NO);
-          goto check_error_and_continue;        
-        }
-      return;
+      GNUNET_STATISTICS_update (GSF_stats,
+                                gettext_noop
+                                ("# Datastore lookups concluded (error queueing)"),
+                                1, GNUNET_NO);
+      goto check_error_and_continue;
     }
+    return;
+  }
   prq.type = type;
-  prq.priority = priority;  
+  prq.priority = priority;
   prq.request_found = GNUNET_NO;
   prq.anonymity_level = anonymity;
-  if ( (old_rf == 0) &&
-       (pr->public_data.results_found == 0) )
+  if ((old_rf == 0) && (pr->public_data.results_found == 0))
     GSF_update_datastore_delay_ (pr->public_data.start_time);
   process_reply (&prq, key, pr);
   pr->local_result = prq.eval;
   if (prq.eval == GNUNET_BLOCK_EVALUATION_OK_LAST)
-    {
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# Datastore lookups concluded (found ultimate result)"),
-                                1,
-                                GNUNET_NO);
-      goto check_error_and_continue;
-    }
-  if ( (0 == (GSF_PRO_PRIORITY_UNLIMITED & pr->public_data.options)) &&
-       ( (GNUNET_YES == GSF_test_get_load_too_high_ (0)) ||
-         (pr->public_data.results_found > 5 + 2 * pr->public_data.priority) ) )
-    {
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# Datastore lookups concluded (found ultimate result)"),
+                              1, GNUNET_NO);
+    goto check_error_and_continue;
+  }
+  if ((0 == (GSF_PRO_PRIORITY_UNLIMITED & pr->public_data.options)) &&
+      ((GNUNET_YES == GSF_test_get_load_too_high_ (0)) ||
+       (pr->public_data.results_found > 5 + 2 * pr->public_data.priority)))
+  {
 #if DEBUG_FS > 2
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Load too high, done with request\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Load too high, done with request\n");
 #endif
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# Datastore lookups concluded (load too high)"),
-                                1,
-                                GNUNET_NO);
-      goto check_error_and_continue;
-    }
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# Datastore lookups concluded (load too high)"),
+                              1, GNUNET_NO);
+    goto check_error_and_continue;
+  }
   pr->qe_start = GNUNET_TIME_absolute_get ();
   pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                &warn_delay_task,
-                                                pr);
+                                                &warn_delay_task, pr);
   pr->qe = GNUNET_DATASTORE_get_key (GSF_dsh,
-                                     pr->local_result_offset++,
-                                     &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
-                                     : 1 /* max queue size */,
-                                     GNUNET_TIME_UNIT_FOREVER_REL,
-                                     &process_local_reply,
-                                     pr);
+                                     pr->local_result_offset++,
+                                     &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 : 1
+                                     /* max queue size */ ,
+                                     GNUNET_TIME_UNIT_FOREVER_REL,
+                                     &process_local_reply, pr);
   /* check if we successfully queued another datastore request;
-     if so, return, otherwise call our continuation (if we have
-     any) */
- check_error_and_continue:
+   * if so, return, otherwise call our continuation (if we have
+   * any) */
+check_error_and_continue:
   if (NULL != pr->qe)
     return;
   if (GNUNET_SCHEDULER_NO_TASK != pr->warn_task)
-    {
-      GNUNET_SCHEDULER_cancel (pr->warn_task);
-      pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (pr->warn_task);
+    pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   if (NULL == (cont = pr->llc_cont))
-    return; /* no continuation */      
+    return;                     /* no continuation */
   pr->llc_cont = NULL;
-  cont (pr->llc_cont_cls,
-        pr,
-        pr->local_result);
+  cont (pr->llc_cont_cls, pr, pr->local_result);
 }
 
 
@@ -1477,8 +1419,7 @@ process_local_reply (void *cls,
  */
 void
 GSF_local_lookup_ (struct GSF_PendingRequest *pr,
-                   GSF_LocalLookupContinuation cont,
-                   void *cont_cls)
+                   GSF_LocalLookupContinuation cont, void *cont_cls)
 {
   GNUNET_assert (NULL == pr->gh);
   GNUNET_assert (NULL == pr->llc_cont);
@@ -1486,41 +1427,41 @@ GSF_local_lookup_ (struct GSF_PendingRequest *pr,
   pr->llc_cont_cls = cont_cls;
   pr->qe_start = GNUNET_TIME_absolute_get ();
   pr->warn_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                                &warn_delay_task,
-                                                pr);
+                                                &warn_delay_task, pr);
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# Datastore lookups initiated"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# Datastore lookups initiated"),
+                            1, GNUNET_NO);
   pr->qe = GNUNET_DATASTORE_get_key (GSF_dsh,
-                                     pr->local_result_offset++,
-                                     &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
-                                     : 1 /* max queue size */,
-                                     GNUNET_TIME_UNIT_FOREVER_REL,
-                                     &process_local_reply,
-                                     pr);
+                                     pr->local_result_offset++,
+                                     &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 : 1
+                                     /* max queue size */ ,
+                                     GNUNET_TIME_UNIT_FOREVER_REL,
+                                     &process_local_reply, pr);
   if (NULL != pr->qe)
-    {
-      GNUNET_STATISTICS_update (GSF_stats,
-                                gettext_noop ("# Datastore lookups concluded (error queueing)"),
-                                1,
-                                GNUNET_NO);
-      
-      return;
-    }
+  {
+    GNUNET_STATISTICS_update (GSF_stats,
+                              gettext_noop
+                              ("# Datastore lookups concluded (error queueing)"),
+                              1, GNUNET_NO);
+
+    return;
+  }
   GNUNET_SCHEDULER_cancel (pr->warn_task);
   pr->warn_task = GNUNET_SCHEDULER_NO_TASK;
   pr->llc_cont = NULL;
   if (NULL != cont)
-    cont (cont_cls, pr, pr->local_result);      
+    cont (cont_cls, pr, pr->local_result);
 }
 
 
@@ -1540,7 +1481,7 @@ GSF_local_lookup_ (struct GSF_PendingRequest *pr,
  */
 int
 GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
-                         const struct GNUNET_MessageHeader *message)
+                         const struct GNUNET_MessageHeader *message)
 {
   const struct PutMessage *put;
   uint16_t msize;
@@ -1549,38 +1490,33 @@ GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
   struct GNUNET_TIME_Absolute expiration;
   GNUNET_HashCode query;
   struct ProcessReplyClosure prq;
-  struct GNUNET_TIME_Relative block_time;  
+  struct GNUNET_TIME_Relative block_time;
   double putl;
   struct PutMigrationContext *pmc;
 
   msize = ntohs (message->size);
   if (msize < sizeof (struct PutMessage))
-    {
-      GNUNET_break_op(0);
-      return GNUNET_SYSERR;
-    }
-  put = (const struct PutMessage*) message;
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
+  put = (const struct PutMessage *) message;
   dsize = msize - sizeof (struct PutMessage);
   type = ntohl (put->type);
   expiration = GNUNET_TIME_absolute_ntoh (put->expiration);
   if (type == GNUNET_BLOCK_TYPE_FS_ONDEMAND)
     return GNUNET_SYSERR;
   if (GNUNET_OK !=
-      GNUNET_BLOCK_get_key (GSF_block_ctx,
-                            type,
-                            &put[1],
-                            dsize,
-                            &query))
-    {
-      GNUNET_break_op (0);
-      return GNUNET_SYSERR;
-    }
+      GNUNET_BLOCK_get_key (GSF_block_ctx, type, &put[1], dsize, &query))
+  {
+    GNUNET_break_op (0);
+    return GNUNET_SYSERR;
+  }
   GNUNET_STATISTICS_update (GSF_stats,
-                            gettext_noop ("# GAP PUT messages received"),
-                            1,
-                            GNUNET_NO);
+                            gettext_noop ("# GAP PUT messages received"),
+                            1, GNUNET_NO);
   /* now, lookup 'query' */
-  prq.data = (const void*) &put[1];
+  prq.data = (const void *) &put[1];
   if (NULL != cp)
     prq.sender = cp;
   else
@@ -1592,66 +1528,66 @@ GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
   prq.anonymity_level = UINT32_MAX;
   prq.request_found = GNUNET_NO;
   GNUNET_CONTAINER_multihashmap_get_multiple (pr_map,
-                                              &query,
-                                              &process_reply,
-                                              &prq);
+                                              &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)->trust += prq.priority;
-    }
-  if ( (GNUNET_YES == active_to_migration) &&
-       (GNUNET_NO == test_put_load_too_high (prq.priority)) )
-    {      
+  {
+    GSF_connected_peer_change_preference_ (cp,
+                                           CONTENT_BANDWIDTH_VALUE +
+                                           1000 * prq.priority);
+    GSF_get_peer_performance_data_ (cp)->trust += prq.priority;
+  }
+  if ((GNUNET_YES == active_to_migration) &&
+      (GNUNET_NO == test_put_load_too_high (prq.priority)))
+  {
 #if DEBUG_FS
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Replicating result for query `%s' with priority %u\n",
-                  GNUNET_h2s (&query),
-                  prq.priority);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Replicating result for query `%s' with priority %u\n",
+                GNUNET_h2s (&query), prq.priority);
 #endif
-      pmc = GNUNET_malloc (sizeof (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,
-                                GNUNET_CONSTANTS_SERVICE_TIMEOUT,
-                                &put_migration_continuation, 
-                                pmc))
-        {
-          put_migration_continuation (pmc, GNUNET_NO, NULL);      
-        }
+    pmc = GNUNET_malloc (sizeof (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,
+                              GNUNET_CONSTANTS_SERVICE_TIMEOUT,
+                              &put_migration_continuation, pmc))
+    {
+      put_migration_continuation (pmc, GNUNET_NO, NULL);
     }
+  }
   else
-    {
+  {
 #if DEBUG_FS
-      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));
+    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));
 #endif
-    }
+  }
   putl = GNUNET_LOAD_get_load (datastore_put_load);
-  if ( (NULL != (cp = prq.sender)) &&
-       (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)));
-      GSF_block_peer_migration_ (cp, block_time);
-    }  
+  if ((NULL != (cp = prq.sender)) &&
+      (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)));
+    GSF_block_peer_migration_ (cp, block_time);
+  }
   return GNUNET_OK;
 }
 
@@ -1664,20 +1600,22 @@ GSF_pending_request_init_ ()
 {
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (GSF_cfg,
-                                             "fs",
-                                             "MAX_PENDING_REQUESTS",
-                                             &max_pending_requests))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-                  _("Configuration fails to specify `%s', assuming default value."),
-                  "MAX_PENDING_REQUESTS");
-    }
+                                             "fs",
+                                             "MAX_PENDING_REQUESTS",
+                                             &max_pending_requests))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+                _
+                ("Configuration fails to specify `%s', assuming default value."),
+                "MAX_PENDING_REQUESTS");
+  }
   active_to_migration = GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg,
-                                                              "FS",
-                                                              "CONTENT_CACHING");
+                                                              "FS",
+                                                              "CONTENT_CACHING");
   datastore_put_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
   pr_map = GNUNET_CONTAINER_multihashmap_create (32 * 1024);
-  requests_by_expiration_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN); 
+  requests_by_expiration_heap =
+      GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
 }
 
 
@@ -1687,9 +1625,7 @@ GSF_pending_request_init_ ()
 void
 GSF_pending_request_done_ ()
 {
-  GNUNET_CONTAINER_multihashmap_iterate (pr_map,
-                                         &clean_request,
-                                         NULL);
+  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);
diff --git a/src/fs/gnunet-service-fs_pr.h b/src/fs/gnunet-service-fs_pr.h
index 1e71aa7ee..2f89f6e73 100644
--- a/src/fs/gnunet-service-fs_pr.h
+++ b/src/fs/gnunet-service-fs_pr.h
@@ -33,38 +33,38 @@
  * Options for pending requests (bits to be ORed).
  */
 enum GSF_PendingRequestOptions
-  {
+{
     /**
      * Request must only be processed locally.
      */
-    GSF_PRO_LOCAL_ONLY = 1,
-    
+  GSF_PRO_LOCAL_ONLY = 1,
+
     /**
      * Request must only be forwarded (no routing)
      */
-    GSF_PRO_FORWARD_ONLY = 2,
+  GSF_PRO_FORWARD_ONLY = 2,
 
     /**
      * Request persists indefinitely (no expiration).
      */
-    GSF_PRO_REQUEST_EXPIRES = 4,
+  GSF_PRO_REQUEST_EXPIRES = 4,
 
     /**
      * Request is allowed to refresh bloomfilter and change mingle value.
      */
-    GSF_PRO_BLOOMFILTER_FULL_REFRESH = 8,
+  GSF_PRO_BLOOMFILTER_FULL_REFRESH = 8,
 
     /**
      * Request priority is allowed to be exceeded.
      */
-    GSF_PRO_PRIORITY_UNLIMITED = 16,
+  GSF_PRO_PRIORITY_UNLIMITED = 16,
 
     /**
      * Option mask for typical local requests.
      */
-    GSF_PRO_LOCAL_REQUEST = (GSF_PRO_BLOOMFILTER_FULL_REFRESH | GSF_PRO_PRIORITY_UNLIMITED)
-
-  };
+  GSF_PRO_LOCAL_REQUEST =
+      (GSF_PRO_BLOOMFILTER_FULL_REFRESH | GSF_PRO_PRIORITY_UNLIMITED)
+};
 
 
 /**
@@ -84,7 +84,7 @@ struct GSF_PendingRequestData
    * Namespace to query, only set if the type is SBLOCK.
    */
   GNUNET_HashCode namespace;
-                        
+
   /**
    * Identity of a peer hosting the content, only set if
    * 'has_target' is GNUNET_YES.
@@ -130,7 +130,7 @@ struct GSF_PendingRequestData
    * Options for the request.
    */
   enum GSF_PendingRequestOptions options;
-  
+
   /**
    * Type of the requested block.
    */
@@ -166,14 +166,17 @@ struct GSF_PendingRequestData
  * @param data response data, NULL on request expiration
  * @param data_len number of bytes in data
  */
-typedef void (*GSF_PendingRequestReplyHandler)(void *cls,
-                                               enum GNUNET_BLOCK_EvaluationResult eval,
-                                               struct GSF_PendingRequest *pr,
-                                               uint32_t reply_anonymity_level,
-                                               struct GNUNET_TIME_Absolute expiration,
-                                               enum GNUNET_BLOCK_Type type,
-                                               const void *data,
-                                               size_t data_len);
+typedef void (*GSF_PendingRequestReplyHandler) (void *cls,
+                                                enum
+                                                GNUNET_BLOCK_EvaluationResult
+                                                eval,
+                                                struct GSF_PendingRequest * pr,
+                                                uint32_t reply_anonymity_level,
+                                                struct GNUNET_TIME_Absolute
+                                                expiration,
+                                                enum GNUNET_BLOCK_Type type,
+                                                const void *data,
+                                                size_t data_len);
 
 
 /**
@@ -198,23 +201,33 @@ typedef void (*GSF_PendingRequestReplyHandler)(void *cls,
  * @param rh_cls closure for rh
  * @return handle for the new pending request
  */
-struct GSF_PendingRequest *
-GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
-                             enum GNUNET_BLOCK_Type type,
-                             const GNUNET_HashCode *query,
-                             const GNUNET_HashCode *namespace,
-                             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,
-                             const GNUNET_HashCode *replies_seen,
-                             unsigned int replies_seen_count,
-                             GSF_PendingRequestReplyHandler rh,
-                             void *rh_cls);
+struct GSF_PendingRequest *GSF_pending_request_create_ (enum
+                                                        GSF_PendingRequestOptions
+                                                        options,
+                                                        enum GNUNET_BLOCK_Type
+                                                        type,
+                                                        const GNUNET_HashCode *
+                                                        query,
+                                                        const GNUNET_HashCode *
+                                                        namespace,
+                                                        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,
+                                                        const GNUNET_HashCode *
+                                                        replies_seen,
+                                                        unsigned int
+                                                        replies_seen_count,
+                                                        GSF_PendingRequestReplyHandler
+                                                        rh, void *rh_cls);
 
 
 /**
@@ -227,8 +240,8 @@ GSF_pending_request_create_ (enum GSF_PendingRequestOptions options,
  */
 void
 GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
-                             const GNUNET_HashCode *replies_seen,
-                             unsigned int replies_seen_count);
+                             const GNUNET_HashCode * replies_seen,
+                             unsigned int replies_seen_count);
 
 
 /**
@@ -237,8 +250,9 @@ GSF_pending_request_update_ (struct GSF_PendingRequest *pr,
  * @param pr pending request
  * @return associated public data
  */
-struct GSF_PendingRequestData *
-GSF_pending_request_get_data_ (struct GSF_PendingRequest *pr);
+struct GSF_PendingRequestData *GSF_pending_request_get_data_ (struct
+                                                              GSF_PendingRequest
+                                                              *pr);
 
 
 /**
@@ -252,7 +266,7 @@ GSF_pending_request_get_data_ (struct GSF_PendingRequest *pr);
  */
 int
 GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
-                                    struct GSF_PendingRequest *prb);
+                                    struct GSF_PendingRequest *prb);
 
 
 /**
@@ -265,9 +279,14 @@ GSF_pending_request_is_compatible_ (struct GSF_PendingRequest *pra,
  * @return number of bytes needed (if buf_size too small) or used
  */
 size_t
+ 
+ 
+ 
+ 
+ 
+ 
 GSF_pending_request_get_message_ (struct GSF_PendingRequest *pr,
-                                  size_t buf_size,
-                                  void *buf);
+                                  size_t buf_size, void *buf);
 
 
 /**
@@ -277,8 +296,7 @@ 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);
 
 
 /**
@@ -290,9 +308,9 @@ GSF_pending_request_cancel_ (struct GSF_PendingRequest *pr,
  * @param pr handle to the pending request
  * @return GNUNET_YES to continue to iterate
  */
-typedef int (*GSF_PendingRequestIterator)(void *cls,
-                                          const GNUNET_HashCode *key,
-                                          struct GSF_PendingRequest *pr);
+typedef int (*GSF_PendingRequestIterator) (void *cls,
+                                           const GNUNET_HashCode * key,
+                                           struct GSF_PendingRequest * pr);
 
 
 /**
@@ -301,9 +319,7 @@ typedef int (*GSF_PendingRequestIterator)(void *cls,
  * @param it function to call for each request
  * @param cls closure for it
  */
-void
-GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it,
-                               void *cls);
+void GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it, void *cls);
 
 
 /**
@@ -321,7 +337,7 @@ GSF_iterate_pending_requests_ (GSF_PendingRequestIterator it,
  */
 int
 GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
-                         const struct GNUNET_MessageHeader *message);
+                         const struct GNUNET_MessageHeader *message);
 
 
 /**
@@ -329,8 +345,7 @@ GSF_handle_p2p_content_ (struct GSF_ConnectedPeer *cp,
  *
  * @param pr the pending request to process
  */
-void
-GSF_dht_lookup_ (struct GSF_PendingRequest *pr);
+void GSF_dht_lookup_ (struct GSF_PendingRequest *pr);
 
 
 /**
@@ -341,9 +356,10 @@ GSF_dht_lookup_ (struct GSF_PendingRequest *pr);
  * @param pr the pending request we were processing
  * @param result final datastore lookup result
  */
-typedef void (*GSF_LocalLookupContinuation)(void *cls,
-                                            struct GSF_PendingRequest *pr,
-                                            enum GNUNET_BLOCK_EvaluationResult result);
+typedef void (*GSF_LocalLookupContinuation) (void *cls,
+                                             struct GSF_PendingRequest * pr,
+                                             enum GNUNET_BLOCK_EvaluationResult
+                                             result);
 
 
 /**
@@ -355,22 +371,19 @@ typedef void (*GSF_LocalLookupContinuation)(void *cls,
  */
 void
 GSF_local_lookup_ (struct GSF_PendingRequest *pr,
-                   GSF_LocalLookupContinuation cont,
-                   void *cont_cls);
+                   GSF_LocalLookupContinuation cont, void *cont_cls);
 
 
 /**
  * Setup the subsystem.
  */
-void
-GSF_pending_request_init_ (void);
+void GSF_pending_request_init_ (void);
 
 
 /**
  * Shutdown the subsystem.
  */
-void
-GSF_pending_request_done_ (void);
+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 099010758..108fce5fc 100644
--- a/src/fs/gnunet-service-fs_push.c
+++ b/src/fs/gnunet-service-fs_push.c
@@ -112,7 +112,7 @@ struct MigrationReadyPeer
    * Handle to peer.
    */
   struct GSF_ConnectedPeer *peer;
-  
+
   /**
    * Handle for current transmission request,
    * or NULL for none.
@@ -181,11 +181,8 @@ static int enabled;
 static void
 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);
 }
@@ -193,9 +190,8 @@ delete_migration_block (struct MigrationReadyBlock *mb)
 
 /**
  * Find content for migration to this peer.
- */ 
-static void
-find_content (struct MigrationReadyPeer *mrp);
+ */
+static void find_content (struct MigrationReadyPeer *mrp);
 
 
 /**
@@ -208,9 +204,7 @@ find_content (struct MigrationReadyPeer *mrp);
  * @return number of bytes copied to 'buf', can be 0 (without indicating an error)
  */
 static size_t
-transmit_message (void *cls,
-                  size_t buf_size,
-                  void *buf)
+transmit_message (void *cls, size_t buf_size, void *buf)
 {
   struct MigrationReadyPeer *peer = cls;
   struct PutMessage *msg;
@@ -220,22 +214,21 @@ transmit_message (void *cls,
   msg = peer->msg;
   peer->msg = NULL;
   if (buf == NULL)
-    {
+  {
 #if DEBUG_FS_MIGRATION
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Failed to migrate content to another peer (disconnect)\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to migrate content to another peer (disconnect)\n");
 #endif
-      GNUNET_free (msg);
-      return 0;
-    }
+    GNUNET_free (msg);
+    return 0;
+  }
   msize = ntohs (msg->header.size);
   GNUNET_assert (msize <= buf_size);
   memcpy (buf, msg, msize);
   GNUNET_free (msg);
 #if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Pushing %u bytes to another peer\n",
-              msize);
+              "Pushing %u bytes to another peer\n", msize);
 #endif
   find_content (peer);
   return msize;
@@ -251,11 +244,11 @@ transmit_message (void *cls,
  */
 static int
 transmit_content (struct MigrationReadyPeer *peer,
-                  struct MigrationReadyBlock *block)
+                  struct MigrationReadyBlock *block)
 {
   size_t msize;
   struct PutMessage *msg;
-  unsigned  int i;
+  unsigned int i;
   struct GSF_PeerPerformanceData *ppd;
   int ret;
 
@@ -267,40 +260,33 @@ transmit_content (struct MigrationReadyPeer *peer,
   msg->header.size = htons (msize);
   msg->type = htonl (block->type);
   msg->expiration = GNUNET_TIME_absolute_hton (block->expiration);
-  memcpy (&msg[1],
-          &block[1],
-          block->size);
+  memcpy (&msg[1], &block[1], block->size);
   peer->msg = msg;
-  for (i=0;i<MIGRATION_LIST_SIZE;i++)
+  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;
-    }
+  {
+    ret = GNUNET_NO;
+  }
 #if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Asking for transmission of %u bytes for migration\n",
-              msize);
+              "Asking for transmission of %u bytes for migration\n", msize);
 #endif
-  peer->th = GSF_peer_transmit_ (peer->peer,
-                                 GNUNET_NO,
-                                 0 /* priority */,
-                                 GNUNET_TIME_UNIT_FOREVER_REL,
-                                 msize,
-                                 &transmit_message,
-                                 peer);
+  peer->th = GSF_peer_transmit_ (peer->peer, GNUNET_NO, 0 /* priority */ ,
+                                 GNUNET_TIME_UNIT_FOREVER_REL,
+                                 msize, &transmit_message, peer);
   return ret;
 }
 
@@ -317,7 +303,7 @@ count_targets (struct MigrationReadyBlock *block)
 {
   unsigned int i;
 
-  for (i=0;i<MIGRATION_LIST_SIZE;i++)
+  for (i = 0; i < MIGRATION_LIST_SIZE; i++)
     if (block->target_list[i] == 0)
       return i;
   return i;
@@ -334,7 +320,7 @@ count_targets (struct MigrationReadyBlock *block)
  */
 static long
 score_content (struct MigrationReadyPeer *peer,
-               struct MigrationReadyBlock *block)
+               struct MigrationReadyBlock *block)
 {
   unsigned int i;
   struct GSF_PeerPerformanceData *ppd;
@@ -342,14 +328,12 @@ score_content (struct MigrationReadyPeer *peer,
   uint32_t dist;
 
   ppd = GSF_get_peer_performance_data_ (peer->peer);
-  for (i=0;i<MIGRATION_LIST_SIZE;i++)
+  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);
-  dist = GNUNET_CRYPTO_hash_distance_u32 (&block->query,
-                                          &id.hashPubKey);
+  GNUNET_PEER_resolve (ppd->pid, &id);
+  dist = GNUNET_CRYPTO_hash_distance_u32 (&block->query, &id.hashPubKey);
   /* closer distance, higher score: */
   return UINT32_MAX - dist;
 }
@@ -359,15 +343,14 @@ score_content (struct MigrationReadyPeer *peer,
  * If the migration task is not currently running, consider
  * (re)scheduling it with the appropriate delay.
  */
-static void
-consider_gathering (void);
+static void consider_gathering (void);
 
 
 /**
  * Find content for migration to this peer.
  *
  * @param mrp peer to find content for
- */ 
+ */
 static void
 find_content (struct MigrationReadyPeer *mrp)
 {
@@ -381,51 +364,51 @@ find_content (struct MigrationReadyPeer *mrp)
   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;
     }
-  if (NULL == best) 
+    pos = pos->next;
+  }
+  if (NULL == best)
+  {
+    if (mig_size < MAX_MIGRATION_QUEUE)
     {
-      if (mig_size < MAX_MIGRATION_QUEUE)
-        {
 #if DEBUG_FS_MIGRATION
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "No content found for pushing, waiting for queue to fill\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "No content found for pushing, waiting for queue to fill\n");
 #endif
-          return; /* will fill up eventually... */
-        }
+      return;                   /* will fill up eventually... */
+    }
 #if DEBUG_FS_MIGRATION
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No suitable content found, purging content from full queue\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No suitable content found, purging content from full queue\n");
 #endif
-      /* 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;
+    /* 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;
+  }
 #if DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Preparing to push best content to peer\n");
+              "Preparing to push best content to peer\n");
 #endif
   transmit_content (mrp, best);
 }
@@ -440,7 +423,7 @@ find_content (struct MigrationReadyPeer *mrp)
  */
 static void
 gather_migration_blocks (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc);
+                         const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -458,22 +441,17 @@ consider_gathering ()
     return;
   if (mig_task != GNUNET_SCHEDULER_NO_TASK)
     return;
-  if (mig_size >= MAX_MIGRATION_QUEUE)  
+  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 DEBUG_FS_MIGRATION
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Scheduling gathering task (queue size: %u)\n",
-              mig_size);
+              "Scheduling gathering task (queue size: %u)\n", mig_size);
 #endif
   mig_task = GNUNET_SCHEDULER_add_delayed (delay,
-                                           &gather_migration_blocks,
-                                           NULL);
+                                           &gather_migration_blocks, NULL);
 }
 
 
@@ -493,53 +471,47 @@ consider_gathering ()
  */
 static void
 process_migration_content (void *cls,
-                           const GNUNET_HashCode *key,
-                           size_t size,
-                           const void *data,
-                           enum GNUNET_BLOCK_Type type,
-                           uint32_t priority,
-                           uint32_t anonymity,
-                           struct GNUNET_TIME_Absolute
-                           expiration, uint64_t uid)
+                           const GNUNET_HashCode * key,
+                           size_t size,
+                           const void *data,
+                           enum GNUNET_BLOCK_Type type,
+                           uint32_t priority,
+                           uint32_t anonymity,
+                           struct GNUNET_TIME_Absolute expiration, uint64_t uid)
 {
   struct MigrationReadyBlock *mb;
   struct MigrationReadyPeer *pos;
-  
+
   mig_qe = NULL;
   if (key == NULL)
-    {
+  {
 #if DEBUG_FS_MIGRATION
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "No content found for migration...\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No content found for migration...\n");
 #endif
-      consider_gathering ();
-      return;
-    }
-  if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value < 
+    consider_gathering ();
+    return;
+  }
+  if (GNUNET_TIME_absolute_get_remaining (expiration).rel_value <
       MIN_MIGRATION_CONTENT_LIFETIME.rel_value)
-    {
-      /* 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,
-                                            expiration, uid, 
-                                            &process_migration_content,
-                                            NULL))      
-        consider_gathering ();  
-      return;
-    }
+  {
+    if (GNUNET_OK !=
+        GNUNET_FS_handle_on_demand_block (key, size, data,
+                                          type, priority, anonymity,
+                                          expiration, uid,
+                                          &process_migration_content, NULL))
+      consider_gathering ();
+    return;
+  }
 #if DEBUG_FS_MIGRATION
   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);
+              "Retrieved block `%s' of type %u for migration (queue size: %u/%u)\n",
+              GNUNET_h2s (key), type, mig_size + 1, MAX_MIGRATION_QUEUE);
 #endif
   mb = GNUNET_malloc (sizeof (struct MigrationReadyBlock) + size);
   mb->query = *key;
@@ -547,25 +519,22 @@ process_migration_content (void *cls,
   mb->size = size;
   mb->type = type;
   memcpy (&mb[1], data, size);
-  GNUNET_CONTAINER_DLL_insert_after (mig_head,
-                                     mig_tail,
-                                     mig_tail,
-                                     mb);
+  GNUNET_CONTAINER_DLL_insert_after (mig_head, mig_tail, mig_tail, mb);
   mig_size++;
   pos = peer_head;
   while (pos != NULL)
+  {
+    if (NULL == pos->th)
     {
-      if (NULL == pos->th)
-        {
 #if DEBUG_FS_MIGRATION
-          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                      "Preparing to push best content to peer\n");
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "Preparing to push best content to peer\n");
 #endif
-          if (GNUNET_YES == transmit_content (pos, mb))
-            break; /* 'mb' was freed! */
-        }
-      pos = pos->next;
+      if (GNUNET_YES == transmit_content (pos, mb))
+        break;                  /* 'mb' was freed! */
     }
+    pos = pos->next;
+  }
   consider_gathering ();
 }
 
@@ -579,25 +548,26 @@ process_migration_content (void *cls,
  */
 static void
 gather_migration_blocks (void *cls,
-                         const struct GNUNET_SCHEDULER_TaskContext *tc)
+                         const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   mig_task = GNUNET_SCHEDULER_NO_TASK;
-  if (mig_size >= MAX_MIGRATION_QUEUE)  
+  if (mig_size >= MAX_MIGRATION_QUEUE)
     return;
   if (GSF_dsh != NULL)
-    {
+  {
 #if DEBUG_FS_MIGRATION
-      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);
 #endif
-      mig_qe = GNUNET_DATASTORE_get_for_replication (GSF_dsh, 
-                                                     0, UINT_MAX,
-                                                     GNUNET_TIME_UNIT_FOREVER_REL,
-                                                     &process_migration_content, NULL);
-      if (NULL == mig_qe)
-        consider_gathering ();
-    }
+    mig_qe = GNUNET_DATASTORE_get_for_replication (GSF_dsh,
+                                                   0, UINT_MAX,
+                                                   GNUNET_TIME_UNIT_FOREVER_REL,
+                                                   &process_migration_content,
+                                                   NULL);
+    if (NULL == mig_qe)
+      consider_gathering ();
+  }
 }
 
 
@@ -617,9 +587,7 @@ GSF_push_start_ (struct GSF_ConnectedPeer *peer)
   mrp = GNUNET_malloc (sizeof (struct MigrationReadyPeer));
   mrp->peer = peer;
   find_content (mrp);
-  GNUNET_CONTAINER_DLL_insert  (peer_head,
-                                peer_tail,
-                                mrp);
+  GNUNET_CONTAINER_DLL_insert (peer_head, peer_tail, mrp);
 }
 
 
@@ -636,27 +604,25 @@ GSF_push_stop_ (struct GSF_ConnectedPeer *peer)
 
   pos = peer_head;
   while (pos != NULL)
+  {
+    if (pos->peer == peer)
     {
-      if (pos->peer == peer)
-        {
-          GNUNET_CONTAINER_DLL_remove (peer_head,
-                                       peer_tail,
-                                       pos);
-          if (NULL != pos->th)
-            {
-              GSF_peer_transmit_cancel_ (pos->th);
-              pos->th = NULL;
-            }
-          if (NULL != pos->msg)
-            {
-              GNUNET_free (pos->msg);
-              pos->msg = NULL;
-            }
-          GNUNET_free (pos);
-          return;
-        }
-      pos = pos->next;
+      GNUNET_CONTAINER_DLL_remove (peer_head, peer_tail, pos);
+      if (NULL != pos->th)
+      {
+        GSF_peer_transmit_cancel_ (pos->th);
+        pos->th = NULL;
+      }
+      if (NULL != pos->msg)
+      {
+        GNUNET_free (pos->msg);
+        pos->msg = NULL;
+      }
+      GNUNET_free (pos);
+      return;
     }
+    pos = pos->next;
+  }
 }
 
 
@@ -667,23 +633,22 @@ void
 GSF_push_init_ ()
 {
   enabled = GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg,
-                                                  "FS",
-                                                  "CONTENT_PUSHING");
+                                                  "FS", "CONTENT_PUSHING");
   if (GNUNET_YES != enabled)
     return;
- 
-  if (GNUNET_OK != 
+
+  if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_time (GSF_cfg,
-                                           "fs",
-                                           "MIN_MIGRATION_DELAY",
-                                           &min_migration_delay))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Invalid value specified for option `%s' in section `%s', content pushing disabled\n"),
-                  "MIN_MIGRATION_DELAY",
-                  "fs");
-      return;
-    }
+                                           "fs",
+                                           "MIN_MIGRATION_DELAY",
+                                           &min_migration_delay))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                _
+                ("Invalid value specified for option `%s' in section `%s', content pushing disabled\n"),
+                "MIN_MIGRATION_DELAY", "fs");
+    return;
+  }
   consider_gathering ();
 }
 
@@ -695,15 +660,15 @@ void
 GSF_push_done_ ()
 {
   if (GNUNET_SCHEDULER_NO_TASK != mig_task)
-    {
-      GNUNET_SCHEDULER_cancel (mig_task);
-      mig_task = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (mig_task);
+    mig_task = GNUNET_SCHEDULER_NO_TASK;
+  }
   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);
diff --git a/src/fs/gnunet-service-fs_push.h b/src/fs/gnunet-service-fs_push.h
index 7967b04cd..40e1252be 100644
--- a/src/fs/gnunet-service-fs_push.h
+++ b/src/fs/gnunet-service-fs_push.h
@@ -32,15 +32,13 @@
 /**
  * Setup the module.
  */
-void
-GSF_push_init_ (void);
+void GSF_push_init_ (void);
 
 
 /**
  * Shutdown the module.
  */
-void
-GSF_push_done_ (void);
+void GSF_push_done_ (void);
 
 
 /**
@@ -49,8 +47,7 @@ GSF_push_done_ (void);
  *
  * @param peer handle for the peer that connected
  */
-void
-GSF_push_start_ (struct GSF_ConnectedPeer *peer);
+void GSF_push_start_ (struct GSF_ConnectedPeer *peer);
 
 
 /**
@@ -59,8 +56,7 @@ GSF_push_start_ (struct GSF_ConnectedPeer *peer);
  *
  * @param peer handle for the peer that disconnected
  */
-void
-GSF_push_stop_ (struct GSF_ConnectedPeer *peer);
+void 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 b15207ce8..e67bf0c04 100644
--- a/src/fs/gnunet-service-fs_put.c
+++ b/src/fs/gnunet-service-fs_put.c
@@ -54,7 +54,7 @@ struct PutOperator
    * ID of task that collects blocks for DHT PUTs.
    */
   GNUNET_SCHEDULER_TaskIdentifier dht_task;
-  
+
   /**
    * How many entires with zero anonymity of our type do we currently
    * estimate to have in the database?
@@ -72,13 +72,12 @@ struct PutOperator
  * ANY-terminated list of our operators (one per type
  * of block that we're putting into the DHT).
  */
-static struct PutOperator operators[] = 
-  {
-    { NULL, GNUNET_BLOCK_TYPE_FS_KBLOCK, 0, 0, 0 },
-    { NULL, GNUNET_BLOCK_TYPE_FS_SBLOCK, 0, 0, 0 },
-    { NULL, GNUNET_BLOCK_TYPE_FS_NBLOCK, 0, 0, 0 },
-    { NULL, GNUNET_BLOCK_TYPE_ANY, 0, 0, 0 }
-  };
+static struct PutOperator operators[] = {
+  {NULL, GNUNET_BLOCK_TYPE_FS_KBLOCK, 0, 0, 0},
+  {NULL, GNUNET_BLOCK_TYPE_FS_SBLOCK, 0, 0, 0},
+  {NULL, GNUNET_BLOCK_TYPE_FS_NBLOCK, 0, 0, 0},
+  {NULL, GNUNET_BLOCK_TYPE_ANY, 0, 0, 0}
+};
 
 
 /**
@@ -89,7 +88,7 @@ static struct PutOperator operators[] =
  */
 static void
 gather_dht_put_blocks (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc);
+                       const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
@@ -99,8 +98,7 @@ gather_dht_put_blocks (void *cls,
  * @param tc scheduler context (unused)
  */
 static void
-delay_dht_put_blocks (void *cls,
-                      const struct GNUNET_SCHEDULER_TaskContext *tc)
+delay_dht_put_blocks (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PutOperator *po = cls;
   struct GNUNET_TIME_Relative delay;
@@ -109,21 +107,19 @@ delay_dht_put_blocks (void *cls,
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   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);
+                                               &gather_dht_put_blocks, po);
 }
 
 
@@ -143,45 +139,40 @@ delay_dht_put_blocks (void *cls,
  */
 static void
 process_dht_put_content (void *cls,
-                         const GNUNET_HashCode * key,
-                         size_t size,
-                         const void *data,
-                         enum GNUNET_BLOCK_Type type,
-                         uint32_t priority,
-                         uint32_t anonymity,
-                         struct GNUNET_TIME_Absolute
-                         expiration, uint64_t uid)
-{ 
+                         const GNUNET_HashCode * key,
+                         size_t size,
+                         const void *data,
+                         enum GNUNET_BLOCK_Type type,
+                         uint32_t priority,
+                         uint32_t anonymity,
+                         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->current_offset - 1;
-      po->current_offset = 0;
-      po->dht_task = GNUNET_SCHEDULER_add_now (&delay_dht_put_blocks,
-                                               po);
-      return;
-    }
+  {
+    po->zero_anonymity_count_estimate = po->current_offset - 1;
+    po->current_offset = 0;
+    po->dht_task = GNUNET_SCHEDULER_add_now (&delay_dht_put_blocks, po);
+    return;
+  }
   po->zero_anonymity_count_estimate = GNUNET_MAX (po->current_offset,
-                                                  po->zero_anonymity_count_estimate);
+                                                  po->zero_anonymity_count_estimate);
 #if DEBUG_FS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Retrieved block `%s' of type %u for DHT PUT\n",
-              GNUNET_h2s (key),
-              type);
+              "Retrieved block `%s' of type %u for DHT PUT\n",
+              GNUNET_h2s (key), type);
 #endif
   GNUNET_DHT_put (GSF_dht,
-                  key,
-                  DEFAULT_PUT_REPLICATION,
-                  GNUNET_DHT_RO_NONE,
-                  type,
-                  size,
-                  data,
-                  expiration,
-                  GNUNET_TIME_UNIT_FOREVER_REL,
-                  &delay_dht_put_blocks,
-                  po);
+                  key,
+                  DEFAULT_PUT_REPLICATION,
+                  GNUNET_DHT_RO_NONE,
+                  type,
+                  size,
+                  data,
+                  expiration,
+                  GNUNET_TIME_UNIT_FOREVER_REL, &delay_dht_put_blocks, po);
 }
 
 
@@ -192,23 +183,22 @@ process_dht_put_content (void *cls,
  * @param tc scheduler context (unused)
  */
 static void
-gather_dht_put_blocks (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+gather_dht_put_blocks (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct PutOperator *po = cls;
 
   po->dht_task = GNUNET_SCHEDULER_NO_TASK;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
-  po->dht_qe = GNUNET_DATASTORE_get_zero_anonymity (GSF_dsh, 
-                                                    po->current_offset++,
-                                                    0, UINT_MAX,
-                                                    GNUNET_TIME_UNIT_FOREVER_REL,
-                                                    po->dht_put_type,
-                                                    &process_dht_put_content, po);
+  po->dht_qe = GNUNET_DATASTORE_get_zero_anonymity (GSF_dsh,
+                                                    po->current_offset++,
+                                                    0, UINT_MAX,
+                                                    GNUNET_TIME_UNIT_FOREVER_REL,
+                                                    po->dht_put_type,
+                                                    &process_dht_put_content,
+                                                    po);
   if (NULL == po->dht_qe)
-    po->dht_task = GNUNET_SCHEDULER_add_now (&delay_dht_put_blocks,
-                                             po);
+    po->dht_task = GNUNET_SCHEDULER_add_now (&delay_dht_put_blocks, po);
 }
 
 
@@ -222,10 +212,11 @@ GSF_put_init_ ()
 
   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++;
+  }
 }
 
 
@@ -240,19 +231,19 @@ GSF_put_done_ ()
 
   i = 0;
   while ((po = &operators[i])->dht_put_type != GNUNET_BLOCK_TYPE_ANY)
+  {
+    if (GNUNET_SCHEDULER_NO_TASK != po->dht_task)
+    {
+      GNUNET_SCHEDULER_cancel (po->dht_task);
+      po->dht_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    if (NULL != po->dht_qe)
     {
-      if (GNUNET_SCHEDULER_NO_TASK != po->dht_task)
-        {
-          GNUNET_SCHEDULER_cancel (po->dht_task);
-          po->dht_task = GNUNET_SCHEDULER_NO_TASK;
-        }
-      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 59b1f83e3..21c3c3baf 100644
--- a/src/fs/gnunet-service-fs_put.h
+++ b/src/fs/gnunet-service-fs_put.h
@@ -32,15 +32,13 @@
 /**
  * Setup the module.
  */
-void
-GSF_put_init_ (void);
+void GSF_put_init_ (void);
 
 
 /**
  * Shutdown the module.
  */
-void
-GSF_put_done_ (void);
+void GSF_put_done_ (void);
 
 
 #endif
diff --git a/src/fs/gnunet-unindex.c b/src/fs/gnunet-unindex.c
index c1d1890db..a4aad4568 100644
--- a/src/fs/gnunet-unindex.c
+++ b/src/fs/gnunet-unindex.c
@@ -40,8 +40,7 @@ static struct GNUNET_FS_UnindexContext *uc;
 
 
 static void
-cleanup_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_stop (ctx);
   ctx = NULL;
@@ -49,17 +48,16 @@ cleanup_task (void *cls,
 
 
 static void
-shutdown_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   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);
+  }
 }
 
 /**
@@ -76,49 +74,44 @@ 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)
 {
   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);
-          fprintf (stdout,
-                   _("Unindexing at %llu/%llu (%s remaining)\n"),
-                   (unsigned long long) info->value.unindex.completed,
-                   (unsigned long long) info->value.unindex.size,
-                   s);
-          GNUNET_free (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:
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.unindex.eta);
       fprintf (stdout,
-               _("Unindexing done.\n"));
-      GNUNET_SCHEDULER_shutdown ();
-      break;
-    case GNUNET_FS_STATUS_UNINDEX_STOPPED:
-      GNUNET_SCHEDULER_add_continuation (&cleanup_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;      
-    default:
-      fprintf (stderr,
-               _("Unexpected status: %d\n"),
-               info->status);
-      break;
+               _("Unindexing at %llu/%llu (%s remaining)\n"),
+               (unsigned long long) info->value.unindex.completed,
+               (unsigned long long) info->value.unindex.size, s);
+      GNUNET_free (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, _("Unindexing done.\n"));
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+  case GNUNET_FS_STATUS_UNINDEX_STOPPED:
+    GNUNET_SCHEDULER_add_continuation (&cleanup_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    fprintf (stderr, _("Unexpected status: %d\n"), info->status);
+    break;
+  }
   return NULL;
 }
 
@@ -134,45 +127,35 @@ progress_cb (void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     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;
-    }
+  if ((args[0] == NULL) || (args[1] != NULL))
+  {
+    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);
+                         "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,
-               _("Could not start unindex operation.\n"));
-      GNUNET_FS_stop (ctx);
-      return;
-    }
+  {
+    fprintf (stderr, _("Could not start unindex operation.\n"));
+    GNUNET_FS_stop (ctx);
+    return;
+  }
   GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
-                                &shutdown_task,
-                                NULL);
+                                &shutdown_task, NULL);
 }
 
 
diff --git a/src/fs/perf_gnunet_service_fs_p2p.c b/src/fs/perf_gnunet_service_fs_p2p.c
index 572585520..92441e901 100644
--- a/src/fs/perf_gnunet_service_fs_p2p.c
+++ b/src/fs/perf_gnunet_service_fs_p2p.c
@@ -52,11 +52,9 @@ static struct GNUNET_TIME_Absolute start_time;
 static const char *progname;
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                               daemons);
+  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
 }
 
 
@@ -65,7 +63,7 @@ do_stop (void *cls,
  */
 struct StatMaster
 {
-  struct GNUNET_STATISTICS_Handle *stat;  
+  struct GNUNET_STATISTICS_Handle *stat;
   unsigned int daemon;
   unsigned int value;
 };
@@ -79,32 +77,31 @@ struct StatValues
 /**
  * Statistics we print out.
  */
-static struct StatValues stats[] =
-  {
-    { "fs", "# artificial delays introduced (ms)"},
-    { "fs", "# queries forwarded"},
-    { "fs", "# replies received and matched"},
-    { "fs", "# results found locally"},
-    { "fs", "# requests forwarded due to high load"},
-    { "fs", "# requests done for free (low load)"},
-    { "fs", "# requests dropped, priority insufficient"},
-    { "fs", "# requests done for a price (normal load)"},
-    { "fs", "# requests dropped by datastore (queue length limit)"},
-    { "fs", "# P2P searches received"},
-    { "fs", "# P2P searches discarded (queue length bound)"},
-    { "fs", "# replies received for local clients"},
-    { "fs", "# queries retransmitted to same target"},
-    { "core", "# bytes decrypted"},
-    { "core", "# bytes encrypted"},
-    { "core", "# discarded CORE_SEND requests"},
-    { "core", "# discarded CORE_SEND request bytes"},
-    { "core", "# discarded lower priority CORE_SEND requests"},
-    { "core", "# discarded lower priority CORE_SEND request bytes"},
-    { "transport", "# bytes received via TCP"},
-    { "transport", "# bytes transmitted via TCP"},
-    { "datacache", "# bytes stored"},
-    { NULL, NULL}
-  };
+static struct StatValues stats[] = {
+  {"fs", "# artificial delays introduced (ms)"},
+  {"fs", "# queries forwarded"},
+  {"fs", "# replies received and matched"},
+  {"fs", "# results found locally"},
+  {"fs", "# requests forwarded due to high load"},
+  {"fs", "# requests done for free (low load)"},
+  {"fs", "# requests dropped, priority insufficient"},
+  {"fs", "# requests done for a price (normal load)"},
+  {"fs", "# requests dropped by datastore (queue length limit)"},
+  {"fs", "# P2P searches received"},
+  {"fs", "# P2P searches discarded (queue length bound)"},
+  {"fs", "# replies received for local clients"},
+  {"fs", "# queries retransmitted to same target"},
+  {"core", "# bytes decrypted"},
+  {"core", "# bytes encrypted"},
+  {"core", "# discarded CORE_SEND requests"},
+  {"core", "# discarded CORE_SEND request bytes"},
+  {"core", "# discarded lower priority CORE_SEND requests"},
+  {"core", "# discarded lower priority CORE_SEND request bytes"},
+  {"transport", "# bytes received via TCP"},
+  {"transport", "# bytes transmitted via TCP"},
+  {"datacache", "# bytes stored"},
+  {NULL, NULL}
+};
 
 
 /**
@@ -119,18 +116,14 @@ static struct StatValues stats[] =
  */
 static int
 print_stat (void *cls,
-            const char *subsystem,
-            const char *name,
-            uint64_t value,
-            int is_persistent)
+            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);
+           "Peer %2u: %12s/%50s = %12llu\n",
+           sm->daemon, subsystem, name, (unsigned long long) value);
   return GNUNET_OK;
 }
 
@@ -138,20 +131,18 @@ print_stat (void *cls,
 /**
  * Function that gathers stats from all daemons.
  */
-static void
-stat_run (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc);
+static void stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
  * 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++;
   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 }
@@ -161,129 +152,115 @@ get_done (void *cls,
  * Function that gathers stats from all daemons.
  */
 static void
-stat_run (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc)
+stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct StatMaster *sm = cls;
- 
+
   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
-                             GNUNET_TIME_UNIT_FOREVER_REL,
-                             &get_done,
-                             &print_stat, sm);
-      return;
-    }
+                           GNUNET_TIME_UNIT_FOREVER_REL,
+                           &get_done, &print_stat, sm);
+    return;
+  }
   GNUNET_STATISTICS_destroy (sm->stat, GNUNET_NO);
   sm->value = 0;
   sm->daemon++;
   if (sm->daemon == NUM_DAEMONS)
-    {
-      GNUNET_free (sm);
-      GNUNET_SCHEDULER_add_now (&do_stop, NULL);
-      return;
-    }
+  {
+    GNUNET_free (sm);
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+    return;
+  }
   sm->stat = GNUNET_STATISTICS_create ("<driver>",
-                                       GNUNET_FS_TEST_get_configuration (daemons,
-                                                                         sm->daemon));
+                                       GNUNET_FS_TEST_get_configuration
+                                       (daemons, sm->daemon));
   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 }
 
 
 static void
-do_report (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TIME_Relative del;
-  char *fancy; 
+  char *fancy;
   struct StatMaster *sm;
-  
+
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      del = GNUNET_TIME_absolute_get_duration (start_time);
-      if (del.rel_value == 0)
-        del.rel_value = 1;
-      fancy = GNUNET_STRINGS_byte_size_fancy (((unsigned long long)FILESIZE) * 1000LL / del.rel_value);
-      fprintf (stdout,
-               "Download speed was %s/s\n",
-               fancy);
-      GNUNET_free (fancy);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Finished download, shutting down\n",
-                  (unsigned long long) FILESIZE);
-      sm = GNUNET_malloc (sizeof (struct StatMaster));
-      sm->stat = GNUNET_STATISTICS_create ("<driver>",
-                                           GNUNET_FS_TEST_get_configuration (daemons,
-                                                                             sm->daemon));
-      GNUNET_SCHEDULER_add_now (&stat_run, sm);
-    }
+  {
+    del = GNUNET_TIME_absolute_get_duration (start_time);
+    if (del.rel_value == 0)
+      del.rel_value = 1;
+    fancy =
+        GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
+                                        1000LL / del.rel_value);
+    fprintf (stdout, "Download speed was %s/s\n", fancy);
+    GNUNET_free (fancy);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished download, shutting down\n",
+                (unsigned long long) FILESIZE);
+    sm = GNUNET_malloc (sizeof (struct StatMaster));
+    sm->stat = GNUNET_STATISTICS_create ("<driver>",
+                                         GNUNET_FS_TEST_get_configuration
+                                         (daemons, sm->daemon));
+    GNUNET_SCHEDULER_add_now (&stat_run, sm);
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during download, shutting down with error\n");
-      ok = 1;
-      GNUNET_SCHEDULER_add_now (&do_stop, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during download, shutting down with error\n");
+    ok = 1;
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+  }
 }
 
 
 static void
-do_download (void *cls,
-             const struct GNUNET_FS_Uri *uri)
+do_download (void *cls, const struct GNUNET_FS_Uri *uri)
 {
   int anonymity;
 
   if (NULL == uri)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    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);
+              "Downloading %llu bytes\n", (unsigned long long) FILESIZE);
   start_time = GNUNET_TIME_absolute_get ();
   if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
   GNUNET_FS_TEST_download (daemons[0],
-                           TIMEOUT,
-                           anonymity, SEED, uri, 
-                           VERBOSE, 
-                           &do_report, NULL);
+                           TIMEOUT,
+                           anonymity, SEED, uri, VERBOSE, &do_report, NULL);
 }
 
 
 static void
-do_publish (void *cls,
-            const char *emsg)
+do_publish (void *cls, const char *emsg)
 {
   int do_index;
   int anonymity;
 
   if (NULL != emsg)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Error trying to connect: %s\n",
-                  emsg);
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg);
+    ok = 1;
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
@@ -292,61 +269,52 @@ do_publish (void *cls,
     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);
 }
 
 
 static void
-do_connect (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TESTING_PeerGroup *pg;
 
   GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Daemons started, will now try to connect them\n");
+              "Daemons started, will now try to connect them\n");
   pg = GNUNET_FS_TEST_get_group (daemons);
-  GNUNET_break ( (NUM_DAEMONS - 1) * 2
-                 == (GNUNET_TESTING_create_topology (pg, 
-                                                     GNUNET_TESTING_TOPOLOGY_LINE,
-                                                     GNUNET_TESTING_TOPOLOGY_NONE,
-                                                     NULL)));
+  GNUNET_break ((NUM_DAEMONS - 1) * 2
+                == (GNUNET_TESTING_create_topology (pg,
+                                                    GNUNET_TESTING_TOPOLOGY_LINE,
+                                                    GNUNET_TESTING_TOPOLOGY_NONE,
+                                                    NULL)));
   GNUNET_TESTING_connect_topology (pg,
-                                   GNUNET_TESTING_TOPOLOGY_LINE,                                   
-                                   GNUNET_TESTING_TOPOLOGY_OPTION_NONE,
-                                   0.0,
-                                   TIMEOUT,
-                                   NUM_DAEMONS,
-                                   &do_publish,
-                                   NULL);
+                                   GNUNET_TESTING_TOPOLOGY_LINE,
+                                   GNUNET_TESTING_TOPOLOGY_OPTION_NONE,
+                                   0.0,
+                                   TIMEOUT, NUM_DAEMONS, &do_publish, NULL);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
-                                TIMEOUT,
-                                NUM_DAEMONS,
-                                daemons,
-                                &do_connect,
-                                NULL);
+                                TIMEOUT,
+                                NUM_DAEMONS, daemons, &do_connect, NULL);
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "perf-gnunet-service-fs-p2p",
     "-c",
     "fs_test_lib_data.conf",
@@ -360,16 +328,16 @@ main (int argc, char *argv[])
   };
   progname = argv[0];
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
-  GNUNET_log_setup ("perf_gnunet_service_fs_p2p_index", 
+  GNUNET_log_setup ("perf_gnunet_service_fs_p2p_index",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "perf-gnunet-service-fs-p2p-index",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ok;
 }
diff --git a/src/fs/perf_gnunet_service_fs_p2p_trust.c b/src/fs/perf_gnunet_service_fs_p2p_trust.c
index 0128e281d..a78ff0571 100644
--- a/src/fs/perf_gnunet_service_fs_p2p_trust.c
+++ b/src/fs/perf_gnunet_service_fs_p2p_trust.c
@@ -87,11 +87,9 @@ static struct GNUNET_FS_Uri *uri1;
 static struct GNUNET_FS_Uri *uri2;
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                               daemons);
+  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
 }
 
 
@@ -100,7 +98,7 @@ do_stop (void *cls,
  */
 struct StatMaster
 {
-  struct GNUNET_STATISTICS_Handle *stat;  
+  struct GNUNET_STATISTICS_Handle *stat;
   unsigned int daemon;
   unsigned int value;
 };
@@ -114,30 +112,29 @@ struct StatValues
 /**
  * Statistics we print out.
  */
-static struct StatValues stats[] =
-  {
-    { "fs", "# artificial delays introduced (ms)"},
-    { "fs", "# queries forwarded"},
-    { "fs", "# replies received and matched"},
-    { "fs", "# results found locally"},
-    { "fs", "# requests forwarded due to high load"},
-    { "fs", "# requests done for free (low load)"},
-    { "fs", "# requests dropped, priority insufficient"},
-    { "fs", "# requests done for a price (normal load)"},
-    { "fs", "# requests dropped by datastore (queue length limit)"},
-    { "fs", "# P2P searches received"},
-    { "fs", "# P2P searches discarded (queue length bound)"},
-    { "fs", "# replies received for local clients"},
-    { "fs", "# queries retransmitted to same target"},
-    { "core", "# bytes decrypted"},
-    { "core", "# bytes encrypted"},
-    { "core", "# discarded CORE_SEND requests"},
-    { "core", "# discarded lower priority CORE_SEND requests"},
-    { "transport", "# bytes received via TCP"},
-    { "transport", "# bytes transmitted via TCP"},
-    { "datacache", "# bytes stored"},
-    { NULL, NULL}
-  };
+static struct StatValues stats[] = {
+  {"fs", "# artificial delays introduced (ms)"},
+  {"fs", "# queries forwarded"},
+  {"fs", "# replies received and matched"},
+  {"fs", "# results found locally"},
+  {"fs", "# requests forwarded due to high load"},
+  {"fs", "# requests done for free (low load)"},
+  {"fs", "# requests dropped, priority insufficient"},
+  {"fs", "# requests done for a price (normal load)"},
+  {"fs", "# requests dropped by datastore (queue length limit)"},
+  {"fs", "# P2P searches received"},
+  {"fs", "# P2P searches discarded (queue length bound)"},
+  {"fs", "# replies received for local clients"},
+  {"fs", "# queries retransmitted to same target"},
+  {"core", "# bytes decrypted"},
+  {"core", "# bytes encrypted"},
+  {"core", "# discarded CORE_SEND requests"},
+  {"core", "# discarded lower priority CORE_SEND requests"},
+  {"transport", "# bytes received via TCP"},
+  {"transport", "# bytes transmitted via TCP"},
+  {"datacache", "# bytes stored"},
+  {NULL, NULL}
+};
 
 
 /**
@@ -152,18 +149,14 @@ static struct StatValues stats[] =
  */
 static int
 print_stat (void *cls,
-            const char *subsystem,
-            const char *name,
-            uint64_t value,
-            int is_persistent)
+            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);
+           "Peer %2u: %12s/%50s = %12llu\n",
+           sm->daemon, subsystem, name, (unsigned long long) value);
   return GNUNET_OK;
 }
 
@@ -171,20 +164,18 @@ print_stat (void *cls,
 /**
  * Function that gathers stats from all daemons.
  */
-static void
-stat_run (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc);
+static void stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
  * 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++;
   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 }
@@ -194,154 +185,140 @@ get_done (void *cls,
  * Function that gathers stats from all daemons.
  */
 static void
-stat_run (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc)
+stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct StatMaster *sm = cls;
- 
+
   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
-                             GNUNET_TIME_UNIT_FOREVER_REL,
-                             &get_done,
-                             &print_stat, sm);
-      return;
-    }
+                           GNUNET_TIME_UNIT_FOREVER_REL,
+                           &get_done, &print_stat, sm);
+    return;
+  }
   GNUNET_STATISTICS_destroy (sm->stat, GNUNET_NO);
   sm->value = 0;
   sm->daemon++;
   if (sm->daemon == NUM_DAEMONS)
-    {
-      GNUNET_free (sm);
-      GNUNET_SCHEDULER_add_now (&do_stop, NULL);
-      return;
-    }
+  {
+    GNUNET_free (sm);
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+    return;
+  }
   sm->stat = GNUNET_STATISTICS_create ("<driver>",
-                                       GNUNET_FS_TEST_get_configuration (daemons,
-                                                                         sm->daemon));
+                                       GNUNET_FS_TEST_get_configuration
+                                       (daemons, sm->daemon));
   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 }
 
 
 static void
-do_report (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   static int download_counter;
   const char *type = cls;
   struct GNUNET_TIME_Relative del;
-  char *fancy; 
+  char *fancy;
   struct StatMaster *sm;
-  
+
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      del = GNUNET_TIME_absolute_get_duration (start_time);
-      if (del.rel_value == 0)
-        del.rel_value = 1;
-      fancy = GNUNET_STRINGS_byte_size_fancy (((unsigned long long)FILESIZE) * 1000LL / del.rel_value);
-      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, shutting down\n",
-                  (unsigned long long) FILESIZE);
-      sm = GNUNET_malloc (sizeof (struct StatMaster));
-      sm->stat = GNUNET_STATISTICS_create ("<driver>",
-                                           GNUNET_FS_TEST_get_configuration (daemons,
-                                                                             sm->daemon));
-      GNUNET_SCHEDULER_add_now (&stat_run, sm);
-    }
+  {
+    del = GNUNET_TIME_absolute_get_duration (start_time);
+    if (del.rel_value == 0)
+      del.rel_value = 1;
+    fancy =
+        GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
+                                        1000LL / del.rel_value);
+    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, shutting down\n",
+                (unsigned long long) FILESIZE);
+    sm = GNUNET_malloc (sizeof (struct StatMaster));
+    sm->stat = GNUNET_STATISTICS_create ("<driver>",
+                                         GNUNET_FS_TEST_get_configuration
+                                         (daemons, sm->daemon));
+    GNUNET_SCHEDULER_add_now (&stat_run, sm);
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during download for type `%s', shutting down with error\n",
-                  type);
-      ok = 1;
-      GNUNET_SCHEDULER_add_now (&do_stop, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during download for type `%s', shutting down with error\n",
+                type);
+    ok = 1;
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+  }
 }
 
 
 static void
-do_downloads (void *cls,
-              const struct GNUNET_FS_Uri *u2)
+do_downloads (void *cls, const struct GNUNET_FS_Uri *u2)
 {
   int anonymity;
   unsigned int i;
 
   if (NULL == u2)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   uri2 = GNUNET_FS_uri_dup (u2);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Downloading %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Downloading %llu bytes\n", (unsigned long long) FILESIZE);
   start_time = GNUNET_TIME_absolute_get ();
   if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
   /* (semi) leach-download(s); not true leaches since
-     these peers do participate in sharing, they just
-     don't have to offer anything *initially*.  */
-  for (i=0;i<NUM_DAEMONS-2;i++)
+   * 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");
+                             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)
+do_publish2 (void *cls, const struct GNUNET_FS_Uri *u1)
 {
   int do_index;
   int anonymity;
 
   if (NULL == u1)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   uri1 = GNUNET_FS_uri_dup (u1);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
@@ -350,35 +327,29 @@ do_publish2 (void *cls,
     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,
-            const char *emsg)
+do_publish1 (void *cls, const char *emsg)
 {
   int do_index;
   int anonymity;
 
   if (NULL != emsg)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Error trying to connect: %s\n",
-                  emsg);
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg);
+    ok = 1;
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
@@ -387,60 +358,50 @@ do_publish1 (void *cls,
     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,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TESTING_PeerGroup *pg;
 
   GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Daemons started, will now try to connect them\n");
+              "Daemons started, will now try to connect them\n");
   pg = GNUNET_FS_TEST_get_group (daemons);
-  GNUNET_TESTING_create_topology (pg, 
-                                  GNUNET_TESTING_TOPOLOGY_CLIQUE,
-                                  GNUNET_TESTING_TOPOLOGY_NONE,
-                                  NULL);
+  GNUNET_TESTING_create_topology (pg,
+                                  GNUNET_TESTING_TOPOLOGY_CLIQUE,
+                                  GNUNET_TESTING_TOPOLOGY_NONE, NULL);
   GNUNET_TESTING_connect_topology (pg,
-                                   GNUNET_TESTING_TOPOLOGY_CLIQUE,
-                                   GNUNET_TESTING_TOPOLOGY_OPTION_NONE,
-                                   0.0,
-                                   TIMEOUT,
-                                   NUM_DAEMONS,
-                                   &do_publish1,
-                                   NULL);
+                                   GNUNET_TESTING_TOPOLOGY_CLIQUE,
+                                   GNUNET_TESTING_TOPOLOGY_OPTION_NONE,
+                                   0.0,
+                                   TIMEOUT, NUM_DAEMONS, &do_publish1, NULL);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
-                                TIMEOUT,
-                                NUM_DAEMONS,
-                                daemons,
-                                &do_connect,
-                                NULL);
+                                TIMEOUT,
+                                NUM_DAEMONS, daemons, &do_connect, NULL);
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "perf-gnunet-service-fs-p2p",
     "-c",
     "fs_test_lib_data.conf",
@@ -454,16 +415,16 @@ main (int argc, char *argv[])
   };
   progname = argv[0];
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
-  GNUNET_log_setup ("perf_gnunet_service_fs_p2p_trust", 
+  GNUNET_log_setup ("perf_gnunet_service_fs_p2p_trust",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "perf-gnunet-service-fs-p2p-trust",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ok;
 }
diff --git a/src/fs/test_fs.c b/src/fs/test_fs.c
index 41a155407..b936c3199 100644
--- a/src/fs/test_fs.c
+++ b/src/fs/test_fs.c
@@ -37,9 +37,8 @@ makeName (unsigned int i)
 {
   char *fn;
 
-  fn =
-    GNUNET_malloc (strlen ("/tmp/gnunet-basic_fsui_test/BASIC_FSUI_TEST") +
-                   14);
+  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);
@@ -61,39 +60,37 @@ 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;
-    case GNUNET_FSUI_upload_completed:
+    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:
 #if DEBUG_VERBOSE
-      printf ("Upload complete.\n");
+    printf ("Upload complete.\n");
 #endif
-      break;
-    case GNUNET_FSUI_download_completed:
+    break;
+  case GNUNET_FSUI_download_completed:
 #if DEBUG_VERBOSE
-      printf ("Download complete.\n");
+    printf ("Download complete.\n");
 #endif
-      break;
-    case GNUNET_FSUI_unindex_completed:
+    break;
+  case GNUNET_FSUI_unindex_completed:
 #if DEBUG_VERBOSE
-      printf ("Unindex complete.\n");
+    printf ("Unindex complete.\n");
 #endif
-      break;
-    default:
-      break;
-    }
+    break;
+  default:
+    break;
+  }
   lastEvent = event->type;
   return NULL;
 }
@@ -109,6 +106,7 @@ main (int argc, char *argv[])
   int ok;
   struct GNUNET_ECRS_URI *uri;
   char *filename = NULL;
+
   char *keywords[] = {
     "fsui_foo",
     "fsui_bar",
@@ -126,16 +124,15 @@ main (int argc, char *argv[])
 
   cfg = GNUNET_GC_create ();
   if (-1 == GNUNET_GC_parse_configuration (cfg, "check.conf"))
-    {
-      GNUNET_GC_free (cfg);
-      return -1;
-    }
+  {
+    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));
+         GNUNET_wait_for_daemon_running (NULL, cfg, 60 * GNUNET_CRON_SECONDS));
 #endif
   GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);        /* give apps time to start */
   ok = GNUNET_YES;
@@ -151,8 +148,8 @@ main (int argc, char *argv[])
                           "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 */
@@ -166,13 +163,12 @@ main (int argc, char *argv[])
   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]);
@@ -182,13 +178,13 @@ main (int argc, char *argv[])
   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;
-    }
+  {
+    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);
 
@@ -202,13 +198,13 @@ main (int argc, char *argv[])
   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;
-    }
+  {
+    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);
@@ -217,13 +213,13 @@ main (int argc, char *argv[])
   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);
@@ -234,15 +230,15 @@ FAILURE:
   if (ctx != NULL)
     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);
-    }
+  {
+    GNUNET_FSUI_download_abort (download);
+    GNUNET_FSUI_download_stop (download);
+  }
   filename = makeName (43);
   /* TODO: verify file 'filename(42)' == file 'filename(43)' */
   UNLINK (filename);
diff --git a/src/fs/test_fs_directory.c b/src/fs/test_fs_directory.c
index b32628b73..d8a9c63b6 100644
--- a/src/fs/test_fs_directory.c
+++ b/src/fs/test_fs_directory.c
@@ -42,27 +42,26 @@ 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)
+           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;
 
   if (NULL == uri)
-    return; /* ignore directory's meta data */
+    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__);
 }
 
@@ -86,89 +85,81 @@ testDirectory (unsigned int i)
   char *s;
 
   cls.max = i;
-  uris = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri*) * i);
-  mds = GNUNET_malloc (sizeof (struct GNUNET_CONTAINER_MetaData*) * 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);
+  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>",
-                                             q % EXTRACTOR_metatype_get_max (),
-                                             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);
+      GNUNET_snprintf (txt, sizeof (txt), "%u -- %u\n", p, q);
+      GNUNET_CONTAINER_meta_data_insert (mds[p],
+                                         "<test>",
+                                         q % EXTRACTOR_metatype_get_max (),
+                                         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);
+  }
   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_FS_directory_builder_finish (db, &dlen, (void **) &data);
+  s = GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration
+                                              (start));
   fprintf (stdout,
-           "Creating directory with %u entires and total size %llu took %s\n",
-           i,
-           (unsigned long long) dlen,
-           s);
+           "Creating directory with %u entires and total size %llu took %s\n",
+           i, (unsigned long long) dlen, s);
   GNUNET_free (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);
-    }
+  {
+    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_CONTAINER_meta_data_destroy (mds[p]);
+    GNUNET_FS_uri_destroy (uris[p]);
+  }
   GNUNET_free (uris);
   GNUNET_free (mds);
   return ret;
@@ -181,15 +172,15 @@ 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 6bc287da3..d37b94c03 100644
--- a/src/fs/test_fs_download.c
+++ b/src/fs/test_fs_download.c
@@ -46,7 +46,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -74,57 +74,52 @@ static char *fn;
 static int err;
 
 static void
-timeout_kill_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   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_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 = GNUNET_SCHEDULER_NO_TASK;
   err = 1;
 }
 
 static void
-abort_publish_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (publish != NULL)
-    {
-      GNUNET_FS_publish_stop (publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
 }
 
 static void
-stop_fs_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+stop_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_stop (fs);
   fs = NULL;
 }
 
 static void
-abort_download_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_download_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   uint64_t size;
-  
+
   if (download != NULL)
-    {
-      GNUNET_FS_download_stop (download, GNUNET_YES);
-      download = NULL;
-    }
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
   GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES));
-  GNUNET_assert (size == FILESIZE); 
+  GNUNET_assert (size == FILESIZE);
   GNUNET_DISK_directory_remove (fn);
   GNUNET_free (fn);
   fn = NULL;
@@ -134,115 +129,116 @@ abort_download_task (void *cls,
 
 
 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:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 #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);
-#endif      
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf ("Publishing complete, %llu kb/s.\n",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
-      GAUGER ("FS",
-              "Publishing speed (insertion)",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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,
-                                           1,
-                                           GNUNET_FS_DOWNLOAD_OPTION_NONE,
-                                           "download",
-                                           NULL);
-      GNUNET_assert (download != NULL);
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      printf ("Download complete,  %llu kb/s.\n",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
-      GAUGER ("FS",
-              "Local download speed (inserted)",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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);
+    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_COMPLETED:
+    printf ("Publishing complete, %llu kb/s.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL));
+    GAUGER ("FS", "Publishing speed (insertion)",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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, 1,
+                                         GNUNET_FS_DOWNLOAD_OPTION_NONE,
+                                         "download", NULL);
+    GNUNET_assert (download != NULL);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    printf ("Download complete,  %llu kb/s.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL));
+    GAUGER ("FS", "Local download speed (inserted)",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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);
 #if VERBOSE
-      printf ("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);
+    printf ("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);
 #endif
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    default:
-      printf ("Unexpected event: %d\n", 
-              event->status);
-      break;
-    }
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
@@ -253,11 +249,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -268,16 +264,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);    
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -286,8 +283,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -302,12 +298,10 @@ run (void *cls,
 
   setup_peer (&p1, "test_fs_download_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-download",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "test-fs-download",
+                        &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);
@@ -316,26 +310,22 @@ run (void *cls,
   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);
   fi = GNUNET_FS_file_information_create_from_data (fs,
-                                                    "publish-context",
-                                                    FILESIZE,
-                                                    buf,
-                                                    kuri,
-                                                    meta,
-                                                    GNUNET_NO,
-                                                    &bo);
+                                                    "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);
+                                               &timeout_kill_task, NULL);
   start = GNUNET_TIME_absolute_get ();
   publish = GNUNET_FS_publish_start (fs,
-                                    fi,
-                                    NULL, NULL, NULL,
-                                    GNUNET_FS_PUBLISH_OPTION_NONE);
+                                     fi,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -343,7 +333,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-download",
     "-c",
     "test_fs_download_data.conf",
@@ -356,16 +346,15 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_download", 
+  GNUNET_log_setup ("test_fs_download",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-download",
-                      "nohelp", options, &run, NULL);
+                      argvx, "test-fs-download", "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
   return err;
diff --git a/src/fs/test_fs_download_indexed.c b/src/fs/test_fs_download_indexed.c
index c99dd04de..86933352a 100644
--- a/src/fs/test_fs_download_indexed.c
+++ b/src/fs/test_fs_download_indexed.c
@@ -46,7 +46,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -76,55 +76,51 @@ static char *fn1;
 static int err;
 
 static void
-timeout_kill_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   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 = GNUNET_SCHEDULER_NO_TASK;
   err = 1;
 }
 
 static void
-abort_publish_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (publish != NULL)
-    {
-      GNUNET_FS_publish_stop (publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
 }
 
 static void
-stop_fs_task (void *cls,
-              const struct GNUNET_SCHEDULER_TaskContext *tc)
+stop_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_stop (fs);
   fs = NULL;
 }
 
 static void
-abort_download_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_download_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   uint64_t size;
-  
+
   if (download != NULL)
-    {
-      GNUNET_FS_download_stop (download, GNUNET_YES);
-      download = NULL;
-    }
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
   GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES));
-  GNUNET_assert (size == FILESIZE); 
+  GNUNET_assert (size == FILESIZE);
   GNUNET_DISK_directory_remove (fn);
   GNUNET_free (fn);
   fn = NULL;
@@ -134,115 +130,116 @@ abort_download_task (void *cls,
 
 
 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:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 #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);
-#endif      
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf ("Publishing complete, %llu kbps.\n",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
-      GAUGER ("FS",
-              "Publishing speed (indexing)",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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,
-                                           1,
-                                           GNUNET_FS_DOWNLOAD_OPTION_NONE,
-                                           "download",
-                                           NULL);
-      GNUNET_assert (download != NULL);
-      break;
-    case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
-      printf ("Download complete,  %llu kbps.\n",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024LL));
-      GAUGER ("FS",
-              "Local download speed (indexed)",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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);
+    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_COMPLETED:
+    printf ("Publishing complete, %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL));
+    GAUGER ("FS", "Publishing speed (indexing)",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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, 1,
+                                         GNUNET_FS_DOWNLOAD_OPTION_NONE,
+                                         "download", NULL);
+    GNUNET_assert (download != NULL);
+    break;
+  case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+    printf ("Download complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024LL));
+    GAUGER ("FS", "Local download speed (indexed)",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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);
 #if VERBOSE
-      printf ("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);
+    printf ("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);
 #endif
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    default:
-      printf ("Unexpected event: %d\n", 
-              event->status);
-      break;
-    }
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
@@ -253,11 +250,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -268,16 +265,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -286,8 +284,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -302,47 +299,43 @@ run (void *cls,
 
   setup_peer (&p1, "test_fs_download_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-download-indexed",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "test-fs-download-indexed",
+                        &progress_cb,
+                        NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
 
   fn1 = GNUNET_DISK_mktemp ("gnunet-download-indexed-test");
   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_DISK_fn_write (fn1,
+                                       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);
   fi = GNUNET_FS_file_information_create_from_file (fs,
-                                                    "publish-context",
-                                                    fn1,
-                                                    kuri,
-                                                    meta,
-                                                    GNUNET_YES,
-                                                    &bo);
+                                                    "publish-context",
+                                                    fn1,
+                                                    kuri,
+                                                    meta, GNUNET_YES, &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);
+                                               &timeout_kill_task, NULL);
   start = GNUNET_TIME_absolute_get ();
   publish = GNUNET_FS_publish_start (fs,
-                                    fi,
-                                    NULL, NULL, NULL,
-                                    GNUNET_FS_PUBLISH_OPTION_NONE);
+                                     fi,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -350,7 +343,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-download-indexed",
     "-c",
     "test_fs_download_data.conf",
@@ -363,27 +356,27 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_download_indexed", 
+  GNUNET_log_setup ("test_fs_download_indexed",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-download-indexed",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   stop_arm (&p1);
   if (fn1 != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn1);
-      GNUNET_free (fn1);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn1);
+    GNUNET_free (fn1);
+  }
   if (fn != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn);
-      GNUNET_free (fn);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn);
+    GNUNET_free (fn);
+  }
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
   return err;
 }
diff --git a/src/fs/test_fs_download_persistence.c b/src/fs/test_fs_download_persistence.c
index b058367a2..d484f9587 100644
--- a/src/fs/test_fs_download_persistence.c
+++ b/src/fs/test_fs_download_persistence.c
@@ -45,7 +45,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -75,50 +75,46 @@ static char *fn;
 static int err;
 
 static void
-timeout_kill_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+timeout_kill_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  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 = GNUNET_SCHEDULER_NO_TASK;
   err = 1;
 }
 
 static void
-abort_publish_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (publish != NULL)
-    {
-      GNUNET_FS_publish_stop (publish);
-      publish = NULL;
-    }
+  {
+    GNUNET_FS_publish_stop (publish);
+    publish = NULL;
+  }
 }
 
 
 static void
-abort_download_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_download_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   uint64_t size;
-  
+
   if (download != NULL)
-    {
-      GNUNET_FS_download_stop (download, GNUNET_YES);
-      download = NULL;
-    }
+  {
+    GNUNET_FS_download_stop (download, GNUNET_YES);
+    download = NULL;
+  }
   GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_size (fn, &size, GNUNET_YES));
-  GNUNET_assert (size == FILESIZE); 
+  GNUNET_assert (size == FILESIZE);
   GNUNET_DISK_directory_remove (fn);
   GNUNET_free (fn);
   fn = NULL;
@@ -127,24 +123,20 @@ abort_download_task (void *cls,
 }
 
 
-static void *
-progress_cb (void *cls, 
-             const struct GNUNET_FS_ProgressInfo *event);
+static void *progress_cb (void *cls,
+                          const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Restarting FS.\n");
+  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);
+                        "test-fs-download-persistence",
+                        &progress_cb,
+                        NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -161,152 +153,149 @@ consider_restart (int ev)
   static int prev[32];
   static int off;
   int i;
-  for (i=0;i<off;i++)
+
+  for (i = 0; i < off; i++)
     if (prev[i] == ev)
       return;
   prev[off++] = ev;
   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                      &restart_fs_task,
-                                      NULL);
+                                      &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:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 #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);
-#endif      
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf ("Publishing complete, %llu kbps.\n",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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:
-      consider_restart (event->status);
-      printf ("Download complete,  %llu kbps.\n",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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);
+    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_COMPLETED:
+    printf ("Publishing complete, %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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:
+    consider_restart (event->status);
+    printf ("Download complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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);
 #if VERBOSE
-      printf ("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);
+    printf ("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);
 #endif
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      download = NULL;
-      break;
-    default:
-      printf ("Unexpected event: %d\n", 
-              event->status);
-      break;
-    }
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    download = NULL;
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
@@ -317,11 +306,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -332,16 +321,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -350,8 +340,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   const char *keywords[] = {
     "down_foo",
@@ -367,12 +356,11 @@ run (void *cls,
   cfg = c;
   setup_peer (&p1, "test_fs_download_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-download-persistence",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_PERSISTENCE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "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);
@@ -381,26 +369,22 @@ run (void *cls,
   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);
   fi = GNUNET_FS_file_information_create_from_data (fs,
-                                                    "publish-context",
-                                                    FILESIZE,
-                                                    buf,
-                                                    kuri,
-                                                    meta,
-                                                    GNUNET_NO,
-                                                    &bo);
+                                                    "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);
+                                               &timeout_kill_task, NULL);
   start = GNUNET_TIME_absolute_get ();
   publish = GNUNET_FS_publish_start (fs,
-                                    fi,
-                                    NULL, NULL, NULL,
-                                    GNUNET_FS_PUBLISH_OPTION_NONE);
+                                     fi,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -408,7 +392,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-download-persistence",
     "-c",
     "test_fs_download_data.conf",
@@ -420,17 +404,17 @@ main (int argc, char *argv[])
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_OPTION_END
   };
-  GNUNET_log_setup ("test_fs_download_persistence", 
+  GNUNET_log_setup ("test_fs_download_persistence",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-download-persistence",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-download/");
   return err;
diff --git a/src/fs/test_fs_download_recursive.c b/src/fs/test_fs_download_recursive.c
index d24a38dbc..c3e0ea440 100644
--- a/src/fs/test_fs_download_recursive.c
+++ b/src/fs/test_fs_download_recursive.c
@@ -46,10 +46,9 @@ makeName (unsigned int i)
 {
   char *fn;
 
-  fn =
-    GNUNET_malloc (strlen
-                   ("/tmp/gnunet-fsui-recursive_download_test/FSUITEST") +
-                   15);
+  fn = GNUNET_malloc (strlen
+                      ("/tmp/gnunet-fsui-recursive_download_test/FSUITEST") +
+                      15);
   GNUNET_snprintf (fn,
                    strlen
                    ("/tmp/gnunet-fsui-recursive_download_test/FSUITEST") + 15,
@@ -68,56 +67,56 @@ makeHierarchyHelper (const char *current, const char *tree, int index,
   fi = 0;
   done = 0;
   while (!done && tree[index] != '\0')
+  {
+    s = GNUNET_malloc (strlen (current) + strlen (DIR_SEPARATOR_STR) + 14);
+    GNUNET_snprintf (s, strlen (current) + strlen (DIR_SEPARATOR_STR) + 14,
+                     "%s%s%u", current, DIR_SEPARATOR_STR, fi);
+    switch (tree[index++])
     {
-      s = GNUNET_malloc (strlen (current) + strlen (DIR_SEPARATOR_STR) + 14);
-      GNUNET_snprintf (s, strlen (current) + strlen (DIR_SEPARATOR_STR) + 14,
-                       "%s%s%u", current, DIR_SEPARATOR_STR, fi);
-      switch (tree[index++])
+    case 'd':
+      if (check)
+      {
+        if (GNUNET_disk_directory_test (NULL, s) == GNUNET_NO)
         {
-        case 'd':
-          if (check)
-            {
-              if (GNUNET_disk_directory_test (NULL, s) == GNUNET_NO)
-                {
-                  index = -1;
-                  done = 1;
-                }
-            }
-          else
-            {
-              GNUNET_disk_directory_create (NULL, s);
-            }
-          if (!done)
-            index = makeHierarchyHelper (s, tree, index, check);
-          break;
-        case 'f':
-          if (check)
-            {
-              /* TODO: compare file contents */
-              if (GNUNET_disk_directory_test (NULL, s) != GNUNET_NO)
-                {
-                  index = -1;
-                  done = 1;
-                }
-            }
-          else
-            {
-              buf = GNUNET_malloc (FILESIZE);
-              for (i = 0; i < FILESIZE; i++)
-                buf[i] = GNUNET_random_u32 (GNUNET_RANDOM_QUALITY_WEAK, 256);
-              GNUNET_disk_file_write (ectx, s, buf, FILESIZE, "600");
-              GNUNET_free (buf);
-            }
-          break;
-        case '.':
+          index = -1;
           done = 1;
-          break;
-        default:
-          break;
         }
-      GNUNET_free (s);
-      fi++;
+      }
+      else
+      {
+        GNUNET_disk_directory_create (NULL, s);
+      }
+      if (!done)
+        index = makeHierarchyHelper (s, tree, index, check);
+      break;
+    case 'f':
+      if (check)
+      {
+        /* TODO: compare file contents */
+        if (GNUNET_disk_directory_test (NULL, s) != GNUNET_NO)
+        {
+          index = -1;
+          done = 1;
+        }
+      }
+      else
+      {
+        buf = GNUNET_malloc (FILESIZE);
+        for (i = 0; i < FILESIZE; i++)
+          buf[i] = GNUNET_random_u32 (GNUNET_RANDOM_QUALITY_WEAK, 256);
+        GNUNET_disk_file_write (ectx, s, buf, FILESIZE, "600");
+        GNUNET_free (buf);
+      }
+      break;
+    case '.':
+      done = 1;
+      break;
+    default:
+      break;
     }
+    GNUNET_free (s);
+    fi++;
+  }
   return index;
 }
 
@@ -139,10 +138,10 @@ checkHierarchy (unsigned int i, const char *tree)
 
   fn = makeName (i);
   if (GNUNET_disk_directory_test (NULL, fn) != GNUNET_YES)
-    {
-      GNUNET_free (fn);
-      return GNUNET_SYSERR;
-    }
+  {
+    GNUNET_free (fn);
+    return GNUNET_SYSERR;
+  }
   res = ((makeHierarchyHelper (fn, tree, 0, 1) == -1) ?
          GNUNET_SYSERR : GNUNET_OK);
   GNUNET_free (fn);
@@ -160,89 +159,87 @@ static void *
 eventCallback (void *cls, const GNUNET_FSUI_Event * event)
 {
   switch (event->type)
-    {
-    case GNUNET_FSUI_download_suspended:
-      download = NULL;
-      break;
-    case GNUNET_FSUI_download_resumed:
-      download = event->data.DownloadResumed.dc.pos;
-      break;
-      break;
-    case GNUNET_FSUI_upload_progress:
+  {
+  case GNUNET_FSUI_download_suspended:
+    download = NULL;
+    break;
+  case GNUNET_FSUI_download_resumed:
+    download = event->data.DownloadResumed.dc.pos;
+    break;
+    break;
+  case GNUNET_FSUI_upload_progress:
 #if DEBUG_VERBOSE > 1
-      printf ("Upload is progressing (%llu/%llu)...\n",
-              event->data.UploadProgress.completed,
-              event->data.UploadProgress.total);
+    printf ("Upload is progressing (%llu/%llu)...\n",
+            event->data.UploadProgress.completed,
+            event->data.UploadProgress.total);
 #endif
-      break;
-    case GNUNET_FSUI_upload_completed:
-      upURI = GNUNET_ECRS_uri_duplicate (event->data.UploadCompleted.uri);
+    break;
+  case GNUNET_FSUI_upload_completed:
+    upURI = GNUNET_ECRS_uri_duplicate (event->data.UploadCompleted.uri);
 #if DEBUG_VERBOSE
-      printf ("Upload of `%s' complete.\n",
-              event->data.UploadCompleted.filename);
+    printf ("Upload of `%s' complete.\n", event->data.UploadCompleted.filename);
 #endif
-      break;
-    case GNUNET_FSUI_download_completed:
+    break;
+  case GNUNET_FSUI_download_completed:
 #if DEBUG_VERBOSE
-      printf ("Download of `%s' complete.\n",
-              event->data.DownloadCompleted.filename);
+    printf ("Download of `%s' complete.\n",
+            event->data.DownloadCompleted.filename);
 #endif
-      if (checkHierarchy (43, DIRECTORY_TREE_SPEC) == GNUNET_OK)
-        download_done = 1;
+    if (checkHierarchy (43, DIRECTORY_TREE_SPEC) == GNUNET_OK)
+      download_done = 1;
 #if DEBUG_VERBOSE
-      else
-        printf ("Hierarchy check not successful yet...\n");
+    else
+      printf ("Hierarchy check not successful yet...\n");
 #endif
-      break;
-    case GNUNET_FSUI_download_progress:
+    break;
+  case GNUNET_FSUI_download_progress:
 #if DEBUG_VERBOSE > 1
-      printf ("Download is progressing (%llu/%llu)...\n",
-              event->data.DownloadProgress.completed,
-              event->data.DownloadProgress.total);
+    printf ("Download is progressing (%llu/%llu)...\n",
+            event->data.DownloadProgress.completed,
+            event->data.DownloadProgress.total);
 #endif
-      break;
-    case GNUNET_FSUI_unindex_progress:
+    break;
+  case GNUNET_FSUI_unindex_progress:
 #if DEBUG_VERBOSE > 1
-      printf ("Unindex is progressing (%llu/%llu)...\n",
-              event->data.UnindexProgress.completed,
-              event->data.UnindexProgress.total);
+    printf ("Unindex is progressing (%llu/%llu)...\n",
+            event->data.UnindexProgress.completed,
+            event->data.UnindexProgress.total);
 #endif
-      break;
-    case GNUNET_FSUI_unindex_completed:
+    break;
+  case GNUNET_FSUI_unindex_completed:
 #if DEBUG_VERBOSE
-      printf ("Unindex complete.\n");
+    printf ("Unindex complete.\n");
 #endif
-      break;
-    case GNUNET_FSUI_unindex_error:
-      fprintf (stderr, "Error unindexing: %s\n",
-               event->data.UnindexError.message);
-      break;
-    case GNUNET_FSUI_upload_error:
-      fprintf (stderr, "Error uploading: %s\n",
-               event->data.UploadError.message);
-      break;
-    case GNUNET_FSUI_download_error:
-      fprintf (stderr, "Error downloading: %s\n",
-               event->data.DownloadError.message);
-      break;
-    case GNUNET_FSUI_download_aborted:
+    break;
+  case GNUNET_FSUI_unindex_error:
+    fprintf (stderr, "Error unindexing: %s\n",
+             event->data.UnindexError.message);
+    break;
+  case GNUNET_FSUI_upload_error:
+    fprintf (stderr, "Error uploading: %s\n", event->data.UploadError.message);
+    break;
+  case GNUNET_FSUI_download_error:
+    fprintf (stderr, "Error downloading: %s\n",
+             event->data.DownloadError.message);
+    break;
+  case GNUNET_FSUI_download_aborted:
 #if DEBUG_VERBOSE
-      printf ("Received download aborted event.\n");
+    printf ("Received download aborted event.\n");
 #endif
-      break;
-    case GNUNET_FSUI_unindex_suspended:
-    case GNUNET_FSUI_upload_suspended:
-    case GNUNET_FSUI_upload_started:
-    case GNUNET_FSUI_upload_stopped:
-    case GNUNET_FSUI_download_started:
-    case GNUNET_FSUI_download_stopped:
-    case GNUNET_FSUI_unindex_started:
-    case GNUNET_FSUI_unindex_stopped:
-      break;
-    default:
-      printf ("Unexpected event: %d\n", event->type);
-      break;
-    }
+    break;
+  case GNUNET_FSUI_unindex_suspended:
+  case GNUNET_FSUI_upload_suspended:
+  case GNUNET_FSUI_upload_started:
+  case GNUNET_FSUI_upload_stopped:
+  case GNUNET_FSUI_download_started:
+  case GNUNET_FSUI_download_stopped:
+  case GNUNET_FSUI_unindex_started:
+  case GNUNET_FSUI_unindex_stopped:
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->type);
+    break;
+  }
   if (lastEvent == waitForEvent)
     return NULL;                /* ignore all other events */
   lastEvent = event->type;
@@ -261,6 +258,7 @@ main (int argc, char *argv[])
   int ok;
   char *fn = NULL;
   char *fn43 = NULL;
+
   char *keywords[] = {
     "down_foo",
     "down_bar",
@@ -274,20 +272,18 @@ main (int argc, char *argv[])
   ok = GNUNET_YES;
   cfg = GNUNET_GC_create ();
   if (-1 == GNUNET_GC_parse_configuration (cfg, "check.conf"))
-    {
-      GNUNET_GC_free (cfg);
-      return -1;
-    }
-  fprintf(stderr,
-          "Setup...\n");
+  {
+    GNUNET_GC_free (cfg);
+    return -1;
+  }
+  fprintf (stderr, "Setup...\n");
 #if START_DAEMON
   GNUNET_disk_directory_remove (NULL,
                                 "/tmp/gnunet-fsui-recursive_download_test/");
   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,
-                                         30 * GNUNET_CRON_SECONDS));
+         GNUNET_wait_for_daemon_running (NULL, cfg, 30 * GNUNET_CRON_SECONDS));
   GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);        /* give apps time to start */
   /* ACTUAL TEST CODE */
 #endif
@@ -298,10 +294,9 @@ main (int argc, char *argv[])
   fn = makeHierarchy (42, DIRECTORY_TREE_SPEC);
   meta = GNUNET_meta_data_create ();
   kuri =
-    GNUNET_ECRS_keyword_command_line_to_uri (ectx, 2,
-                                             (const char **) keywords);
-  fprintf(stderr,
-          "Uploading...\n");
+      GNUNET_ECRS_keyword_command_line_to_uri (ectx, 2,
+                                               (const char **) keywords);
+  fprintf (stderr, "Uploading...\n");
   waitForEvent = GNUNET_FSUI_upload_completed;
   upload = GNUNET_FSUI_upload_start (ctx,
                                      fn,
@@ -315,19 +310,18 @@ main (int argc, char *argv[])
   kuri = NULL;
   prog = 0;
   while (lastEvent != GNUNET_FSUI_upload_completed)
-    {
-      prog++;
-      CHECK (prog < 5000);
-      GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
-      if (GNUNET_shutdown_test () == GNUNET_YES)
-        break;
-    }
+  {
+    prog++;
+    CHECK (prog < 5000);
+    GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+    if (GNUNET_shutdown_test () == GNUNET_YES)
+      break;
+  }
   GNUNET_FSUI_upload_stop (upload);
   upload = NULL;
   CHECK (upURI != NULL);
 
-  fprintf(stderr,
-          "Downloading...\n");
+  fprintf (stderr, "Downloading...\n");
   waitForEvent = GNUNET_FSUI_download_completed;
   fn43 = makeName (43);
   download = GNUNET_FSUI_download_start (ctx,
@@ -339,29 +333,28 @@ main (int argc, char *argv[])
   fn43 = NULL;
   prog = 0;
   while (!download_done)
-    {
-      prog++;
-      CHECK (prog < 5000);
-      GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
-      if (GNUNET_shutdown_test () == GNUNET_YES)
-        break;
-    }
+  {
+    prog++;
+    CHECK (prog < 5000);
+    GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+    if (GNUNET_shutdown_test () == GNUNET_YES)
+      break;
+  }
 FAILURE:
-  fprintf(stderr,
-          "Cleanup...\n");
+  fprintf (stderr, "Cleanup...\n");
   if (meta != NULL)
     GNUNET_meta_data_destroy (meta);
   if (ctx != NULL)
-    {
-      if (download != NULL)
-        GNUNET_FSUI_download_stop (download);
-      GNUNET_FSUI_stop (ctx);
-    }
+  {
+    if (download != NULL)
+      GNUNET_FSUI_download_stop (download);
+    GNUNET_FSUI_stop (ctx);
+  }
   if (fn != NULL)
-    {
-      GNUNET_disk_directory_remove (NULL, fn);
-      GNUNET_free (fn);
-    }
+  {
+    GNUNET_disk_directory_remove (NULL, fn);
+    GNUNET_free (fn);
+  }
   if (kuri != NULL)
     GNUNET_ECRS_uri_destroy (kuri);
   fn43 = makeName (43);
diff --git a/src/fs/test_fs_file_information.c b/src/fs/test_fs_file_information.c
index 00e3c2211..97a63062e 100644
--- a/src/fs/test_fs_file_information.c
+++ b/src/fs/test_fs_file_information.c
@@ -45,19 +45,17 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #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;
 }
@@ -66,8 +64,7 @@ mycleaner(void *cls,
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -86,17 +83,17 @@ run (void *cls,
   struct GNUNET_FS_BlockOptions bo;
 
   fs = GNUNET_FS_start (cfg, "test-fs-file-information", NULL, NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
+                        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_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");
@@ -104,48 +101,41 @@ run (void *cls,
   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_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); 
+  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);
+                                                     "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);
+                                                     "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);
+                                                             "file_information-context-dir",
+                                                             kuri, meta, &bo);
   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_FS_file_information_destroy (fidir, &mycleaner, NULL);
   GNUNET_DISK_directory_remove (fn1);
   GNUNET_DISK_directory_remove (fn2);
   GNUNET_free_non_null (fn1);
@@ -164,45 +154,47 @@ testThumbnail ()
   size_t size;
   char *date;
 
-  ex = EXTRACTOR_plugin_add_config (NULL, "thumbnailgtk", EXTRACTOR_OPTION_DEFAULT_POLICY);
+  ex = EXTRACTOR_plugin_add_config (NULL, "thumbnailgtk",
+                                    EXTRACTOR_OPTION_DEFAULT_POLICY);
   if (ex == NULL)
-    {
-      fprintf (stderr,
-               "Test incomplete, have no GTK thumbnail extractor available.\n");
-      return 0;                 /* can not test, no thumbnailer */
-    }
-  ex = EXTRACTOR_plugin_add_config (ex, "mime", EXTRACTOR_OPTION_DEFAULT_POLICY);
+  {
+    fprintf (stderr,
+             "Test incomplete, have no GTK thumbnail extractor available.\n");
+    return 0;                   /* can not test, no thumbnailer */
+  }
+  ex = EXTRACTOR_plugin_add_config (ex, "mime",
+                                    EXTRACTOR_OPTION_DEFAULT_POLICY);
   m = GNUNET_CONTAINER_meta_data_create ();
   if (3 != GNUNET_FS_meta_data_extract_from_file (m,
-                                                  "test_fs_file_information_meta_data_image.jpg",
-                                                  ex))
-    {
-      GNUNET_break (0);
-      EXTRACTOR_plugin_remove_all (ex);
-      GNUNET_CONTAINER_meta_data_destroy (m);
-      return 1;
-    }
+                                                  "test_fs_file_information_meta_data_image.jpg",
+                                                  ex))
+  {
+    GNUNET_break (0);
+    EXTRACTOR_plugin_remove_all (ex);
+    GNUNET_CONTAINER_meta_data_destroy (m);
+    return 1;
+  }
   EXTRACTOR_plugin_remove_all (ex);
   d = GNUNET_CONTAINER_meta_data_duplicate (m);
   GNUNET_CONTAINER_meta_data_destroy (m);
   thumb = NULL;
   size = GNUNET_CONTAINER_meta_data_get_thumbnail (d, &thumb);
   if (size == 0)
-    {
-      GNUNET_break (0);
-      GNUNET_CONTAINER_meta_data_destroy (d);
-      return 1;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_CONTAINER_meta_data_destroy (d);
+    return 1;
+  }
   GNUNET_free (thumb);
   GNUNET_CONTAINER_meta_data_add_publication_date (d);
   date = GNUNET_CONTAINER_meta_data_get_by_type (d,
                                                  EXTRACTOR_METATYPE_PUBLICATION_DATE);
   if (date == NULL)
-    {
-      GNUNET_break (0);
-      GNUNET_CONTAINER_meta_data_destroy (d);
-      return 1;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_CONTAINER_meta_data_destroy (d);
+    return 1;
+  }
   GNUNET_free (date);
   GNUNET_CONTAINER_meta_data_destroy (d);
   return 0;
@@ -213,7 +205,7 @@ testThumbnail ()
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-file_information",
     "-c",
     "test_fs_file_information_data.conf",
@@ -226,18 +218,18 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_file_information", 
+  GNUNET_log_setup ("test_fs_file_information",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   if (0 != testThumbnail ())
     return 1;
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-file_information",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   return 0;
 }
 
diff --git a/src/fs/test_fs_getopt.c b/src/fs/test_fs_getopt.c
index e52984877..2b0a9fca8 100644
--- a/src/fs/test_fs_getopt.c
+++ b/src/fs/test_fs_getopt.c
@@ -28,13 +28,13 @@
 int
 main (int argc, char *argv[])
 {
-  GNUNET_log_setup ("test_fs_directory", 
+  GNUNET_log_setup ("test_fs_directory",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   fprintf (stderr, "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 b46ebf52d..e3330f3ba 100644
--- a/src/fs/test_fs_list_indexed.c
+++ b/src/fs/test_fs_list_indexed.c
@@ -49,7 +49,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -75,8 +75,7 @@ static char *fn2;
 static int err;
 
 static void
-abort_publish_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -90,101 +89,96 @@ abort_publish_task (void *cls,
 
 
 static void
-list_indexed_task (void *cls,
-                   const struct GNUNET_SCHEDULER_TaskContext *tc)
+list_indexed_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
   GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
-                                     NULL,
-                                     GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+                                     NULL, GNUNET_SCHEDULER_REASON_PREREQ_DONE);
 }
 
 
 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 * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
-      if (0 == strcmp ("list_indexed-context-dir", 
-                       event->value.publish.cctx))      
-        GNUNET_SCHEDULER_add_continuation (&list_indexed_task,
-                                           NULL,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-        
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      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 * 1000 /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024));
+    if (0 == strcmp ("list_indexed-context-dir", event->value.publish.cctx))
+      GNUNET_SCHEDULER_add_continuation (&list_indexed_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    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_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_continuation (&abort_publish_task,
-                                           NULL,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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;
+    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_continuation (&abort_publish_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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;
+  }
   return ret;
 }
 
@@ -195,11 +189,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -210,16 +204,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -228,8 +223,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -246,21 +240,20 @@ run (void *cls,
 
   setup_peer (&p1, "test_fs_list_indexed_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-list_indexed",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "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_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");
@@ -268,10 +261,11 @@ run (void *cls,
   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_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 ();
@@ -279,30 +273,24 @@ run (void *cls,
   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);
+                                                     "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);
+                                                     "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);
+                                                             "list_indexed-context-dir",
+                                                             kuri, meta, &bo);
   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);
@@ -310,9 +298,9 @@ run (void *cls,
   GNUNET_assert (NULL != fidir);
   start = GNUNET_TIME_absolute_get ();
   publish = GNUNET_FS_publish_start (fs,
-                                     fidir,
-                                     NULL, NULL, NULL,
-                                     GNUNET_FS_PUBLISH_OPTION_NONE);
+                                     fidir,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -320,7 +308,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-list_indexed",
     "-c",
     "test_fs_list_indexed_data.conf",
@@ -333,28 +321,28 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_list_indexed", 
+  GNUNET_log_setup ("test_fs_list_indexed",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-list_indexed",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-list-indexed/");
   if (fn1 != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn1);
-      GNUNET_free (fn1);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn1);
+    GNUNET_free (fn1);
+  }
   if (fn2 != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn2);
-      GNUNET_free (fn2);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn2);
+    GNUNET_free (fn2);
+  }
   return err;
 }
 
diff --git a/src/fs/test_fs_namespace.c b/src/fs/test_fs_namespace.c
index b4d487ddc..96caa8dfa 100644
--- a/src/fs/test_fs_namespace.c
+++ b/src/fs/test_fs_namespace.c
@@ -67,11 +67,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -82,68 +82,64 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
 
 
 static void
-abort_ksk_search_task (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_ksk_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   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 (GNUNET_SCHEDULER_NO_TASK  != kill_task)
-            GNUNET_SCHEDULER_cancel (kill_task);
-        }
+      GNUNET_FS_stop (fs);
+      if (GNUNET_SCHEDULER_NO_TASK != kill_task)
+        GNUNET_SCHEDULER_cancel (kill_task);
     }
+  }
 }
 
 
 static void
-abort_sks_search_task (void *cls,
-                       const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_sks_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_Namespace *ns;
 
   if (sks_search == NULL)
     return;
-  GNUNET_FS_search_stop (sks_search); 
+  GNUNET_FS_search_stop (sks_search);
   sks_search = NULL;
-  ns = GNUNET_FS_namespace_create (fs,
-                                   "testNamespace");
+  ns = GNUNET_FS_namespace_create (fs, "testNamespace");
   GNUNET_assert (NULL != ns);
   GNUNET_assert (GNUNET_OK == GNUNET_FS_namespace_delete (ns, GNUNET_YES));
   if (ksk_search == NULL)
-    {
-      GNUNET_FS_stop (fs);
-      if (GNUNET_SCHEDULER_NO_TASK  != kill_task)
-        GNUNET_SCHEDULER_cancel (kill_task);
-    }    
+  {
+    GNUNET_FS_stop (fs);
+    if (GNUNET_SCHEDULER_NO_TASK != kill_task)
+      GNUNET_SCHEDULER_cancel (kill_task);
+  }
 }
 
 
 static void
-do_timeout (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  fprintf (stderr,
-           "Operation timed out\n");
+  fprintf (stderr, "Operation timed out\n");
   kill_task = GNUNET_SCHEDULER_NO_TASK;
   abort_sks_search_task (NULL, tc);
   abort_ksk_search_task (NULL, tc);
@@ -152,134 +148,121 @@ do_timeout (void *cls,
 
 
 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)
+    {
+      if (!GNUNET_FS_uri_test_equal (sks_expect_uri,
+                                     event->value.search.specifics.result.uri))
+      {
+        fprintf (stderr, "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)
     {
-    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,
-                       "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,
-                       "Wrong result for ksk search!\n");
-              err = 1;
-            }
-          GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
-                                             NULL,
-                                             GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-        }
-      else 
-        {
-          fprintf (stderr,
-                   "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_continuation (&abort_sks_search_task,
-                                           NULL,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      else if (ksk_search == event->value.search.sc)
-        GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
-                                           NULL,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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 (ksk_expect_uri,
+                                     event->value.search.specifics.result.uri))
+      {
+        fprintf (stderr, "Wrong result for ksk search!\n");
+        err = 1;
+      }
+      GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
     }
+    else
+    {
+      fprintf (stderr, "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_continuation (&abort_sks_search_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    else if (ksk_search == event->value.search.sc)
+      GNUNET_SCHEDULER_add_continuation (&abort_ksk_search_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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;
   char sbuf[1024];
   struct GNUNET_CRYPTO_HashAsciiEncoded enc;
-  
+
   if (NULL != emsg)
-    {
-      fprintf (stderr, "Error publishing: %s\n", emsg);
-      err = 1;
-      GNUNET_FS_stop (fs);
-      return;
-    }  
-  GNUNET_CRYPTO_hash_to_enc (&nsid,
-                             &enc);
-  GNUNET_snprintf (sbuf,
-                   sizeof (sbuf),
-                   "gnunet://fs/sks/%s/this",
-                   &enc);
+  {
+    fprintf (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  GNUNET_CRYPTO_hash_to_enc (&nsid, &enc);
+  GNUNET_snprintf (sbuf, sizeof (sbuf), "gnunet://fs/sks/%s/this", &enc);
   sks_uri = GNUNET_FS_uri_parse (sbuf, &msg);
   if (msg != NULL)
-    {
-      fprintf (stderr, "failed to parse URI `%s': %s\n",
-               sbuf,
-               msg);
-      err = 1;
-      GNUNET_FS_stop (fs);
-      GNUNET_free (msg);
-      return;
-    }
-  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");
+  {
+    fprintf (stderr, "failed to parse URI `%s': %s\n", sbuf, msg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    GNUNET_free (msg);
+    return;
+  }
+  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);
 }
 
 
 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;
-  char * msg;
+  char *msg;
   struct GNUNET_FS_BlockOptions bo;
 
   meta = GNUNET_CONTAINER_meta_data_create ();
@@ -290,38 +273,30 @@ sks_cont (void *cls,
   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);
+  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);
 }
 
 
 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_FS_Namespace *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_FS_namespace_create (fs,
-                                   "testNamespace");
+  {
+    fprintf (stderr, "Error publishing: %s\n", emsg);
+    err = 1;
+    GNUNET_FS_stop (fs);
+    return;
+  }
+  ns = GNUNET_FS_namespace_create (fs, "testNamespace");
   GNUNET_assert (NULL != ns);
   meta = GNUNET_CONTAINER_meta_data_create ();
   GNUNET_assert (NULL == emsg);
@@ -329,31 +304,21 @@ adv_cont (void *cls,
   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_sks (fs,
-                         ns,
-                         "this",
-                         "next",
-                         meta,
-                         uri, /* FIXME: this is non-sense (use CHK URI!?) */
-                         &bo,
-                         GNUNET_FS_PUBLISH_OPTION_NONE,
-                         &sks_cont,
-                         NULL);
+  bo.expiration_time =
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  GNUNET_FS_publish_sks (fs, ns, "this", "next", meta, uri,     /* FIXME: this is non-sense (use CHK URI!?) */
+                         &bo, GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont, NULL);
   GNUNET_CONTAINER_meta_data_destroy (meta);
   GNUNET_FS_namespace_delete (ns, GNUNET_NO);
 }
 
 
 static void
-ns_iterator (void *cls,
-             const char *name,
-             const GNUNET_HashCode *id)
+ns_iterator (void *cls, const char *name, const GNUNET_HashCode * id)
 {
   int *ok = cls;
 
-  if (0 != strcmp (name,
-                   "testNamespace"))
+  if (0 != strcmp (name, "testNamespace"))
     return;
   *ok = GNUNET_YES;
   nsid = *id;
@@ -369,35 +334,30 @@ testNamespace ()
   struct GNUNET_FS_Uri *ksk_uri;
   int ok;
 
-  ns = GNUNET_FS_namespace_create (fs,
-                                   "testNamespace");
+  ns = GNUNET_FS_namespace_create (fs, "testNamespace");
   GNUNET_assert (NULL != ns);
   ok = GNUNET_NO;
   GNUNET_FS_namespace_list (fs, &ns_iterator, &ok);
   if (GNUNET_NO == ok)
-    {
-      fprintf (stderr, "namespace_list failed to find namespace!\n");
-      GNUNET_FS_namespace_delete (ns, GNUNET_YES);
-      GNUNET_FS_stop (fs);
-      err = 1;
-      return;
-    }
+  {
+    fprintf (stderr, "namespace_list failed to find namespace!\n");
+    GNUNET_FS_namespace_delete (ns, GNUNET_YES);
+    GNUNET_FS_stop (fs);
+    err = 1;
+    return;
+  }
   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);
-  GNUNET_FS_namespace_advertise (fs,
-                                 ksk_uri,
-                                 ns,
-                                 meta,
-                                 &bo,
-                                 "root",
-                                 &adv_cont, NULL);
-  kill_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES,
-                                            &do_timeout,
-                                            NULL);
+  bo.expiration_time =
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
+  GNUNET_FS_namespace_advertise (fs, ksk_uri, ns, meta, &bo, "root", &adv_cont,
+                                 NULL);
+  kill_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MINUTES, &do_timeout,
+                                    NULL);
   GNUNET_FS_uri_destroy (ksk_uri);
   GNUNET_FS_namespace_delete (ns, GNUNET_NO);
   GNUNET_CONTAINER_meta_data_destroy (meta);
@@ -407,16 +367,13 @@ testNamespace ()
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   setup_peer (&p1, "test_fs_namespace_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-namespace",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
+                        "test-fs-namespace",
+                        &progress_cb,
+                        NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
   testNamespace ();
 }
 
@@ -424,7 +381,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-namespace",
     "-c",
     "test_fs_namespace_data.conf",
@@ -437,23 +394,22 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_namespace", 
+  GNUNET_log_setup ("test_fs_namespace",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-namespace",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   stop_arm (&p1);
   if (GNUNET_YES != update_started)
-    {
-      fprintf (stderr,
-               "Update search never started!\n");
-      err = 1;
-    }
+  {
+    fprintf (stderr, "Update search never started!\n");
+    err = 1;
+  }
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/");
   return err;
 }
diff --git a/src/fs/test_fs_namespace_list_updateable.c b/src/fs/test_fs_namespace_list_updateable.c
index 291ab6d9d..dc8673e21 100644
--- a/src/fs/test_fs_namespace_list_updateable.c
+++ b/src/fs/test_fs_namespace_list_updateable.c
@@ -59,8 +59,7 @@ struct PeerContext
 
 
 static void *
-progress_cb (void *cls, 
-             const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   return NULL;
 }
@@ -72,11 +71,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -87,16 +86,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   if (uri_this != NULL)
     GNUNET_FS_uri_destroy (uri_this);
@@ -113,10 +113,10 @@ stop_arm (struct PeerContext *p)
 
 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)
+            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"));
@@ -126,43 +126,35 @@ check_next (void *cls,
 
 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)
+                 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"));
   err -= 2;
   err += 4;
-  GNUNET_FS_namespace_list_updateable (ns,
-                                       next_id,
-                                       &check_next,
-                                       NULL);
+  GNUNET_FS_namespace_list_updateable (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);
   err += 2;
-  GNUNET_FS_namespace_list_updateable (ns,
-                                       NULL,
-                                       &check_this_next,
-                                       NULL);
+  GNUNET_FS_namespace_list_updateable (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)
+            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"));
@@ -171,27 +163,20 @@ check_this (void *cls,
 
 
 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);
   err = 1;
-  GNUNET_FS_namespace_list_updateable (ns,
-                                       NULL,
-                                       &check_this,
-                                       NULL);
+  GNUNET_FS_namespace_list_updateable (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);
+                         ns,
+                         "next",
+                         "future",
+                         meta,
+                         uri_next,
+                         &bo,
+                         GNUNET_FS_PUBLISH_OPTION_NONE, &sks_cont_next, NULL);
 
 }
 
@@ -201,45 +186,38 @@ static void
 testNamespace ()
 {
 
-  ns = GNUNET_FS_namespace_create (fs,
-                                   "testNamespace");
+  ns = GNUNET_FS_namespace_create (fs, "testNamespace");
   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);
+  bo.expiration_time =
+      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", NULL);
+      GNUNET_FS_uri_parse
+      ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42",
+       NULL);
   uri_next =
-    GNUNET_FS_uri_parse ("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_uri_parse
+      ("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);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   setup_peer (&p1, "test_fs_namespace_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-namespace",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
+                        "test-fs-namespace",
+                        &progress_cb,
+                        NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
   testNamespace ();
 }
 
@@ -247,7 +225,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-namespace",
     "-c",
     "test_fs_namespace_data.conf",
@@ -260,16 +238,16 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_namespace_list_updateable", 
+  GNUNET_log_setup ("test_fs_namespace_list_updateable",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-namespace",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-namespace/");
   return err;
diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c
index dcce43cdf..d53b5b0ae 100644
--- a/src/fs/test_fs_publish.c
+++ b/src/fs/test_fs_publish.c
@@ -46,7 +46,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -72,8 +72,7 @@ static char *fn2;
 static int err;
 
 static void
-abort_publish_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -87,90 +86,86 @@ abort_publish_task (void *cls,
 
 
 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 * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
-      if (0 == strcmp ("publish-context-dir", 
-                       event->value.publish.cctx))      
-        GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
-                                           NULL,
-                                           GNUNET_SCHEDULER_REASON_PREREQ_DONE);        
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      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 * 1000 /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024));
+    if (0 == strcmp ("publish-context-dir", event->value.publish.cctx))
+      GNUNET_SCHEDULER_add_continuation (&abort_publish_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    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_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_continuation (&abort_publish_task,
-                                             NULL,
-                                             GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-        }
-      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;
+    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_continuation (&abort_publish_task,
+                                         NULL,
+                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    }
+    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;
 }
 
@@ -181,11 +176,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -196,16 +191,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -214,8 +210,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -232,21 +227,20 @@ run (void *cls,
 
   setup_peer (&p1, "test_fs_publish_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-publish",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "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_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");
@@ -254,10 +248,11 @@ run (void *cls,
   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_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 ();
@@ -268,29 +263,23 @@ run (void *cls,
   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);
-                                                     
+                                                     "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);
+                                                     "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);
+                                                             "publish-context-dir",
+                                                             kuri, meta, &bo);
   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);
@@ -298,9 +287,9 @@ run (void *cls,
   GNUNET_assert (NULL != fidir);
   start = GNUNET_TIME_absolute_get ();
   publish = GNUNET_FS_publish_start (fs,
-                                     fidir,
-                                     NULL, NULL, NULL,
-                                     GNUNET_FS_PUBLISH_OPTION_NONE);
+                                     fidir,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -308,7 +297,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-publish",
     "-c",
     "test_fs_publish_data.conf",
@@ -321,28 +310,27 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_publish", 
+  GNUNET_log_setup ("test_fs_publish",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-publish",
-                      "nohelp", options, &run, NULL);
+                      argvx, "test-fs-publish", "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-publish/");
   if (fn1 != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn1);
-      GNUNET_free (fn1);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn1);
+    GNUNET_free (fn1);
+  }
   if (fn2 != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn2);
-      GNUNET_free (fn2);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn2);
+    GNUNET_free (fn2);
+  }
   return err;
 }
 
diff --git a/src/fs/test_fs_publish_persistence.c b/src/fs/test_fs_publish_persistence.c
index 2d8332602..4dcf10965 100644
--- a/src/fs/test_fs_publish_persistence.c
+++ b/src/fs/test_fs_publish_persistence.c
@@ -45,7 +45,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -77,8 +77,7 @@ static int err;
 static GNUNET_SCHEDULER_TaskIdentifier rtask;
 
 static void
-abort_publish_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -91,30 +90,27 @@ abort_publish_task (void *cls,
   GNUNET_FS_stop (fs);
   fs = NULL;
   if (GNUNET_SCHEDULER_NO_TASK != rtask)
-    {
-      GNUNET_SCHEDULER_cancel (rtask);
-      rtask = GNUNET_SCHEDULER_NO_TASK;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (rtask);
+    rtask = GNUNET_SCHEDULER_NO_TASK;
+  }
 }
 
 
-static void *
-progress_cb (void *cls, 
-             const struct GNUNET_FS_ProgressInfo *event);
+static void *progress_cb (void *cls,
+                          const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   rtask = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_FS_stop (fs);
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-publish-persistence",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_PERSISTENCE,
-                        GNUNET_FS_OPTIONS_END);
+                        "test-fs-publish-persistence",
+                        &progress_cb,
+                        NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -131,111 +127,108 @@ consider_restart (int ev)
   static int prev[32];
   static int off;
   int i;
-  for (i=0;i<off;i++)
+
+  for (i = 0; i < off; i++)
     if (prev[i] == ev)
       return;
   prev[off++] = ev;
   rtask = GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                              &restart_fs_task,
-                                              NULL);
+                                              &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:
-      consider_restart (event->status);
-      ret = event->value.publish.cctx;
-      printf ("Publish complete,  %llu kbps.\n",
-              (unsigned long long) (FILESIZE * 1000LL / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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:
-      consider_restart (event->status);
-      ret = event->value.publish.cctx;
-      GNUNET_assert (publish == event->value.publish.pc);
+  {
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    consider_restart (event->status);
+    ret = event->value.publish.cctx;
+    printf ("Publish complete,  %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000LL /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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:
+    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 (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 (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;
 }
 
@@ -246,11 +239,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -261,16 +254,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -279,8 +273,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   const char *keywords[] = {
     "down_foo",
@@ -298,21 +291,21 @@ run (void *cls,
   cfg = c;
   setup_peer (&p1, "test_fs_publish_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-publish-persistence",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_PERSISTENCE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "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_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");
@@ -320,10 +313,11 @@ run (void *cls,
   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_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 ();
@@ -331,30 +325,24 @@ run (void *cls,
   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);
+                                                     "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);
+                                                     "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);
+                                                             "publish-context-dir",
+                                                             kuri, meta, &bo);
   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);
@@ -362,9 +350,8 @@ run (void *cls,
   GNUNET_assert (NULL != fidir);
   start = GNUNET_TIME_absolute_get ();
   GNUNET_FS_publish_start (fs,
-                           fidir,
-                           NULL, NULL, NULL,
-                           GNUNET_FS_PUBLISH_OPTION_NONE);
+                           fidir,
+                           NULL, NULL, NULL, GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -372,7 +359,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-publish-persistence",
     "-c",
     "test_fs_publish_data.conf",
@@ -385,28 +372,27 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_publish_persistence", 
+  GNUNET_log_setup ("test_fs_publish_persistence",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-publish",
-                      "nohelp", options, &run, NULL);
+                      argvx, "test-fs-publish", "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-publish/");
   if (fn1 != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn1);
-      GNUNET_free (fn1);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn1);
+    GNUNET_free (fn1);
+  }
   if (fn2 != NULL)
-    {
-      GNUNET_DISK_directory_remove (fn2);
-      GNUNET_free (fn2);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn2);
+    GNUNET_free (fn2);
+  }
   return err;
 }
 
diff --git a/src/fs/test_fs_search.c b/src/fs/test_fs_search.c
index a1f3208ef..878624c73 100644
--- a/src/fs/test_fs_search.c
+++ b/src/fs/test_fs_search.c
@@ -45,13 +45,13 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
-  struct GNUNET_PeerIdentity id;   
+  struct GNUNET_PeerIdentity id;
 #if START_ARM
   struct GNUNET_OS_Process *arm_proc;
 #endif
@@ -69,8 +69,7 @@ static struct GNUNET_FS_PublishContext *publish;
 
 
 static void
-abort_publish_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -78,8 +77,7 @@ abort_publish_task (void *cls,
 
 
 static void
-abort_search_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (search != NULL)
     GNUNET_FS_search_stop (search);
@@ -88,94 +86,90 @@ abort_search_task (void *cls,
 
 
 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"
   };
   struct GNUNET_FS_Uri *kuri;
 
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 #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);
-#endif      
-      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:
+    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_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:
 #if VERBOSE
-      printf ("Search complete.\n");
+    printf ("Search complete.\n");
 #endif
-      GNUNET_SCHEDULER_add_continuation (&abort_search_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf (stderr,
-               "Error searching file: %s\n",
-               event->value.search.specifics.error.message);
-      GNUNET_SCHEDULER_add_continuation (&abort_search_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    default:
-      fprintf (stderr,
-               "Unexpected event: %d\n", 
-               event->status);
-      break;
-    }
+    GNUNET_SCHEDULER_add_continuation (&abort_search_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr,
+             "Error searching file: %s\n",
+             event->value.search.specifics.error.message);
+    GNUNET_SCHEDULER_add_continuation (&abort_search_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    fprintf (stderr, "Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
@@ -186,11 +180,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -201,16 +195,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -219,8 +214,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -235,12 +229,10 @@ run (void *cls,
 
   setup_peer (&p1, "test_fs_search_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-search",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "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);
@@ -251,21 +243,18 @@ run (void *cls,
   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);
+                                                    "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);
+                                     fi,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -273,7 +262,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-search",
     "-c",
     "test_fs_search_data.conf",
@@ -286,16 +275,15 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_search", 
+  GNUNET_log_setup ("test_fs_search",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-search",
-                      "nohelp", options, &run, NULL);
+                      argvx, "test-fs-search", "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-search/");
   return 0;
diff --git a/src/fs/test_fs_search_persistence.c b/src/fs/test_fs_search_persistence.c
index 47d177a81..eceb4d1d5 100644
--- a/src/fs/test_fs_search_persistence.c
+++ b/src/fs/test_fs_search_persistence.c
@@ -45,13 +45,13 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
 {
   struct GNUNET_CONFIGURATION_Handle *cfg;
-  struct GNUNET_PeerIdentity id;   
+  struct GNUNET_PeerIdentity id;
 #if START_ARM
   struct GNUNET_OS_Process *arm_proc;
 #endif
@@ -70,8 +70,7 @@ static struct GNUNET_FS_PublishContext *publish;
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 static void
-abort_publish_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -79,8 +78,7 @@ abort_publish_task (void *cls,
 
 
 static void
-abort_search_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_search_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (search != NULL)
     GNUNET_FS_search_stop (search);
@@ -88,22 +86,19 @@ abort_search_task (void *cls,
 }
 
 
-static void *
-progress_cb (void *cls, 
-             const struct GNUNET_FS_ProgressInfo *event);
+static void *progress_cb (void *cls,
+                          const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_stop (fs);
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-search-persistence",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_PERSISTENCE,
-                        GNUNET_FS_OPTIONS_END);
+                        "test-fs-search-persistence",
+                        &progress_cb,
+                        NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -122,129 +117,124 @@ consider_restart (int ev)
   static int prev[32];
   static int off;
   int i;
-  for (i=0;i<off;i++)
+
+  for (i = 0; i < off; i++)
     if (prev[i] == ev)
       return;
   prev[off++] = ev;
   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                      &restart_fs_task,
-                                      NULL);
+                                      &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"
   };
   struct GNUNET_FS_Uri *kuri;
 
   switch (event->status)
-    {
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 #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);
-#endif      
-      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... */
+    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_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... */
 #if VERBOSE
-      printf ("Search complete.\n");
+    printf ("Search complete.\n");
 #endif
-      GNUNET_SCHEDULER_add_continuation (&abort_search_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_SEARCH_ERROR:
-      fprintf (stderr,
-               "Error searching file: %s\n",
-               event->value.search.specifics.error.message);
-      GNUNET_SCHEDULER_add_continuation (&abort_search_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    GNUNET_SCHEDULER_add_continuation (&abort_search_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_SEARCH_ERROR:
+    fprintf (stderr,
+             "Error searching file: %s\n",
+             event->value.search.specifics.error.message);
+    GNUNET_SCHEDULER_add_continuation (&abort_search_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_SEARCH_SUSPEND:
+    if (event->value.search.sc == search)
       search = NULL;
-      break;
-    default:
-      fprintf (stderr,
-               "Unexpected event: %d\n", 
-               event->status);
-      break;
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    search = NULL;
+    break;
+  default:
+    fprintf (stderr, "Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
@@ -255,11 +245,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -270,16 +260,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -288,8 +279,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   const char *keywords[] = {
     "down_foo",
@@ -305,12 +295,11 @@ run (void *cls,
   cfg = c;
   setup_peer (&p1, "test_fs_search_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-search-persistence",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_PERSISTENCE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "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);
@@ -321,21 +310,18 @@ run (void *cls,
   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);
+                                                    "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);
+                                     fi,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -343,7 +329,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-search-persistence",
     "-c",
     "test_fs_search_data.conf",
@@ -357,16 +343,16 @@ main (int argc, char *argv[])
   };
 
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-search/");
-  GNUNET_log_setup ("test_fs_search_persistence", 
+  GNUNET_log_setup ("test_fs_search_persistence",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-search-persistence",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-search/");
   return 0;
diff --git a/src/fs/test_fs_search_ranking.c b/src/fs/test_fs_search_ranking.c
index 06c37dfc2..b19ff97bf 100644
--- a/src/fs/test_fs_search_ranking.c
+++ b/src/fs/test_fs_search_ranking.c
@@ -37,8 +37,7 @@ makeName (unsigned int i)
 {
   char *fn;
 
-  fn =
-    GNUNET_malloc (strlen ("/tmp/gnunet-fsui-searchranktest/FSUITEST") + 14);
+  fn = GNUNET_malloc (strlen ("/tmp/gnunet-fsui-searchranktest/FSUITEST") + 14);
   GNUNET_snprintf (fn,
                    strlen ("/tmp/gnunet-fsui-searchranktest/FSUITEST") + 14,
                    "/tmp/gnunet-fsui-searchranktest/FSUITEST%u", i);
@@ -64,57 +63,57 @@ eventCallback (void *cls, const GNUNET_FSUI_Event * event)
   static char unused;
 
   switch (event->type)
-    {
-    case GNUNET_FSUI_search_resumed:
-      search = event->data.SearchResumed.sc.pos;
-      break;
-    case GNUNET_FSUI_search_suspended:
-      search = NULL;
-      break;
-    case GNUNET_FSUI_search_update:
-      availability = event->data.SearchUpdate.availability_rank;
-      rank = event->data.SearchUpdate.applicability_rank;
-      break;
-    case GNUNET_FSUI_search_paused:
-    case GNUNET_FSUI_search_restarted:
-      break;
-    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:
+    search = event->data.SearchResumed.sc.pos;
+    break;
+  case GNUNET_FSUI_search_suspended:
+    search = NULL;
+    break;
+  case GNUNET_FSUI_search_update:
+    availability = event->data.SearchUpdate.availability_rank;
+    rank = event->data.SearchUpdate.applicability_rank;
+    break;
+  case GNUNET_FSUI_search_paused:
+  case GNUNET_FSUI_search_restarted:
+    break;
+  case GNUNET_FSUI_download_resumed:
+  case GNUNET_FSUI_upload_resumed:
+  case GNUNET_FSUI_unindex_resumed:
+    return &unused;
+  case GNUNET_FSUI_search_result:
 #if CHECK_VERBOSE
-      printf ("Received search result\n");
+    printf ("Received search result\n");
 #endif
-      uri = GNUNET_ECRS_uri_duplicate (event->data.SearchResult.fi.uri);
-      break;
-    case GNUNET_FSUI_upload_completed:
+    uri = GNUNET_ECRS_uri_duplicate (event->data.SearchResult.fi.uri);
+    break;
+  case GNUNET_FSUI_upload_completed:
 #if CHECK_VERBOSE
-      printf ("Upload complete.\n");
+    printf ("Upload complete.\n");
 #endif
-      break;
-    case GNUNET_FSUI_download_completed:
+    break;
+  case GNUNET_FSUI_download_completed:
 #if CHECK_VERBOSE
-      printf ("Download complete.\n");
+    printf ("Download complete.\n");
 #endif
-      break;
-    case GNUNET_FSUI_unindex_completed:
+    break;
+  case GNUNET_FSUI_unindex_completed:
 #if CHECK_VERBOSE
-      printf ("Unindex complete.\n");
+    printf ("Unindex complete.\n");
 #endif
-      break;
-    case GNUNET_FSUI_upload_error:
-      printf ("Upload error.\n");
-      break;
-    case GNUNET_FSUI_download_error:
-      printf ("Download error.\n");
-      break;
-    case GNUNET_FSUI_unindex_error:
-      printf ("Unindex error.\n");
-      break;
-    default:
-      break;
-    }
+    break;
+  case GNUNET_FSUI_upload_error:
+    printf ("Upload error.\n");
+    break;
+  case GNUNET_FSUI_download_error:
+    printf ("Download error.\n");
+    break;
+  case GNUNET_FSUI_unindex_error:
+    printf ("Unindex error.\n");
+    break;
+  default:
+    break;
+  }
   if (lastEvent != waitForEvent)
     lastEvent = event->type;
   return NULL;
@@ -130,6 +129,7 @@ main (int argc, char *argv[])
 #endif
   int ok;
   char *fn = NULL;
+
   char *keywords[] = {
     "search_foo",
     "search_bar",
@@ -146,17 +146,16 @@ main (int argc, char *argv[])
   ok = GNUNET_YES;
   cfg = GNUNET_GC_create ();
   if (-1 == GNUNET_GC_parse_configuration (cfg, "check.conf"))
-    {
-      GNUNET_GC_free (cfg);
-      return -1;
-    }
+  {
+    GNUNET_GC_free (cfg);
+    return -1;
+  }
 #if START_DAEMON
   GNUNET_disk_directory_remove (NULL, "/tmp/gnunet-fsui-searchranktest/");
   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,
-                                         30 * GNUNET_CRON_SECONDS));
+         GNUNET_wait_for_daemon_running (NULL, cfg, 30 * GNUNET_CRON_SECONDS));
   GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);        /* give apps time to start */
   /* ACTUAL TEST CODE */
 #endif
@@ -167,21 +166,20 @@ main (int argc, char *argv[])
   /* upload */
   fn = makeName (42);
   GNUNET_disk_file_write (NULL,
-                          fn, "foo bar test!", strlen ("foo bar test!"),
-                          "600");
+                          fn, "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);
   waitForEvent = GNUNET_FSUI_upload_completed;
   upload =
-    GNUNET_FSUI_upload_start (ctx,
-                              fn,
-                              (GNUNET_FSUI_DirectoryScanCallback) &
-                              GNUNET_disk_directory_scan, NULL, 0, 0,
-                              GNUNET_YES, GNUNET_NO, GNUNET_NO,
-                              GNUNET_get_time () + 5 * GNUNET_CRON_HOURS,
-                              meta, kuri, kuri);
+      GNUNET_FSUI_upload_start (ctx,
+                                fn,
+                                (GNUNET_FSUI_DirectoryScanCallback) &
+                                GNUNET_disk_directory_scan, NULL, 0, 0,
+                                GNUNET_YES, GNUNET_NO, GNUNET_NO,
+                                GNUNET_get_time () + 5 * GNUNET_CRON_HOURS,
+                                meta, kuri, kuri);
   CHECK (NULL != upload);
   GNUNET_free (fn);
   fn = NULL;
@@ -189,19 +187,18 @@ main (int argc, char *argv[])
   GNUNET_meta_data_destroy (meta);
   prog = 0;
   while (lastEvent != GNUNET_FSUI_upload_completed)
+  {
+    prog++;
+    if (prog == 10000)
     {
-      prog++;
-      if (prog == 10000)
-        {
-          fprintf (stderr,
-                   "Upload failed to complete -- last event: %u\n",
-                   lastEvent);
-        }
-      CHECK (prog < 10000);
-      GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
-      if (GNUNET_shutdown_test () == GNUNET_YES)
-        break;
+      fprintf (stderr,
+               "Upload failed to complete -- last event: %u\n", lastEvent);
     }
+    CHECK (prog < 10000);
+    GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+    if (GNUNET_shutdown_test () == GNUNET_YES)
+      break;
+  }
   GNUNET_FSUI_upload_stop (upload);
 
   /* search */
@@ -217,11 +214,11 @@ main (int argc, char *argv[])
   while ((uri == NULL) &&
          (availability < 3) &&
          (rank != 2) && (GNUNET_shutdown_test () != GNUNET_YES))
-    {
-      prog++;
-      CHECK (prog < 10000);
-      GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
-    }
+  {
+    prog++;
+    CHECK (prog < 10000);
+    GNUNET_thread_sleep (50 * GNUNET_CRON_MILLISECONDS);
+  }
   GNUNET_FSUI_search_abort (search);
   GNUNET_FSUI_search_stop (search);
   CHECK (uri != NULL);
diff --git a/src/fs/test_fs_start_stop.c b/src/fs/test_fs_start_stop.c
index 5080ecc18..e38a4b965 100644
--- a/src/fs/test_fs_start_stop.c
+++ b/src/fs/test_fs_start_stop.c
@@ -45,8 +45,7 @@ struct PeerContext
 
 
 static void *
-progress_cb (void *cls, 
-             const struct GNUNET_FS_ProgressInfo *event)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *event)
 {
   return NULL;
 }
@@ -58,11 +57,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -73,16 +72,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -91,19 +91,16 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_FS_Handle *fs;
 
   setup_peer (&p1, "test_fs_data.conf");
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-start-stop",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
-  GNUNET_assert (NULL != fs); 
+                        "test-fs-start-stop",
+                        &progress_cb,
+                        NULL, GNUNET_FS_FLAGS_NONE, GNUNET_FS_OPTIONS_END);
+  GNUNET_assert (NULL != fs);
   GNUNET_FS_stop (fs);
 }
 
@@ -111,7 +108,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-start-stop",
     "-c",
     "test_fs_data.conf",
@@ -124,16 +121,16 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_start_stop", 
+  GNUNET_log_setup ("test_fs_start_stop",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-fs-start-stop",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs/");
   return 0;
diff --git a/src/fs/test_fs_test_lib.c b/src/fs/test_fs_test_lib.c
index 3c6826181..9aa7b2ee3 100644
--- a/src/fs/test_fs_test_lib.c
+++ b/src/fs/test_fs_test_lib.c
@@ -47,112 +47,91 @@ static struct GNUNET_FS_TestDaemon *daemons[NUM_DAEMONS];
 static int ret;
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      GNUNET_break (0);
-      ret = 1;
-    }
+  {
+    GNUNET_break (0);
+    ret = 1;
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Finished download, shutting down\n",
-                  (unsigned long long) FILESIZE);
-    }
-  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                               daemons);
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished download, shutting down\n",
+                (unsigned long long) FILESIZE);
+  }
+  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
 }
 
 
 static void
-do_download (void *cls,
-             const struct GNUNET_FS_Uri *uri)
+do_download (void *cls, const struct GNUNET_FS_Uri *uri)
 {
   if (NULL == uri)
-    {
-      GNUNET_break (0);
-      GNUNET_SCHEDULER_add_now (&do_stop,
-                                NULL);
-      ret = 1;
-      return;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+    ret = 1;
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Downloading %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Downloading %llu bytes\n", (unsigned long long) FILESIZE);
   GNUNET_FS_TEST_download (daemons[0],
-                           TIMEOUT,
-                           1, SEED, uri, 
-                           VERBOSE, 
-                           &do_stop, NULL);
+                           TIMEOUT, 1, SEED, uri, VERBOSE, &do_stop, NULL);
 }
 
 
 static void
-do_publish (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      GNUNET_break (0);
-      ret = 1;
-      GNUNET_SCHEDULER_add_now (&do_stop,
-                                NULL);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    ret = 1;
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   GNUNET_FS_TEST_publish (daemons[0],
-                          TIMEOUT,
-                          1, GNUNET_NO, FILESIZE, SEED, 
-                          VERBOSE, 
-                          &do_download, NULL);
+                          TIMEOUT,
+                          1, GNUNET_NO, FILESIZE, SEED,
+                          VERBOSE, &do_download, NULL);
 }
 
 
 static void
-do_connect (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      GNUNET_break (0);
-      ret = 1;
-      GNUNET_SCHEDULER_add_now (&do_stop,
-                                NULL);
-      return;
-    }
+  {
+    GNUNET_break (0);
+    ret = 1;
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Daemons started, will now try to connect them\n");
+              "Daemons started, will now try to connect them\n");
   GNUNET_FS_TEST_daemons_connect (daemons[0],
-                                  daemons[1],
-                                  TIMEOUT,
-                                  &do_publish,
-                                  NULL);  
+                                  daemons[1], TIMEOUT, &do_publish, NULL);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
-                                TIMEOUT,
-                                NUM_DAEMONS,
-                                daemons,
-                                &do_connect,
-                                NULL);
+                                TIMEOUT,
+                                NUM_DAEMONS, daemons, &do_connect, NULL);
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-test-lib",
     "-c",
     "fs_test_lib_data.conf",
@@ -166,16 +145,15 @@ main (int argc, char *argv[])
   };
 
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
-  GNUNET_log_setup ("test_fs_test_lib", 
+  GNUNET_log_setup ("test_fs_test_lib",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-test-lib",
-                      "nohelp", options, &run, NULL);
+                      argvx, "test-fs-test-lib", "nohelp", options, &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 6774d0dfa..70a9e0bcf 100644
--- a/src/fs/test_fs_unindex.c
+++ b/src/fs/test_fs_unindex.c
@@ -45,7 +45,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -70,8 +70,7 @@ static char *fn;
 
 
 static void
-abort_publish_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -79,8 +78,7 @@ abort_publish_task (void *cls,
 
 
 static void
-abort_unindex_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_unindex_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_unindex_stop (unindex);
   unindex = NULL;
@@ -91,96 +89,99 @@ abort_unindex_task (void *cls,
 
 
 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:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 #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);
-#endif      
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf ("Publishing complete, %llu kbps.\n",
-              (unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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 * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
-      GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
-      GNUNET_assert (unindex == event->value.unindex.uc);
+    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_COMPLETED:
+    printf ("Publishing complete, %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000 /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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 * 1000 /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024));
+    GNUNET_SCHEDULER_add_continuation (&abort_unindex_task, NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    GNUNET_assert (unindex == event->value.unindex.uc);
 #if VERBOSE
-      printf ("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);
+    printf ("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);
 #endif
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_UNINDEX_ERROR:
-      fprintf (stderr,
-               "Error unindexing file: %s\n",
-               event->value.unindex.specifics.error.message);
-      GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    default:
-      printf ("Unexpected event: %d\n", 
-              event->status);
-      break;
-    }
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_UNINDEX_ERROR:
+    fprintf (stderr,
+             "Error unindexing file: %s\n",
+             event->value.unindex.specifics.error.message);
+    GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
@@ -191,11 +192,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -206,16 +207,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -224,8 +226,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   const char *keywords[] = {
     "down_foo",
@@ -241,20 +242,19 @@ run (void *cls,
   setup_peer (&p1, "test_fs_unindex_data.conf");
   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); 
+                        "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_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);
@@ -263,20 +263,18 @@ run (void *cls,
   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);
+                                                    "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);
+                                     fi,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -284,7 +282,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-unindex",
     "-c",
     "test_fs_unindex_data.conf",
@@ -297,23 +295,22 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_unindex", 
+  GNUNET_log_setup ("test_fs_unindex",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-unindex",
-                      "nohelp", options, &run, NULL);
+                      argvx, "test-fs-unindex", "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-unindex/");
   if (NULL != fn)
-    {
-      GNUNET_DISK_directory_remove (fn);
-      GNUNET_free (fn);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn);
+    GNUNET_free (fn);
+  }
   return 0;
 }
 
diff --git a/src/fs/test_fs_unindex_persistence.c b/src/fs/test_fs_unindex_persistence.c
index 095c6961f..191dec57d 100644
--- a/src/fs/test_fs_unindex_persistence.c
+++ b/src/fs/test_fs_unindex_persistence.c
@@ -44,7 +44,7 @@
 
 /**
  * How long should our test-content live?
- */ 
+ */
 #define LIFETIME GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 15)
 
 struct PeerContext
@@ -70,8 +70,7 @@ static char *fn;
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 static void
-abort_publish_task (void *cls,
-                     const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_publish_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_publish_stop (publish);
   publish = NULL;
@@ -79,39 +78,35 @@ abort_publish_task (void *cls,
 
 
 static void
-abort_unindex_task (void *cls,
-                    const struct GNUNET_SCHEDULER_TaskContext *tc)
+abort_unindex_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   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);
+static void *progress_cb (void *cls,
+                          const struct GNUNET_FS_ProgressInfo *event);
 
 
 static void
-restart_fs_task (void *cls,
-                 const struct GNUNET_SCHEDULER_TaskContext *tc)
+restart_fs_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_FS_stop (fs);
   fs = GNUNET_FS_start (cfg,
-                        "test-fs-unindex-persistence",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_PERSISTENCE,
-                        GNUNET_FS_OPTIONS_END);
+                        "test-fs-unindex-persistence",
+                        &progress_cb,
+                        NULL,
+                        GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_END);
 }
 
 
@@ -128,127 +123,130 @@ consider_restart (int ev)
   static int prev[32];
   static int off;
   int i;
-  for (i=0;i<off;i++)
+
+  for (i = 0; i < off; i++)
     if (prev[i] == ev)
       return;
   prev[off++] = ev;
   GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_URGENT,
-                                      &restart_fs_task,
-                                      NULL);
+                                      &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:
+  {
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
 #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);
-#endif      
-      break;
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      printf ("Publishing complete, %llu kbps.\n",
-              (unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 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 * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).rel_value) / 1024));
-      GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
-      consider_restart (event->status);
-      GNUNET_assert (unindex == event->value.unindex.uc);
+    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_COMPLETED:
+    printf ("Publishing complete, %llu kbps.\n",
+            (unsigned long long) (FILESIZE * 1000 /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 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 * 1000 /
+                                  (1 +
+                                   GNUNET_TIME_absolute_get_duration
+                                   (start).rel_value) / 1024));
+    GNUNET_SCHEDULER_add_continuation (&abort_unindex_task, NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    consider_restart (event->status);
+    GNUNET_assert (unindex == event->value.unindex.uc);
 #if VERBOSE
-      printf ("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);
+    printf ("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);
 #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)
-        {
-          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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    case GNUNET_FS_STATUS_UNINDEX_ERROR:
-      fprintf (stderr,
-               "Error unindexing file: %s\n",
-               event->value.unindex.specifics.error.message);
-      GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      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_continuation (&abort_publish_task,
-                                         NULL,
-                                         GNUNET_SCHEDULER_REASON_PREREQ_DONE);
-      break;
-    default:
-      printf ("Unexpected event: %d\n", 
-              event->status);
-      break;
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  case GNUNET_FS_STATUS_UNINDEX_ERROR:
+    fprintf (stderr,
+             "Error unindexing file: %s\n",
+             event->value.unindex.specifics.error.message);
+    GNUNET_SCHEDULER_add_continuation (&abort_unindex_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    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_continuation (&abort_publish_task,
+                                       NULL,
+                                       GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+    break;
+  default:
+    printf ("Unexpected event: %d\n", event->status);
+    break;
+  }
   return NULL;
 }
 
@@ -259,11 +257,11 @@ setup_peer (struct PeerContext *p, const char *cfgname)
   p->cfg = GNUNET_CONFIGURATION_create ();
 #if START_ARM
   p->arm_proc = GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
-                                        "gnunet-service-arm",
+                                         "gnunet-service-arm",
 #if VERBOSE
-                                        "-L", "DEBUG",
+                                         "-L", "DEBUG",
 #endif
-                                        "-c", cfgname, NULL);
+                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
 }
@@ -274,16 +272,17 @@ stop_arm (struct PeerContext *p)
 {
 #if START_ARM
   if (NULL != p->arm_proc)
-    {
-      if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
-      if (GNUNET_OS_process_wait(p->arm_proc) != GNUNET_OK)
-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "ARM process %u stopped\n", GNUNET_OS_process_get_pid (p->arm_proc));
-      GNUNET_OS_process_close (p->arm_proc);
-      p->arm_proc = NULL;
-    }
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "ARM process %u stopped\n",
+                GNUNET_OS_process_get_pid (p->arm_proc));
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
 #endif
   GNUNET_CONFIGURATION_destroy (p->cfg);
 }
@@ -292,8 +291,7 @@ stop_arm (struct PeerContext *p)
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *c)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
 {
   const char *keywords[] = {
     "down_foo",
@@ -310,20 +308,20 @@ run (void *cls,
   setup_peer (&p1, "test_fs_unindex_data.conf");
   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); 
+                        "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_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);
@@ -332,20 +330,18 @@ run (void *cls,
   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);
+                                                    "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);
+                                     fi,
+                                     NULL, NULL, NULL,
+                                     GNUNET_FS_PUBLISH_OPTION_NONE);
   GNUNET_assert (publish != NULL);
 }
 
@@ -353,7 +349,7 @@ run (void *cls,
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-fs-unindex",
     "-c",
     "test_fs_unindex_data.conf",
@@ -366,23 +362,22 @@ main (int argc, char *argv[])
     GNUNET_GETOPT_OPTION_END
   };
 
-  GNUNET_log_setup ("test_fs_unindex_persistence", 
+  GNUNET_log_setup ("test_fs_unindex_persistence",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
-                      argvx, "test-fs-unindex",
-                      "nohelp", options, &run, NULL);
+                      argvx, "test-fs-unindex", "nohelp", options, &run, NULL);
   stop_arm (&p1);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-unindex/");
   if (NULL != fn)
-    {
-      GNUNET_DISK_directory_remove (fn);
-      GNUNET_free (fn);
-    }
+  {
+    GNUNET_DISK_directory_remove (fn);
+    GNUNET_free (fn);
+  }
   return 0;
 }
 
diff --git a/src/fs/test_fs_uri.c b/src/fs/test_fs_uri.c
index 0894b8b93..e8f6ed70f 100644
--- a/src/fs/test_fs_uri.c
+++ b/src/fs/test_fs_uri.c
@@ -39,37 +39,37 @@ testKeyword ()
   char *emsg;
 
   if (NULL != (ret = GNUNET_FS_uri_parse ("gnunet://fs/ksk/++", &emsg)))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (emsg);
   ret = GNUNET_FS_uri_parse ("gnunet://fs/ksk/foo+bar", &emsg);
   if (ret == NULL)
-    {
-      GNUNET_free (emsg);
-      ABORT ();
-    }
+  {
+    GNUNET_free (emsg);
+    ABORT ();
+  }
   if (!GNUNET_FS_uri_test_ksk (ret))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   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);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
 
   uri = GNUNET_FS_uri_to_string (ret);
   if (0 != strcmp (uri, "gnunet://fs/ksk/foo+bar"))
-    {
-      GNUNET_free (uri);
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_free (uri);
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (uri);
   GNUNET_FS_uri_destroy (ret);
   return 0;
@@ -86,46 +86,45 @@ testLocation ()
   struct GNUNET_CONFIGURATION_Handle *cfg;
 
   baseURI =
-    GNUNET_FS_uri_parse ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42", &emsg);
+      GNUNET_FS_uri_parse
+      ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42",
+       &emsg);
   GNUNET_assert (baseURI != NULL);
   GNUNET_assert (emsg == NULL);
   cfg = GNUNET_CONFIGURATION_create ();
-  if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_parse (cfg, "test_fs_uri_data.conf"))
-    {
-      fprintf (stderr, "Failed to parse configuration file\n");
-      GNUNET_FS_uri_destroy (baseURI);
-      GNUNET_CONFIGURATION_destroy (cfg);
-      return 1;
-    }
-  uri = GNUNET_FS_uri_loc_create (baseURI,
-                                  cfg,
-                                  GNUNET_TIME_absolute_get ());
+  if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg, "test_fs_uri_data.conf"))
+  {
+    fprintf (stderr, "Failed to parse configuration file\n");
+    GNUNET_FS_uri_destroy (baseURI);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    return 1;
+  }
+  uri = GNUNET_FS_uri_loc_create (baseURI, cfg, GNUNET_TIME_absolute_get ());
   if (uri == NULL)
-    {
-      GNUNET_break (0);
-      GNUNET_FS_uri_destroy (baseURI);
-      GNUNET_CONFIGURATION_destroy (cfg);
-      return 1;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (baseURI);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    return 1;
+  }
   if (!GNUNET_FS_uri_test_loc (uri))
-    {
-      GNUNET_break (0);
-      GNUNET_FS_uri_destroy (uri);
-      GNUNET_FS_uri_destroy (baseURI);
-      GNUNET_CONFIGURATION_destroy (cfg);
-      return 1;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_FS_uri_destroy (baseURI);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    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);
-      GNUNET_CONFIGURATION_destroy (cfg);
-      return 1;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_FS_uri_destroy (uri2);
+    GNUNET_FS_uri_destroy (baseURI);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    return 1;
+  }
   GNUNET_FS_uri_destroy (uri2);
   GNUNET_FS_uri_destroy (baseURI);
   uric = GNUNET_FS_uri_to_string (uri);
@@ -136,22 +135,22 @@ testLocation ()
   uri2 = GNUNET_FS_uri_parse (uric, &emsg);
   GNUNET_free (uric);
   if (uri2 == NULL)
-    {
-      GNUNET_break (0);
-      GNUNET_FS_uri_destroy (uri);
-      GNUNET_CONFIGURATION_destroy (cfg);
-      GNUNET_free (emsg);
-      return 1;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    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);
-      GNUNET_CONFIGURATION_destroy (cfg);
-      return 1;
-    }
+  {
+    GNUNET_break (0);
+    GNUNET_FS_uri_destroy (uri);
+    GNUNET_FS_uri_destroy (uri2);
+    GNUNET_CONFIGURATION_destroy (cfg);
+    return 1;
+  }
   GNUNET_FS_uri_destroy (uri2);
   GNUNET_FS_uri_destroy (uri);
   GNUNET_CONFIGURATION_destroy (cfg);
@@ -166,51 +165,57 @@ testNamespace (int i)
   char *emsg;
 
   if (NULL !=
-      (ret = GNUNET_FS_uri_parse ("gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3VUK", &emsg)))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+      (ret =
+       GNUNET_FS_uri_parse ("gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3VUK",
+                            &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (emsg);
   if (NULL !=
-      (ret = GNUNET_FS_uri_parse ("gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3V/test", &emsg)))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();    
-    }
+      (ret =
+       GNUNET_FS_uri_parse
+       ("gnunet://fs/sks/D1KJS9H2A82Q65VKQ0ML3RFU6U1D3V/test", &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (emsg);
   if (NULL != (ret = GNUNET_FS_uri_parse ("gnunet://fs/sks/test", &emsg)))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (emsg);
   ret =
-    GNUNET_FS_uri_parse ("gnunet://fs/sks/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820/test", &emsg);
+      GNUNET_FS_uri_parse
+      ("gnunet://fs/sks/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820/test",
+       &emsg);
   if (ret == NULL)
-    {
-      GNUNET_free (emsg);
-      ABORT ();
-    }
+  {
+    GNUNET_free (emsg);
+    ABORT ();
+  }
   if (GNUNET_FS_uri_test_ksk (ret))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   if (!GNUNET_FS_uri_test_sks (ret))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
 
   uri = GNUNET_FS_uri_to_string (ret);
   if (0 != strcmp (uri,
                    "gnunet://fs/sks/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820/test"))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      GNUNET_free (uri);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    GNUNET_free (uri);
+    ABORT ();
+  }
   GNUNET_free (uri);
   GNUNET_FS_uri_destroy (ret);
   return 0;
@@ -224,57 +229,68 @@ testFile (int i)
   char *emsg;
 
   if (NULL !=
-      (ret = GNUNET_FS_uri_parse ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H00000440000.42", &emsg)))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+      (ret =
+       GNUNET_FS_uri_parse
+       ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H00000440000.42",
+        &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (emsg);
   if (NULL !=
-      (ret = GNUNET_FS_uri_parse ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000", &emsg)))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+      (ret =
+       GNUNET_FS_uri_parse
+       ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000",
+        &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (emsg);
   if (NULL !=
-      (ret = GNUNET_FS_uri_parse ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.FGH", &emsg)))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+      (ret =
+       GNUNET_FS_uri_parse
+       ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.FGH",
+        &emsg)))
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (emsg);
   ret =
-    GNUNET_FS_uri_parse ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42", &emsg);
+      GNUNET_FS_uri_parse
+      ("gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42",
+       &emsg);
   if (ret == NULL)
-    {
-      GNUNET_free (emsg);
-      ABORT ();
-    }
+  {
+    GNUNET_free (emsg);
+    ABORT ();
+  }
   if (GNUNET_FS_uri_test_ksk (ret))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   if (GNUNET_FS_uri_test_sks (ret))
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   if (GNUNET_ntohll (ret->data.chk.file_length) != 42)
-    {
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
 
   uri = GNUNET_FS_uri_to_string (ret);
   if (0 != strcmp (uri,
                    "gnunet://fs/chk/C282GG70GKK41O4551011DO413KFBVTVMQG1OG30I0K4045N0G41HAPB82G680A02JRVVFO8URVRU2F159011DO41000000022RG820.RNVVVVOOLCLK065B5D04HTNVNSIB2AI022RG8200HSLK1CO1000ATQ98824DMA2032LIMG50CG0K057NVUVG200000H000004400000.42"))
-    {
-      GNUNET_free (uri);
-      GNUNET_FS_uri_destroy (ret);
-      ABORT ();
-    }
+  {
+    GNUNET_free (uri);
+    GNUNET_FS_uri_destroy (ret);
+    ABORT ();
+  }
   GNUNET_free (uri);
   GNUNET_FS_uri_destroy (ret);
   return 0;
@@ -286,22 +302,22 @@ main (int argc, char *argv[])
   int failureCount = 0;
   int i;
 
-  GNUNET_log_setup ("test_fs_uri", 
+  GNUNET_log_setup ("test_fs_uri",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_CRYPTO_random_disable_entropy_gathering ();
   failureCount += testKeyword ();
   failureCount += testLocation ();
   for (i = 0; i < 255; i++)
-    {
-      /* fprintf (stderr, "."); */
-      failureCount += testNamespace (i);
-      failureCount += testFile (i);
-    }
+  {
+    /* fprintf (stderr, "."); */
+    failureCount += testNamespace (i);
+    failureCount += testFile (i);
+  }
   /* fprintf (stderr, "\n"); */
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-uri");
   if (failureCount != 0)
diff --git a/src/fs/test_gnunet_service_fs_migration.c b/src/fs/test_gnunet_service_fs_migration.c
index 092cedfc2..9a209521f 100644
--- a/src/fs/test_gnunet_service_fs_migration.c
+++ b/src/fs/test_gnunet_service_fs_migration.c
@@ -53,172 +53,140 @@ static int ok;
 static struct GNUNET_TIME_Absolute start_time;
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TIME_Relative del;
   char *fancy;
 
-  GNUNET_FS_TEST_daemons_stop (2,
-                               daemons);
+  GNUNET_FS_TEST_daemons_stop (2, daemons);
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      del = GNUNET_TIME_absolute_get_duration (start_time);
-      if (del.rel_value == 0)
-        del.rel_value = 1;
-      fancy = GNUNET_STRINGS_byte_size_fancy (((unsigned long long)FILESIZE) * 1000LL / del.rel_value);
-      fprintf (stdout,
-               "Download speed was %s/s\n",
-               fancy);
-      GNUNET_free (fancy);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Finished download, shutting down\n",
-                  (unsigned long long) FILESIZE);
-    }
+  {
+    del = GNUNET_TIME_absolute_get_duration (start_time);
+    if (del.rel_value == 0)
+      del.rel_value = 1;
+    fancy =
+        GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
+                                        1000LL / del.rel_value);
+    fprintf (stdout, "Download speed was %s/s\n", fancy);
+    GNUNET_free (fancy);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished download, shutting down\n",
+                (unsigned long long) FILESIZE);
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Timeout during download, shutting down with error\n");
-      ok = 1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during download, shutting down with error\n");
+    ok = 1;
+  }
 }
 
 
 static void
-do_download (void *cls,
-             const char *emsg)
+do_download (void *cls, const char *emsg)
 {
   struct GNUNET_FS_Uri *uri = cls;
 
   if (emsg != NULL)
-    {
-      GNUNET_FS_TEST_daemons_stop (2,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Failed to stop source daemon: %s\n",
-                  emsg);
-      GNUNET_FS_uri_destroy (uri);
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (2, daemons);
+    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);
+              "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);
+                           TIMEOUT, 1, SEED, uri, VERBOSE, &do_stop, NULL);
   GNUNET_FS_uri_destroy (uri);
 }
 
 
 static void
-stop_source_peer (void *cls,
-                  const struct GNUNET_SCHEDULER_TaskContext *tc)
+stop_source_peer (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_FS_Uri *uri = cls;
   struct GNUNET_TESTING_PeerGroup *pg;
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Stopping source peer\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping source peer\n");
   pg = GNUNET_FS_TEST_get_group (daemons);
-  GNUNET_TESTING_daemons_vary (pg, 1, GNUNET_NO, TIMEOUT,
-                               &do_download,
-                               uri);
+  GNUNET_TESTING_daemons_vary (pg, 1, GNUNET_NO, TIMEOUT, &do_download, uri);
 }
 
 
 static void
-do_wait (void *cls,
-         const struct GNUNET_FS_Uri *uri)
+do_wait (void *cls, const struct GNUNET_FS_Uri *uri)
 {
   struct GNUNET_FS_Uri *d;
 
   if (NULL == uri)
-    {
-      GNUNET_FS_TEST_daemons_stop (2,
-                                   daemons);
-      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"); 
+  {
+    GNUNET_FS_TEST_daemons_stop (2, daemons);
+    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");
   d = GNUNET_FS_uri_dup (uri);
-  (void) GNUNET_SCHEDULER_add_delayed (MIGRATION_DELAY,
-                                       &stop_source_peer,
-                                       d);
+  (void) GNUNET_SCHEDULER_add_delayed (MIGRATION_DELAY, &stop_source_peer, d);
 }
 
 
 static void
-do_publish (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      GNUNET_FS_TEST_daemons_stop (2,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Timeout during connect attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (2, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during connect attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   GNUNET_FS_TEST_publish (daemons[1],
-                          TIMEOUT,
-                          1, GNUNET_NO, FILESIZE, SEED, 
-                          VERBOSE, 
-                          &do_wait, NULL);
+                          TIMEOUT,
+                          1, GNUNET_NO, FILESIZE, SEED,
+                          VERBOSE, &do_wait, NULL);
 }
 
 
 static void
-do_connect (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      fprintf (stderr,
-               "Daemons failed to start!\n");
-      GNUNET_break (0);
-      ok = 1;
-      return;
-    }
+  {
+    fprintf (stderr, "Daemons failed to start!\n");
+    GNUNET_break (0);
+    ok = 1;
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Daemons started, will now try to connect them\n");
+              "Daemons started, will now try to connect them\n");
   GNUNET_FS_TEST_daemons_connect (daemons[0],
-                                  daemons[1],
-                                  TIMEOUT,
-                                  &do_publish,
-                                  NULL);  
+                                  daemons[1], TIMEOUT, &do_publish, NULL);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_FS_TEST_daemons_start ("test_gnunet_service_fs_migration_data.conf",
-                                TIMEOUT,
-                                2,
-                                daemons,
-                                &do_connect,
-                                NULL);
+                                TIMEOUT, 2, daemons, &do_connect, NULL);
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-gnunet-service-fs-migration",
     "-c",
     "fs_test_lib_data.conf",
@@ -232,16 +200,16 @@ main (int argc, char *argv[])
   };
 
   GNUNET_DISK_directory_remove ("/tmp/test-gnunet-service-fs-migration/");
-  GNUNET_log_setup ("test_gnunet_service_fs_migration", 
+  GNUNET_log_setup ("test_gnunet_service_fs_migration",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-gnunet-service-fs-migration",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, 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 d21e700e5..c48f98666 100644
--- a/src/fs/test_gnunet_service_fs_p2p.c
+++ b/src/fs/test_gnunet_service_fs_p2p.c
@@ -49,120 +49,100 @@ static int ok;
 static struct GNUNET_TIME_Absolute start_time;
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TIME_Relative del;
   char *fancy;
 
-  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                               daemons);
+  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      del = GNUNET_TIME_absolute_get_duration (start_time);
-      if (del.rel_value == 0)
-        del.rel_value = 1;
-      fancy = GNUNET_STRINGS_byte_size_fancy (((unsigned long long)FILESIZE) * 1000LL / del.rel_value);
-      fprintf (stdout,
-               "Download speed was %s/s\n",
-               fancy);
-      GNUNET_free (fancy);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Finished download, shutting down\n",
-                  (unsigned long long) FILESIZE);
-    }
+  {
+    del = GNUNET_TIME_absolute_get_duration (start_time);
+    if (del.rel_value == 0)
+      del.rel_value = 1;
+    fancy =
+        GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
+                                        1000LL / del.rel_value);
+    fprintf (stdout, "Download speed was %s/s\n", fancy);
+    GNUNET_free (fancy);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished download, shutting down\n",
+                (unsigned long long) FILESIZE);
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Timeout during download, shutting down with error\n");
-      ok = 1;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during download, shutting down with error\n");
+    ok = 1;
+  }
 }
 
 
 static void
-do_download (void *cls,
-             const struct GNUNET_FS_Uri *uri)
+do_download (void *cls, const struct GNUNET_FS_Uri *uri)
 {
   if (NULL == uri)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    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);
+              "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);
+                           TIMEOUT, 1, SEED, uri, VERBOSE, &do_stop, NULL);
 }
 
 
 static void
-do_publish (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_publish (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Timeout during connect attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Timeout during connect attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   GNUNET_FS_TEST_publish (daemons[1],
-                          TIMEOUT,
-                          1, GNUNET_NO, FILESIZE, SEED, 
-                          VERBOSE, 
-                          &do_download, NULL);
+                          TIMEOUT,
+                          1, GNUNET_NO, FILESIZE, SEED,
+                          VERBOSE, &do_download, NULL);
 }
 
 
 static void
-do_connect (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Daemons started, will now try to connect them\n");
+              "Daemons started, will now try to connect them\n");
   GNUNET_FS_TEST_daemons_connect (daemons[0],
-                                  daemons[1],
-                                  TIMEOUT,
-                                  &do_publish,
-                                  NULL);  
+                                  daemons[1], TIMEOUT, &do_publish, NULL);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
-                                TIMEOUT,
-                                NUM_DAEMONS,
-                                daemons,
-                                &do_connect,
-                                NULL);
+                                TIMEOUT,
+                                NUM_DAEMONS, daemons, &do_connect, NULL);
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "test-gnunet-service-fs-p2p",
     "-c",
     "fs_test_lib_data.conf",
@@ -176,16 +156,16 @@ main (int argc, char *argv[])
   };
 
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
-  GNUNET_log_setup ("test_gnunet_service_fs_p2p", 
+  GNUNET_log_setup ("test_gnunet_service_fs_p2p",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "test-gnunet-service-fs-p2p",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ok;
 }