1 files changed, 512 insertions, 512 deletions

diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index 24baa4d38..ff56dac8c 100644
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -148,41 +148,41 @@ static struct GNUNET_IDENTITY_Handle *identity;
  * @param cls NULL
  */
 static void
-do_stop_task(void *cls)
+do_stop_task (void *cls)
 {
   struct GNUNET_FS_PublishContext *p;
 
   if (NULL != ds)
-    {
-      GNUNET_FS_directory_scan_abort(ds);
-      ds = NULL;
-    }
+  {
+    GNUNET_FS_directory_scan_abort (ds);
+    ds = NULL;
+  }
   if (NULL != identity)
-    {
-      GNUNET_IDENTITY_disconnect(identity);
-      identity = NULL;
-    }
+  {
+    GNUNET_IDENTITY_disconnect (identity);
+    identity = NULL;
+  }
   if (NULL != pc)
-    {
-      p = pc;
-      pc = NULL;
-      GNUNET_FS_publish_stop(p);
-    }
+  {
+    p = pc;
+    pc = NULL;
+    GNUNET_FS_publish_stop (p);
+  }
   if (NULL != ctx)
-    {
-      GNUNET_FS_stop(ctx);
-      ctx = NULL;
-    }
+  {
+    GNUNET_FS_stop (ctx);
+    ctx = NULL;
+  }
   if (NULL != meta)
-    {
-      GNUNET_CONTAINER_meta_data_destroy(meta);
-      meta = NULL;
-    }
+  {
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    meta = NULL;
+  }
   if (NULL != uri)
-    {
-      GNUNET_FS_uri_destroy(uri);
-      uri = NULL;
-    }
+  {
+    GNUNET_FS_uri_destroy (uri);
+    uri = NULL;
+  }
 }
 
 
@@ -200,105 +200,105 @@ do_stop_task(void *cls)
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
 static void *
-progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
+progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 {
   const char *s;
   char *suri;
 
   switch (info->status)
+  {
+  case GNUNET_FS_STATUS_PUBLISH_START:
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
+    if (verbose)
     {
-    case GNUNET_FS_STATUS_PUBLISH_START:
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS:
-      if (verbose)
-        {
-          s = GNUNET_STRINGS_relative_time_to_string(info->value.publish.eta,
-                                                     GNUNET_YES);
-          fprintf(stdout,
-                  _("Publishing `%s' at %llu/%llu (%s remaining)\n"),
-                  info->value.publish.filename,
-                  (unsigned long long)info->value.publish.completed,
-                  (unsigned long long)info->value.publish.size,
-                  s);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
-      if (verbose)
-        {
-          s = GNUNET_STRINGS_relative_time_to_string(info->value.publish.specifics
-                                                     .progress_directory.eta,
-                                                     GNUNET_YES);
-          fprintf(stdout,
-                  _("Publishing `%s' at %llu/%llu (%s remaining)\n"),
-                  info->value.publish.filename,
-                  (unsigned long long)
-                  info->value.publish.specifics.progress_directory.completed,
-                  (unsigned long long)
-                  info->value.publish.specifics.progress_directory.total,
-                  s);
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_ERROR:
-      fprintf(stderr,
-              _("Error publishing: %s.\n"),
-              info->value.publish.specifics.error.message);
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
-      fprintf(stdout,
-              _("Publishing `%s' done.\n"),
-              info->value.publish.filename);
-      suri =
-        GNUNET_FS_uri_to_string(info->value.publish.specifics.completed.chk_uri);
-      fprintf(stdout, _("URI is `%s'.\n"), suri);
-      GNUNET_free(suri);
-      if (NULL != info->value.publish.specifics.completed.sks_uri)
-        {
-          suri = GNUNET_FS_uri_to_string(
-            info->value.publish.specifics.completed.sks_uri);
-          fprintf(stdout, _("Namespace URI is `%s'.\n"), suri);
-          GNUNET_free(suri);
-        }
-      if (NULL == info->value.publish.pctx)
-        {
-          ret = 0;
-          GNUNET_SCHEDULER_shutdown();
-        }
-      break;
-
-    case GNUNET_FS_STATUS_PUBLISH_STOPPED:
-      GNUNET_break(NULL == pc);
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_START:
-      fprintf(stderr, "%s", _("Starting cleanup after abort\n"));
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
-      fprintf(stderr, "%s", _("Cleanup after abort completed.\n"));
-      GNUNET_FS_unindex_stop(info->value.unindex.uc);
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_ERROR:
-      fprintf(stderr, "%s", _("Cleanup after abort failed.\n"));
-      GNUNET_FS_unindex_stop(info->value.unindex.uc);
-      return NULL;
-
-    case GNUNET_FS_STATUS_UNINDEX_STOPPED:
-      return NULL;
-
-    default:
-      fprintf(stderr, _("Unexpected status: %d\n"), info->status);
-      return NULL;
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.eta,
+                                                  GNUNET_YES);
+      fprintf (stdout,
+               _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
+               info->value.publish.filename,
+               (unsigned long long) info->value.publish.completed,
+               (unsigned long long) info->value.publish.size,
+               s);
     }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY:
+    if (verbose)
+    {
+      s = GNUNET_STRINGS_relative_time_to_string (info->value.publish.specifics
+                                                  .progress_directory.eta,
+                                                  GNUNET_YES);
+      fprintf (stdout,
+               _ ("Publishing `%s' at %llu/%llu (%s remaining)\n"),
+               info->value.publish.filename,
+               (unsigned long long)
+               info->value.publish.specifics.progress_directory.completed,
+               (unsigned long long)
+               info->value.publish.specifics.progress_directory.total,
+               s);
+    }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_ERROR:
+    fprintf (stderr,
+             _ ("Error publishing: %s.\n"),
+             info->value.publish.specifics.error.message);
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_COMPLETED:
+    fprintf (stdout,
+             _ ("Publishing `%s' done.\n"),
+             info->value.publish.filename);
+    suri =
+      GNUNET_FS_uri_to_string (info->value.publish.specifics.completed.chk_uri);
+    fprintf (stdout, _ ("URI is `%s'.\n"), suri);
+    GNUNET_free (suri);
+    if (NULL != info->value.publish.specifics.completed.sks_uri)
+    {
+      suri = GNUNET_FS_uri_to_string (
+        info->value.publish.specifics.completed.sks_uri);
+      fprintf (stdout, _ ("Namespace URI is `%s'.\n"), suri);
+      GNUNET_free (suri);
+    }
+    if (NULL == info->value.publish.pctx)
+    {
+      ret = 0;
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    break;
+
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_break (NULL == pc);
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_START:
+    fprintf (stderr, "%s", _ ("Starting cleanup after abort\n"));
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
+    fprintf (stderr, "%s", _ ("Cleanup after abort completed.\n"));
+    GNUNET_FS_unindex_stop (info->value.unindex.uc);
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_ERROR:
+    fprintf (stderr, "%s", _ ("Cleanup after abort failed.\n"));
+    GNUNET_FS_unindex_stop (info->value.unindex.uc);
+    return NULL;
+
+  case GNUNET_FS_STATUS_UNINDEX_STOPPED:
+    return NULL;
+
+  default:
+    fprintf (stderr, _ ("Unexpected status: %d\n"), info->status);
+    return NULL;
+  }
   return ""; /* non-null */
 }
 
@@ -317,13 +317,13 @@ progress_cb(void *cls, const struct GNUNET_FS_ProgressInfo *info)
  * @return always 0
  */
 static int
-meta_printer(void *cls,
-             const char *plugin_name,
-             enum EXTRACTOR_MetaType type,
-             enum EXTRACTOR_MetaFormat format,
-             const char *data_mime_type,
-             const char *data,
-             size_t data_size)
+meta_printer (void *cls,
+              const char *plugin_name,
+              enum EXTRACTOR_MetaType type,
+              enum EXTRACTOR_MetaFormat format,
+              const char *data_mime_type,
+              const char *data,
+              size_t data_size)
 {
   if ((EXTRACTOR_METAFORMAT_UTF8 != format) &&
       (EXTRACTOR_METAFORMAT_C_STRING != format))
@@ -331,9 +331,9 @@ meta_printer(void *cls,
   if (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type)
     return 0;
 #if HAVE_LIBEXTRACTOR
-  fprintf(stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string(type), data);
+  fprintf (stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string (type), data);
 #else
-  fprintf(stdout, "\t%d - %s\n", type, data);
+  fprintf (stdout, "\t%d - %s\n", type, data);
 #endif
   return 0;
 }
@@ -348,9 +348,9 @@ meta_printer(void *cls,
  * @return #GNUNET_OK to continue to iterate, #GNUNET_SYSERR to abort
  */
 static int
-keyword_printer(void *cls, const char *keyword, int is_mandatory)
+keyword_printer (void *cls, const char *keyword, int is_mandatory)
 {
-  fprintf(stdout, "\t%s\n", keyword);
+  fprintf (stdout, "\t%s\n", keyword);
   return GNUNET_OK;
 }
 
@@ -373,14 +373,14 @@ keyword_printer(void *cls, const char *keyword, int is_mandatory)
  *         to abort the iteration
  */
 static int
-publish_inspector(void *cls,
-                  struct GNUNET_FS_FileInformation *fi,
-                  uint64_t length,
-                  struct GNUNET_CONTAINER_MetaData *m,
-                  struct GNUNET_FS_Uri **uri,
-                  struct GNUNET_FS_BlockOptions *bo,
-                  int *do_index,
-                  void **client_info)
+publish_inspector (void *cls,
+                   struct GNUNET_FS_FileInformation *fi,
+                   uint64_t length,
+                   struct GNUNET_CONTAINER_MetaData *m,
+                   struct GNUNET_FS_Uri **uri,
+                   struct GNUNET_FS_BlockOptions *bo,
+                   int *do_index,
+                   void **client_info)
 {
   char *fn;
   char *fs;
@@ -389,50 +389,50 @@ publish_inspector(void *cls,
   if (cls == fi)
     return GNUNET_OK;
   if ((disable_extractor) && (NULL != *uri))
-    {
-      GNUNET_FS_uri_destroy(*uri);
-      *uri = NULL;
-    }
+  {
+    GNUNET_FS_uri_destroy (*uri);
+    *uri = NULL;
+  }
   if (NULL != topKeywords)
+  {
+    if (NULL != *uri)
     {
-      if (NULL != *uri)
-        {
-          new_uri = GNUNET_FS_uri_ksk_merge(topKeywords, *uri);
-          GNUNET_FS_uri_destroy(*uri);
-          *uri = new_uri;
-          GNUNET_FS_uri_destroy(topKeywords);
-        }
-      else
-        {
-          *uri = topKeywords;
-        }
-      topKeywords = NULL;
+      new_uri = GNUNET_FS_uri_ksk_merge (topKeywords, *uri);
+      GNUNET_FS_uri_destroy (*uri);
+      *uri = new_uri;
+      GNUNET_FS_uri_destroy (topKeywords);
     }
-  if (NULL != meta)
+    else
     {
-      GNUNET_CONTAINER_meta_data_merge(m, meta);
-      GNUNET_CONTAINER_meta_data_destroy(meta);
-      meta = NULL;
+      *uri = topKeywords;
     }
+    topKeywords = NULL;
+  }
+  if (NULL != meta)
+  {
+    GNUNET_CONTAINER_meta_data_merge (m, meta);
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    meta = NULL;
+  }
   if (enable_creation_time)
-    GNUNET_CONTAINER_meta_data_add_publication_date(m);
+    GNUNET_CONTAINER_meta_data_add_publication_date (m);
   if (extract_only)
-    {
-      fn = GNUNET_CONTAINER_meta_data_get_by_type(
-        m,
-        EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
-      fs = GNUNET_STRINGS_byte_size_fancy(length);
-      fprintf(stdout, _("Meta data for file `%s' (%s)\n"), fn, fs);
-      GNUNET_CONTAINER_meta_data_iterate(m, &meta_printer, NULL);
-      fprintf(stdout, _("Keywords for file `%s' (%s)\n"), fn, fs);
-      GNUNET_free(fn);
-      GNUNET_free(fs);
-      if (NULL != *uri)
-        GNUNET_FS_uri_ksk_get_keywords(*uri, &keyword_printer, NULL);
-      fprintf(stdout, "%s", "\n");
-    }
-  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory(m))
-    GNUNET_FS_file_information_inspect(fi, &publish_inspector, fi);
+  {
+    fn = GNUNET_CONTAINER_meta_data_get_by_type (
+      m,
+      EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
+    fs = GNUNET_STRINGS_byte_size_fancy (length);
+    fprintf (stdout, _ ("Meta data for file `%s' (%s)\n"), fn, fs);
+    GNUNET_CONTAINER_meta_data_iterate (m, &meta_printer, NULL);
+    fprintf (stdout, _ ("Keywords for file `%s' (%s)\n"), fn, fs);
+    GNUNET_free (fn);
+    GNUNET_free (fs);
+    if (NULL != *uri)
+      GNUNET_FS_uri_ksk_get_keywords (*uri, &keyword_printer, NULL);
+    fprintf (stdout, "%s", "\n");
+  }
+  if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (m))
+    GNUNET_FS_file_information_inspect (fi, &publish_inspector, fi);
   return GNUNET_OK;
 }
 
@@ -447,16 +447,16 @@ publish_inspector(void *cls,
  * @param emsg error message, NULL on success
  */
 static void
-uri_sks_continuation(void *cls,
-                     const struct GNUNET_FS_Uri *sks_uri,
-                     const char *emsg)
+uri_sks_continuation (void *cls,
+                      const struct GNUNET_FS_Uri *sks_uri,
+                      const char *emsg)
 {
   if (NULL != emsg)
-    {
-      fprintf(stderr, "%s\n", emsg);
-      ret = 1;
-    }
-  GNUNET_SCHEDULER_shutdown();
+  {
+    fprintf (stderr, "%s\n", emsg);
+    ret = 1;
+  }
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -470,33 +470,33 @@ uri_sks_continuation(void *cls,
  * @param emsg error message, NULL on success
  */
 static void
-uri_ksk_continuation(void *cls,
-                     const struct GNUNET_FS_Uri *ksk_uri,
-                     const char *emsg)
+uri_ksk_continuation (void *cls,
+                      const struct GNUNET_FS_Uri *ksk_uri,
+                      const char *emsg)
 {
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
 
   if (NULL != emsg)
-    {
-      fprintf(stderr, "%s\n", emsg);
-      ret = 1;
-    }
+  {
+    fprintf (stderr, "%s\n", emsg);
+    ret = 1;
+  }
   if (NULL == namespace)
-    {
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  priv = GNUNET_IDENTITY_ego_get_private_key(namespace);
-  GNUNET_FS_publish_sks(ctx,
-                        priv,
-                        this_id,
-                        next_id,
-                        meta,
-                        uri,
-                        &bo,
-                        GNUNET_FS_PUBLISH_OPTION_NONE,
-                        &uri_sks_continuation,
-                        NULL);
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
+  GNUNET_FS_publish_sks (ctx,
+                         priv,
+                         this_id,
+                         next_id,
+                         meta,
+                         uri,
+                         &bo,
+                         GNUNET_FS_PUBLISH_OPTION_NONE,
+                         &uri_sks_continuation,
+                         NULL);
 }
 
 
@@ -508,52 +508,52 @@ uri_ksk_continuation(void *cls,
  * @return handle with the information for the publishing operation
  */
 static struct GNUNET_FS_FileInformation *
-get_file_information(struct GNUNET_FS_ShareTreeItem *item)
+get_file_information (struct GNUNET_FS_ShareTreeItem *item)
 {
   struct GNUNET_FS_FileInformation *fi;
   struct GNUNET_FS_FileInformation *fic;
   struct GNUNET_FS_ShareTreeItem *child;
 
   if (GNUNET_YES == item->is_directory)
+  {
+    if (NULL == item->meta)
+      item->meta = GNUNET_CONTAINER_meta_data_create ();
+    GNUNET_CONTAINER_meta_data_delete (item->meta,
+                                       EXTRACTOR_METATYPE_MIMETYPE,
+                                       NULL,
+                                       0);
+    GNUNET_FS_meta_data_make_directory (item->meta);
+    if (NULL == item->ksk_uri)
     {
-      if (NULL == item->meta)
-        item->meta = GNUNET_CONTAINER_meta_data_create();
-      GNUNET_CONTAINER_meta_data_delete(item->meta,
-                                        EXTRACTOR_METATYPE_MIMETYPE,
-                                        NULL,
-                                        0);
-      GNUNET_FS_meta_data_make_directory(item->meta);
-      if (NULL == item->ksk_uri)
-        {
-          const char *mime = GNUNET_FS_DIRECTORY_MIME;
-          item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args(1, &mime);
-        }
-      else
-        GNUNET_FS_uri_ksk_add_keyword(item->ksk_uri,
-                                      GNUNET_FS_DIRECTORY_MIME,
-                                      GNUNET_NO);
-      fi = GNUNET_FS_file_information_create_empty_directory(ctx,
-                                                             NULL,
-                                                             item->ksk_uri,
-                                                             item->meta,
-                                                             &bo,
-                                                             item->filename);
-      for (child = item->children_head; child; child = child->next)
-        {
-          fic = get_file_information(child);
-          GNUNET_break(GNUNET_OK == GNUNET_FS_file_information_add(fi, fic));
-        }
+      const char *mime = GNUNET_FS_DIRECTORY_MIME;
+      item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &mime);
     }
-  else
+    else
+      GNUNET_FS_uri_ksk_add_keyword (item->ksk_uri,
+                                     GNUNET_FS_DIRECTORY_MIME,
+                                     GNUNET_NO);
+    fi = GNUNET_FS_file_information_create_empty_directory (ctx,
+                                                            NULL,
+                                                            item->ksk_uri,
+                                                            item->meta,
+                                                            &bo,
+                                                            item->filename);
+    for (child = item->children_head; child; child = child->next)
     {
-      fi = GNUNET_FS_file_information_create_from_file(ctx,
-                                                       NULL,
-                                                       item->filename,
-                                                       item->ksk_uri,
-                                                       item->meta,
-                                                       !do_insert,
-                                                       &bo);
+      fic = get_file_information (child);
+      GNUNET_break (GNUNET_OK == GNUNET_FS_file_information_add (fi, fic));
     }
+  }
+  else
+  {
+    fi = GNUNET_FS_file_information_create_from_file (ctx,
+                                                      NULL,
+                                                      item->filename,
+                                                      item->ksk_uri,
+                                                      item->meta,
+                                                      ! do_insert,
+                                                      &bo);
+  }
   return fi;
 }
 
@@ -565,46 +565,46 @@ get_file_information(struct GNUNET_FS_ShareTreeItem *item)
  * @param directory_scan_result result from the directory scan, freed in this function
  */
 static void
-directory_trim_complete(struct GNUNET_FS_ShareTreeItem *directory_scan_result)
+directory_trim_complete (struct GNUNET_FS_ShareTreeItem *directory_scan_result)
 {
   struct GNUNET_FS_FileInformation *fi;
   const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv;
 
-  fi = get_file_information(directory_scan_result);
-  GNUNET_FS_share_tree_free(directory_scan_result);
+  fi = get_file_information (directory_scan_result);
+  GNUNET_FS_share_tree_free (directory_scan_result);
   if (NULL == fi)
-    {
-      fprintf(stderr, "%s", _("Could not publish\n"));
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
-  GNUNET_FS_file_information_inspect(fi, &publish_inspector, NULL);
+  {
+    fprintf (stderr, "%s", _ ("Could not publish\n"));
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
+  GNUNET_FS_file_information_inspect (fi, &publish_inspector, NULL);
   if (extract_only)
-    {
-      GNUNET_FS_file_information_destroy(fi, NULL, NULL);
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    GNUNET_FS_file_information_destroy (fi, NULL, NULL);
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (NULL == namespace)
     priv = NULL;
   else
-    priv = GNUNET_IDENTITY_ego_get_private_key(namespace);
-  pc = GNUNET_FS_publish_start(ctx,
-                               fi,
-                               priv,
-                               this_id,
-                               next_id,
-                               (do_simulate)
-                               ? GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
-                               : GNUNET_FS_PUBLISH_OPTION_NONE);
+    priv = GNUNET_IDENTITY_ego_get_private_key (namespace);
+  pc = GNUNET_FS_publish_start (ctx,
+                                fi,
+                                priv,
+                                this_id,
+                                next_id,
+                                (do_simulate)
+                                ? GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
+                                : GNUNET_FS_PUBLISH_OPTION_NONE);
   if (NULL == pc)
-    {
-      fprintf(stderr, "%s", _("Could not start publishing.\n"));
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    fprintf (stderr, "%s", _ ("Could not start publishing.\n"));
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
 }
 
 
@@ -620,63 +620,63 @@ directory_trim_complete(struct GNUNET_FS_ShareTreeItem *directory_scan_result)
  * @param reason kind of progress we are making
  */
 static void
-directory_scan_cb(void *cls,
-                  const char *filename,
-                  int is_directory,
-                  enum GNUNET_FS_DirScannerProgressUpdateReason reason)
+directory_scan_cb (void *cls,
+                   const char *filename,
+                   int is_directory,
+                   enum GNUNET_FS_DirScannerProgressUpdateReason reason)
 {
   struct GNUNET_FS_ShareTreeItem *directory_scan_result;
 
   switch (reason)
+  {
+  case GNUNET_FS_DIRSCANNER_FILE_START:
+    if (verbose > 1)
     {
-    case GNUNET_FS_DIRSCANNER_FILE_START:
-      if (verbose > 1)
-        {
-          if (is_directory == GNUNET_YES)
-            fprintf(stdout, _("Scanning directory `%s'.\n"), filename);
-          else
-            fprintf(stdout, _("Scanning file `%s'.\n"), filename);
-        }
-      break;
-
-    case GNUNET_FS_DIRSCANNER_FILE_IGNORED:
-      fprintf(stderr,
-              _("There was trouble processing file `%s', skipping it.\n"),
-              filename);
-      break;
-
-    case GNUNET_FS_DIRSCANNER_ALL_COUNTED:
-      if (verbose)
-        fprintf(stdout, "%s", _("Preprocessing complete.\n"));
-      break;
-
-    case GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED:
-      if (verbose > 2)
-        fprintf(stdout,
-                _("Extracting meta data from file `%s' complete.\n"),
-                filename);
-      break;
-
-    case GNUNET_FS_DIRSCANNER_FINISHED:
-      if (verbose > 1)
-        fprintf(stdout, "%s", _("Meta data extraction has finished.\n"));
-      directory_scan_result = GNUNET_FS_directory_scan_get_result(ds);
-      ds = NULL;
-      GNUNET_FS_share_tree_trim(directory_scan_result);
-      directory_trim_complete(directory_scan_result);
-      break;
-
-    case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
-      fprintf(stdout, "%s", _("Error scanning directory.\n"));
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      break;
-
-    default:
-      GNUNET_assert(0);
-      break;
+      if (is_directory == GNUNET_YES)
+        fprintf (stdout, _ ("Scanning directory `%s'.\n"), filename);
+      else
+        fprintf (stdout, _ ("Scanning file `%s'.\n"), filename);
     }
-  fflush(stdout);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_FILE_IGNORED:
+    fprintf (stderr,
+             _ ("There was trouble processing file `%s', skipping it.\n"),
+             filename);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_ALL_COUNTED:
+    if (verbose)
+      fprintf (stdout, "%s", _ ("Preprocessing complete.\n"));
+    break;
+
+  case GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED:
+    if (verbose > 2)
+      fprintf (stdout,
+               _ ("Extracting meta data from file `%s' complete.\n"),
+               filename);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_FINISHED:
+    if (verbose > 1)
+      fprintf (stdout, "%s", _ ("Meta data extraction has finished.\n"));
+    directory_scan_result = GNUNET_FS_directory_scan_get_result (ds);
+    ds = NULL;
+    GNUNET_FS_share_tree_trim (directory_scan_result);
+    directory_trim_complete (directory_scan_result);
+    break;
+
+  case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
+    fprintf (stdout, "%s", _ ("Error scanning directory.\n"));
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    break;
+
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+  fflush (stdout);
 }
 
 
@@ -687,67 +687,67 @@ directory_scan_cb(void *cls,
  * @param args0 filename to publish
  */
 static void
-identity_continuation(const char *args0)
+identity_continuation (const char *args0)
 {
   char *ex;
   char *emsg;
 
   if ((NULL != pseudonym) && (NULL == namespace))
-    {
-      fprintf(stderr, _("Selected pseudonym `%s' unknown\n"), pseudonym);
-      ret = 1;
-      GNUNET_SCHEDULER_shutdown();
-      return;
-    }
+  {
+    fprintf (stderr, _ ("Selected pseudonym `%s' unknown\n"), pseudonym);
+    ret = 1;
+    GNUNET_SCHEDULER_shutdown ();
+    return;
+  }
   if (NULL != uri_string)
+  {
+    emsg = NULL;
+    if (NULL == (uri = GNUNET_FS_uri_parse (uri_string, &emsg)))
     {
-      emsg = NULL;
-      if (NULL == (uri = GNUNET_FS_uri_parse(uri_string, &emsg)))
-        {
-          fprintf(stderr, _("Failed to parse URI: %s\n"), emsg);
-          GNUNET_free(emsg);
-          ret = 1;
-          GNUNET_SCHEDULER_shutdown();
-          return;
-        }
-      GNUNET_FS_publish_ksk(ctx,
-                            topKeywords,
-                            meta,
-                            uri,
-                            &bo,
-                            GNUNET_FS_PUBLISH_OPTION_NONE,
-                            &uri_ksk_continuation,
-                            NULL);
+      fprintf (stderr, _ ("Failed to parse URI: %s\n"), emsg);
+      GNUNET_free (emsg);
+      ret = 1;
+      GNUNET_SCHEDULER_shutdown ();
       return;
     }
+    GNUNET_FS_publish_ksk (ctx,
+                           topKeywords,
+                           meta,
+                           uri,
+                           &bo,
+                           GNUNET_FS_PUBLISH_OPTION_NONE,
+                           &uri_ksk_continuation,
+                           NULL);
+    return;
+  }
   if (GNUNET_OK !=
-      GNUNET_CONFIGURATION_get_value_string(cfg, "FS", "EXTRACTORS", &ex))
+      GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
     ex = NULL;
-  if (0 != access(args0, R_OK))
-    {
-      fprintf(stderr,
-              _("Failed to access `%s': %s\n"),
-              args0,
-              strerror(errno));
-      GNUNET_free_non_null(ex);
-      return;
-    }
-  ds = GNUNET_FS_directory_scan_start(args0,
-                                      disable_extractor,
-                                      ex,
-                                      &directory_scan_cb,
-                                      NULL);
+  if (0 != access (args0, R_OK))
+  {
+    fprintf (stderr,
+             _ ("Failed to access `%s': %s\n"),
+             args0,
+             strerror (errno));
+    GNUNET_free_non_null (ex);
+    return;
+  }
+  ds = GNUNET_FS_directory_scan_start (args0,
+                                       disable_extractor,
+                                       ex,
+                                       &directory_scan_cb,
+                                       NULL);
   if (NULL == ds)
-    {
-      fprintf(
-        stderr,
-        "%s",
-        _(
-          "Failed to start meta directory scanner.  Is gnunet-helper-publish-fs installed?\n"));
-      GNUNET_free_non_null(ex);
-      return;
-    }
-  GNUNET_free_non_null(ex);
+  {
+    fprintf (
+      stderr,
+      "%s",
+      _ (
+        "Failed to start meta directory scanner.  Is gnunet-helper-publish-fs installed?\n"));
+    GNUNET_free_non_null (ex);
+    return;
+  }
+  GNUNET_free_non_null (ex);
 }
 
 
@@ -763,21 +763,21 @@ identity_continuation(const char *args0)
  *                   must thus no longer be used
  */
 static void
-identity_cb(void *cls,
-            struct GNUNET_IDENTITY_Ego *ego,
-            void **ctx,
-            const char *name)
+identity_cb (void *cls,
+             struct GNUNET_IDENTITY_Ego *ego,
+             void **ctx,
+             const char *name)
 {
   const char *args0 = cls;
 
   if (NULL == ego)
-    {
-      identity_continuation(args0);
-      return;
-    }
+  {
+    identity_continuation (args0);
+    return;
+  }
   if (NULL == name)
     return;
-  if (0 == strcmp(name, pseudonym))
+  if (0 == strcmp (name, pseudonym))
     namespace = ego;
 }
 
@@ -791,82 +791,82 @@ identity_cb(void *cls,
  * @param c configuration
  */
 static void
-run(void *cls,
-    char *const *args,
-    const char *cfgfile,
-    const struct GNUNET_CONFIGURATION_Handle *c)
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
 {
   /* check arguments */
   if ((NULL != uri_string) && (extract_only))
-    {
-      printf(_("Cannot extract metadata from a URI!\n"));
-      ret = -1;
-      return;
-    }
+  {
+    printf (_ ("Cannot extract metadata from a URI!\n"));
+    ret = -1;
+    return;
+  }
   if (((NULL == uri_string) || (extract_only)) &&
       ((NULL == args[0]) || (NULL != args[1])))
+  {
+    printf (_ ("You must specify one and only one filename for insertion.\n"));
+    ret = -1;
+    return;
+  }
+  if ((NULL != uri_string) && (NULL != args[0]))
+  {
+    printf (_ ("You must NOT specify an URI and a filename.\n"));
+    ret = -1;
+    return;
+  }
+  if (NULL != pseudonym)
+  {
+    if (NULL == this_id)
     {
-      printf(_("You must specify one and only one filename for insertion.\n"));
+      fprintf (stderr,
+               _ ("Option `%s' is required when using option `%s'.\n"),
+               "-t",
+               "-P");
       ret = -1;
       return;
     }
-  if ((NULL != uri_string) && (NULL != args[0]))
+  }
+  else
+  {   /* ordinary insertion checks */
+    if (NULL != next_id)
     {
-      printf(_("You must NOT specify an URI and a filename.\n"));
+      fprintf (stderr,
+               _ ("Option `%s' makes no sense without option `%s'.\n"),
+               "-N",
+               "-P");
       ret = -1;
       return;
     }
-  if (NULL != pseudonym)
+    if (NULL != this_id)
     {
-      if (NULL == this_id)
-        {
-          fprintf(stderr,
-                  _("Option `%s' is required when using option `%s'.\n"),
-                  "-t",
-                  "-P");
-          ret = -1;
-          return;
-        }
-    }
-  else
-    { /* ordinary insertion checks */
-      if (NULL != next_id)
-        {
-          fprintf(stderr,
-                  _("Option `%s' makes no sense without option `%s'.\n"),
-                  "-N",
-                  "-P");
-          ret = -1;
-          return;
-        }
-      if (NULL != this_id)
-        {
-          fprintf(stderr,
-                  _("Option `%s' makes no sense without option `%s'.\n"),
-                  "-t",
-                  "-P");
-          ret = -1;
-          return;
-        }
+      fprintf (stderr,
+               _ ("Option `%s' makes no sense without option `%s'.\n"),
+               "-t",
+               "-P");
+      ret = -1;
+      return;
     }
+  }
   cfg = c;
-  ctx = GNUNET_FS_start(cfg,
-                        "gnunet-publish",
-                        &progress_cb,
-                        NULL,
-                        GNUNET_FS_FLAGS_NONE,
-                        GNUNET_FS_OPTIONS_END);
+  ctx = GNUNET_FS_start (cfg,
+                         "gnunet-publish",
+                         &progress_cb,
+                         NULL,
+                         GNUNET_FS_FLAGS_NONE,
+                         GNUNET_FS_OPTIONS_END);
   if (NULL == ctx)
-    {
-      fprintf(stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
-      ret = 1;
-      return;
-    }
-  GNUNET_SCHEDULER_add_shutdown(&do_stop_task, NULL);
+  {
+    fprintf (stderr, _ ("Could not initialize `%s' subsystem.\n"), "FS");
+    ret = 1;
+    return;
+  }
+  GNUNET_SCHEDULER_add_shutdown (&do_stop_task, NULL);
   if (NULL != pseudonym)
-    identity = GNUNET_IDENTITY_connect(cfg, &identity_cb, args[0]);
+    identity = GNUNET_IDENTITY_connect (cfg, &identity_cb, args[0]);
   else
-    identity_continuation(args[0]);
+    identity_continuation (args[0]);
 }
 
 
@@ -878,121 +878,121 @@ run(void *cls,
  * @return 0 ok, 1 on error
  */
 int
-main(int argc, char *const *argv)
+main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] =
-  { GNUNET_GETOPT_option_uint('a',
-                              "anonymity",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired LEVEL of sender-anonymity"),
-                              &bo.anonymity_level),
-    GNUNET_GETOPT_option_flag(
+  { GNUNET_GETOPT_option_uint ('a',
+                               "anonymity",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired LEVEL of sender-anonymity"),
+                               &bo.anonymity_level),
+    GNUNET_GETOPT_option_flag (
       'D',
       "disable-extractor",
-      gettext_noop("do not use libextractor to add keywords or metadata"),
+      gettext_noop ("do not use libextractor to add keywords or metadata"),
       &disable_extractor),
-    GNUNET_GETOPT_option_flag('E',
-                              "enable-creation-time",
-                              gettext_noop(
-                                "enable adding the creation time to the "
-                                "metadata of the uploaded file"),
-                              &enable_creation_time),
-    GNUNET_GETOPT_option_flag('e',
-                              "extract",
-                              gettext_noop(
-                                "print list of extracted keywords that would "
-                                "be used, but do not perform upload"),
-                              &extract_only),
-    GNUNET_FS_GETOPT_KEYWORDS(
+    GNUNET_GETOPT_option_flag ('E',
+                               "enable-creation-time",
+                               gettext_noop (
+                                 "enable adding the creation time to the "
+                                 "metadata of the uploaded file"),
+                               &enable_creation_time),
+    GNUNET_GETOPT_option_flag ('e',
+                               "extract",
+                               gettext_noop (
+                                 "print list of extracted keywords that would "
+                                 "be used, but do not perform upload"),
+                               &extract_only),
+    GNUNET_FS_GETOPT_KEYWORDS (
       'k',
       "key",
       "KEYWORD",
-      gettext_noop(
+      gettext_noop (
         "add an additional keyword for the top-level "
         "file or directory (this option can be specified multiple times)"),
       &topKeywords),
-    GNUNET_FS_GETOPT_METADATA(
+    GNUNET_FS_GETOPT_METADATA (
       'm',
       "meta",
       "TYPE:VALUE",
-      gettext_noop("set the meta-data for the given TYPE to the given VALUE"),
+      gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
       &meta),
-    GNUNET_GETOPT_option_flag(
+    GNUNET_GETOPT_option_flag (
       'n',
       "noindex",
-      gettext_noop("do not index, perform full insertion (stores "
-                   "entire file in encrypted form in GNUnet database)"),
+      gettext_noop ("do not index, perform full insertion (stores "
+                    "entire file in encrypted form in GNUnet database)"),
       &do_insert),
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_string (
       'N',
       "next",
       "ID",
-      gettext_noop("specify ID of an updated version to be "
-                   "published in the future (for namespace insertions only)"),
+      gettext_noop ("specify ID of an updated version to be "
+                    "published in the future (for namespace insertions only)"),
       &next_id),
-    GNUNET_GETOPT_option_uint('p',
-                              "priority",
-                              "PRIORITY",
-                              gettext_noop(
-                                "specify the priority of the content"),
-                              &bo.content_priority),
-    GNUNET_GETOPT_option_string('P',
-                                "pseudonym",
-                                "NAME",
-                                gettext_noop(
-                                  "publish the files under the pseudonym "
-                                  "NAME (place file into namespace)"),
-                                &pseudonym),
-    GNUNET_GETOPT_option_uint('r',
-                              "replication",
-                              "LEVEL",
-                              gettext_noop(
-                                "set the desired replication LEVEL"),
-                              &bo.replication_level),
-    GNUNET_GETOPT_option_flag('s',
-                              "simulate-only",
-                              gettext_noop(
-                                "only simulate the process but do not do "
-                                "any actual publishing (useful to compute URIs)"),
-                              &do_simulate),
-    GNUNET_GETOPT_option_string('t',
-                                "this",
-                                "ID",
-                                gettext_noop(
-                                  "set the ID of this version of the publication "
-                                  "(for namespace insertions only)"),
-                                &this_id),
-    GNUNET_GETOPT_option_string(
+    GNUNET_GETOPT_option_uint ('p',
+                               "priority",
+                               "PRIORITY",
+                               gettext_noop (
+                                 "specify the priority of the content"),
+                               &bo.content_priority),
+    GNUNET_GETOPT_option_string ('P',
+                                 "pseudonym",
+                                 "NAME",
+                                 gettext_noop (
+                                   "publish the files under the pseudonym "
+                                   "NAME (place file into namespace)"),
+                                 &pseudonym),
+    GNUNET_GETOPT_option_uint ('r',
+                               "replication",
+                               "LEVEL",
+                               gettext_noop (
+                                 "set the desired replication LEVEL"),
+                               &bo.replication_level),
+    GNUNET_GETOPT_option_flag ('s',
+                               "simulate-only",
+                               gettext_noop (
+                                 "only simulate the process but do not do "
+                                 "any actual publishing (useful to compute URIs)"),
+                               &do_simulate),
+    GNUNET_GETOPT_option_string ('t',
+                                 "this",
+                                 "ID",
+                                 gettext_noop (
+                                   "set the ID of this version of the publication "
+                                   "(for namespace insertions only)"),
+                                 &this_id),
+    GNUNET_GETOPT_option_string (
       'u',
       "uri",
       "URI",
-      gettext_noop(
+      gettext_noop (
         "URI to be published (can be used instead of passing a "
         "file to add keywords to the file with the respective URI)"),
       &uri_string),
 
-    GNUNET_GETOPT_option_verbose(&verbose),
+    GNUNET_GETOPT_option_verbose (&verbose),
 
     GNUNET_GETOPT_OPTION_END };
 
   bo.expiration_time =
-    GNUNET_TIME_year_to_time(GNUNET_TIME_get_current_year() + 2);
+    GNUNET_TIME_year_to_time (GNUNET_TIME_get_current_year () + 2);
 
-  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
+  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
     return 2;
   ret =
     (GNUNET_OK ==
-     GNUNET_PROGRAM_run(argc,
-                        argv,
-                        "gnunet-publish [OPTIONS] FILENAME",
-                        gettext_noop("Publish a file or directory on GNUnet"),
-                        options,
-                        &run,
-                        NULL))
+     GNUNET_PROGRAM_run (argc,
+                         argv,
+                         "gnunet-publish [OPTIONS] FILENAME",
+                         gettext_noop ("Publish a file or directory on GNUnet"),
+                         options,
+                         &run,
+                         NULL))
     ? ret
     : 1;
-  GNUNET_free((void *)argv);
+  GNUNET_free ((void *) argv);
   return ret;
 }