1 files changed, 547 insertions, 529 deletions

diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index 84cbf0aac..24baa4d38 100644
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -16,7 +16,7 @@
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file fs/gnunet-publish.c
  * @brief publishing files on GNUnet
@@ -67,7 +67,7 @@ static struct GNUNET_FS_Uri *topKeywords;
 /**
  * Options we set for published blocks.
  */
-static struct GNUNET_FS_BlockOptions bo = {{0LL}, 1, 365, 1};
+static struct GNUNET_FS_BlockOptions bo = { { 0LL }, 1, 365, 1 };
 
 /**
  * Value of URI provided on command-line (when not publishing
@@ -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,94 +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)
     {
-      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 ();
+    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;
     }
-    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 */
 }
 
@@ -306,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))
@@ -320,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;
 }
@@ -337,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;
 }
 
@@ -362,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;
@@ -378,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;
-  }
-  if (NULL != topKeywords)
-  {
-    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);
+      GNUNET_FS_uri_destroy(*uri);
+      *uri = NULL;
     }
-    else
+  if (NULL != topKeywords)
     {
-      *uri = topKeywords;
+      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;
     }
-    topKeywords = NULL;
-  }
   if (NULL != meta)
-  {
-    GNUNET_CONTAINER_meta_data_merge (m, meta);
-    GNUNET_CONTAINER_meta_data_destroy (meta);
-    meta = NULL;
-  }
+    {
+      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;
 }
 
@@ -436,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();
 }
 
 
@@ -459,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);
 }
 
 
@@ -497,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)
     {
-      const char *mime = GNUNET_FS_DIRECTORY_MIME;
-      item->ksk_uri = GNUNET_FS_uri_ksk_create_from_args (1, &mime);
+      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));
+        }
     }
-    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)
+  else
     {
-      fic = get_file_information (child);
-      GNUNET_break (GNUNET_OK == GNUNET_FS_file_information_add (fi, fic));
+      fi = GNUNET_FS_file_information_create_from_file(ctx,
+                                                       NULL,
+                                                       item->filename,
+                                                       item->ksk_uri,
+                                                       item->meta,
+                                                       !do_insert,
+                                                       &bo);
     }
-  }
-  else
-  {
-    fi = GNUNET_FS_file_information_create_from_file (ctx,
-                                                      NULL,
-                                                      item->filename,
-                                                      item->ksk_uri,
-                                                      item->meta,
-                                                      ! do_insert,
-                                                      &bo);
-  }
   return fi;
 }
 
@@ -554,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;
+    }
 }
 
 
@@ -609,57 +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)
     {
-      if (is_directory == GNUNET_YES)
-        fprintf (stdout, _ ("Scanning directory `%s'.\n"), filename);
-      else
-        fprintf (stdout, _ ("Scanning file `%s'.\n"), filename);
+    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;
     }
-    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);
+  fflush(stdout);
 }
 
 
@@ -670,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;
-  }
-  if (NULL != uri_string)
-  {
-    emsg = NULL;
-    if (NULL == (uri = GNUNET_FS_uri_parse (uri_string, &emsg)))
     {
-      fprintf (stderr, _ ("Failed to parse URI: %s\n"), emsg);
-      GNUNET_free (emsg);
+      fprintf(stderr, _("Selected pseudonym `%s' unknown\n"), pseudonym);
       ret = 1;
-      GNUNET_SCHEDULER_shutdown ();
+      GNUNET_SCHEDULER_shutdown();
+      return;
+    }
+  if (NULL != uri_string)
+    {
+      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);
       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);
 }
 
 
@@ -746,22 +763,22 @@ 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))
-  namespace = ego;
+  if (0 == strcmp(name, pseudonym))
+    namespace = ego;
 }
 
 
@@ -774,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;
-  }
-  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)
     {
-      fprintf (stderr,
-               _ ("Option `%s' is required when using option `%s'.\n"),
-               "-t",
-               "-P");
+      printf(_("Cannot extract metadata from a URI!\n"));
       ret = -1;
       return;
     }
-  }
-  else
-  { /* ordinary insertion checks */
-    if (NULL != next_id)
+  if (((NULL == uri_string) || (extract_only)) &&
+      ((NULL == args[0]) || (NULL != args[1])))
     {
-      fprintf (stderr,
-               _ ("Option `%s' makes no sense without option `%s'.\n"),
-               "-N",
-               "-P");
+      printf(_("You must specify one and only one filename for insertion.\n"));
       ret = -1;
       return;
     }
-    if (NULL != this_id)
+  if ((NULL != uri_string) && (NULL != args[0]))
     {
-      fprintf (stderr,
-               _ ("Option `%s' makes no sense without option `%s'.\n"),
-               "-t",
-               "-P");
+      printf(_("You must NOT specify an URI and a filename.\n"));
       ret = -1;
       return;
     }
-  }
+  if (NULL != pseudonym)
+    {
+      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);
+  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]);
 }
 
 
@@ -861,120 +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 (
-       'D',
-       "disable-extractor",
-       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 (
-       'k',
-       "key",
-       "KEYWORD",
-       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 (
-       'm',
-       "meta",
-       "TYPE:VALUE",
-       gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
-       &meta),
-     GNUNET_GETOPT_option_flag (
-       'n',
-       "noindex",
-       gettext_noop ("do not index, perform full insertion (stores "
-                     "entire file in encrypted form in GNUnet database)"),
-       &do_insert),
-     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)"),
-       &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 (
-       '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)"),
-       &uri_string),
-
-     GNUNET_GETOPT_option_verbose (&verbose),
-
-     GNUNET_GETOPT_OPTION_END};
+  { 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"),
+      &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(
+      'k',
+      "key",
+      "KEYWORD",
+      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(
+      'm',
+      "meta",
+      "TYPE:VALUE",
+      gettext_noop("set the meta-data for the given TYPE to the given VALUE"),
+      &meta),
+    GNUNET_GETOPT_option_flag(
+      'n',
+      "noindex",
+      gettext_noop("do not index, perform full insertion (stores "
+                   "entire file in encrypted form in GNUnet database)"),
+      &do_insert),
+    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)"),
+      &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(
+      '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)"),
+      &uri_string),
+
+    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))
-      ? ret
-      : 1;
-  GNUNET_free ((void *) argv);
+     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);
   return ret;
 }