-help seaspider some more

[oweals/gnunet.git] / src / fs / gnunet-publish.c

diff --git a/src/fs/gnunet-publish.c b/src/fs/gnunet-publish.c
index 70964590d69bc38eb8db016c3269ee3099f73e27..a1b26dbd5845da11eae06fee745c23cdd009a762 100644 (file)
--- a/src/fs/gnunet-publish.c
+++ b/src/fs/gnunet-publish.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.

-     (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009, 2010 Christian Grothoff (and other contributing authors)
+     (C) 2001, 2002, 2004, 2005, 2006, 2007, 2009, 2010, 2011 Christian Grothoff (and other contributing authors)

 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published

-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your

      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but


@@ -28,8 +28,6 @@
 #include "platform.h"
 #include "gnunet_fs_service.h"
 
 #include "platform.h"
 #include "gnunet_fs_service.h"
 

-#define DEFAULT_EXPIRATION GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_YEARS, 2)
-

 static int ret;
 
 static int verbose;
 static int ret;
 
 static int verbose;


@@ -38,17 +36,15 @@ static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 static struct GNUNET_FS_Handle *ctx;
 
 
 static struct GNUNET_FS_Handle *ctx;
 

-static struct GNUNET_SCHEDULER_Handle *sched;
-

 static struct GNUNET_FS_PublishContext *pc;
 
 static struct GNUNET_CONTAINER_MetaData *meta;
 
 static struct GNUNET_FS_Uri *topKeywords;
 
 static struct GNUNET_FS_PublishContext *pc;
 
 static struct GNUNET_CONTAINER_MetaData *meta;
 
 static struct GNUNET_FS_Uri *topKeywords;
 

-static unsigned int anonymity = 1;
+static struct GNUNET_FS_Uri *uri;

 
 

-static unsigned int priority = 365;
+static struct GNUNET_FS_BlockOptions bo = { {0LL}, 1, 365, 1 };

 
 static char *uri_string;
 
 
 static char *uri_string;
 


@@ -70,24 +66,60 @@ static int do_disable_creation_time;
 
 static GNUNET_SCHEDULER_TaskIdentifier kill_task;
 
 
 static GNUNET_SCHEDULER_TaskIdentifier kill_task;
 

+static struct GNUNET_FS_DirScanner *ds;
+
+static struct GNUNET_FS_ShareTreeItem * directory_scan_result;

 
 

-static void 
-do_stop_task (void *cls,
-             const struct GNUNET_SCHEDULER_TaskContext *tc)
+static struct GNUNET_FS_Namespace *namespace;
+
+/**
+ * FIXME: docu
+ */
+static void
+do_stop_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)

 {
   struct GNUNET_FS_PublishContext *p;
 
 {
   struct GNUNET_FS_PublishContext *p;
 

+  kill_task = GNUNET_SCHEDULER_NO_TASK;

   if (pc != NULL)
   if (pc != NULL)

-    {
-      p = pc;
-      pc = NULL;
-      GNUNET_FS_publish_stop (p);
-    }
+  {
+    p = pc;
+    pc = NULL;
+    GNUNET_FS_publish_stop (p);
+  }
+  if (NULL != meta)
+  {
+    GNUNET_CONTAINER_meta_data_destroy (meta);
+    meta = NULL;
+  }  
+}
+
+
+/**
+ * Stop the directory scanner (we had an error).
+ *
+ * @param cls closure
+ * @param tc scheduler context
+ */
+static void
+stop_scanner_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  kill_task = GNUNET_SCHEDULER_NO_TASK;
+  GNUNET_FS_directory_scan_abort (ds);
+  ds = NULL;
+  if (namespace != NULL)
+  {
+    GNUNET_FS_namespace_delete (namespace, GNUNET_NO);
+    namespace = NULL;
+  }
+  GNUNET_FS_stop (ctx);
+  ctx = NULL;
+  ret = 1;

 }
 
 
 /**
 }
 
 
 /**

- * Called by FS client to give information about the progress of an 
+ * Called by FS client to give information about the progress of an

  * operation.
  *
  * @param cls closure
  * operation.
  *
  * @param cls closure


@@ -100,76 +132,65 @@ do_stop_task (void *cls,
  *         field in the GNUNET_FS_ProgressInfo struct.
  */
 static void *
  *         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)
 {
   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 (sched,
-                                  kill_task);
-         kill_task = GNUNET_SCHEDULER_NO_TASK;
-       }
-      GNUNET_SCHEDULER_add_continuation (sched,
-                                        &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);
+      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);
       GNUNET_free (s);

-      if (info->value.publish.pctx == NULL)
-       {
-         if (kill_task != GNUNET_SCHEDULER_NO_TASK)
-           {
-             GNUNET_SCHEDULER_cancel (sched,
-                                      kill_task);
-             kill_task = GNUNET_SCHEDULER_NO_TASK;
-           }
-         GNUNET_SCHEDULER_add_continuation (sched,
-                                            &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;
+    }
+    kill_task = GNUNET_SCHEDULER_add_now (&do_stop_task, NULL);
+    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;
+      }
+      kill_task = GNUNET_SCHEDULER_add_now (&do_stop_task, NULL);
+    }
+    break;
+  case GNUNET_FS_STATUS_PUBLISH_STOPPED:
+    GNUNET_break (NULL == pc);
+    return NULL;
+  case GNUNET_FS_STATUS_UNINDEX_PROGRESS:
+    return NULL;
+  case GNUNET_FS_STATUS_UNINDEX_COMPLETED:
+    FPRINTF (stderr, "%s",  _("Cleanup after abort complete.\n"));
+    return NULL;
+  default:
+    FPRINTF (stderr, _("Unexpected status: %d\n"), info->status);
+    return NULL;
+  }
+  return "";                    /* non-null */

 }
 
 
 }
 
 


@@ -187,58 +208,33 @@ progress_cb (void *cls,
  * @return always 0
  */
 static int
  * @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 ( (format != EXTRACTOR_METAFORMAT_UTF8) &&
-       (format != EXTRACTOR_METAFORMAT_C_STRING) )
+  if ((format != EXTRACTOR_METAFORMAT_UTF8) &&
+      (format != EXTRACTOR_METAFORMAT_C_STRING))

     return 0;
     return 0;

-  if (type == EXTRACTOR_METATYPE_FILENAME) 
+  if (type == EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME)

     return 0;
     return 0;

-  fprintf (stdout, 
-          "%s - %s",
-          EXTRACTOR_metatype_to_string (type),
-          data);
+  FPRINTF (stdout, "\t%s - %s\n", EXTRACTOR_metatype_to_string (type), data);

   return 0;
 }
 
 
 /**
   return 0;
 }
 
 
 /**

- * Merge metadata entries.
+ * Iterator printing keywords

  *
  *

- * @param cls closure, target metadata structure
- * @param plugin_name name of the plugin that generated the meta data
- * @param type type of the meta data
- * @param format format of data
- * @param data_mime_type mime type of data
- * @param data value of the meta data
- * @param data_size number of bytes in data
- * @return always 0
+ * @param cls closure
+ * @param keyword the keyword
+ * @param is_mandatory is the keyword mandatory (in a search)
+ * @return GNUNET_OK to continue to iterate, GNUNET_SYSERR to abort

  */
 static int
  */
 static int

-meta_merger (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)
+keyword_printer (void *cls, const char *keyword, int is_mandatory)

 {
 {

-  struct GNUNET_CONTAINER_MetaData *m = cls;
-
-  GNUNET_CONTAINER_meta_data_insert (m,
-                                    plugin_name,
-                                    type, 
-                                    format,
-                                    data_mime_type,
-                                    data,
-                                    data_size);
-  return 0;
+  FPRINTF (stdout, "\t%s\n", keyword);
+  return GNUNET_OK;

 }
 
 
 }
 
 


@@ -252,92 +248,286 @@ meta_merger (void *cls,
  * @param length length of the file or directory
  * @param m metadata for the file or directory (can be modified)
  * @param uri pointer to the keywords that will be used for this entry (can be modified)
  * @param length length of the file or directory
  * @param m metadata for the file or directory (can be modified)
  * @param uri pointer to the keywords that will be used for this entry (can be modified)

- * @param anonymity pointer to selected anonymity level (can be modified)
- * @param priority pointer to selected priority (can be modified)
- * @param expirationTime pointer to selected expiration time (can be modified)
+ * @param bo block options
+ * @param do_index should we index?

  * @param client_info pointer to client context set upon creation (can be modified)
  * @return GNUNET_OK to continue, GNUNET_NO to remove
  *         this entry from the directory, GNUNET_SYSERR
  *         to abort the iteration
  */
 static int
  * @param client_info pointer to client context set upon creation (can be modified)
  * @return GNUNET_OK to continue, GNUNET_NO to remove
  *         this entry from the directory, GNUNET_SYSERR
  *         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,
-                  unsigned int *anonymity,
-                  unsigned int *priority,
-                  struct GNUNET_TIME_Absolute *expirationTime,
-                  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;
   struct GNUNET_FS_Uri *new_uri;
 
 {
   char *fn;
   char *fs;
   struct GNUNET_FS_Uri *new_uri;
 

+  if (cls == fi)
+    return GNUNET_OK;

   if (NULL != topKeywords)
   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_iterate (meta,
-                                         &meta_merger,
-                                         m);
-      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);
     GNUNET_CONTAINER_meta_data_add_publication_date (m);

+  if ( (disable_extractor) &&
+       (NULL != *uri) )
+  {
+    GNUNET_FS_uri_destroy (*uri);
+    *uri = NULL;
+  }

   if (extract_only)
   if (extract_only)

-    {
-      fn = GNUNET_CONTAINER_meta_data_get_by_type (m,
-                                                  EXTRACTOR_METATYPE_FILENAME);
-      fs = GNUNET_STRINGS_byte_size_fancy (length);
-      fprintf (stdout,
-              _("Keywords for file `%s' (%s)\n"),
-              fn,
-              fs);
-      GNUNET_free (fn);
-      GNUNET_free (fs);
-      GNUNET_CONTAINER_meta_data_iterate (m,
-                                         &meta_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, "%s",  "\n");
+  }

   if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (m))
   if (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (m))

-    GNUNET_FS_file_information_inspect (fi,
-                                       &publish_inspector,
-                                       NULL);
+    GNUNET_FS_file_information_inspect (fi, &publish_inspector, fi);

   return GNUNET_OK;
 }
 
 
   return GNUNET_OK;
 }
 
 

-static void 
-uri_ksk_continuation (void *cls,
-                     const struct GNUNET_FS_Uri *uri,
-                     const char *emsg)
+/**
+ * FIXME: docu
+ */
+static void
+uri_sks_continuation (void *cls, const struct GNUNET_FS_Uri *ksk_uri,
+                      const char *emsg)
+{
+  if (emsg != NULL)
+  {
+    FPRINTF (stderr, "%s\n", emsg);
+    ret = 1;
+  }
+  GNUNET_FS_uri_destroy (uri);
+  uri = NULL;
+  GNUNET_FS_stop (ctx);
+  ctx = NULL;
+}
+
+
+/**
+ * FIXME: docu
+ */
+static void
+uri_ksk_continuation (void *cls, const struct GNUNET_FS_Uri *ksk_uri,
+                      const char *emsg)

 {
 {

+  struct GNUNET_FS_Namespace *ns;
+

   if (emsg != NULL)
   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;
     }
       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_uri_destroy (uri);
+  uri = NULL;

   GNUNET_FS_stop (ctx);
   GNUNET_FS_stop (ctx);

+  ctx = NULL;
+}
+
+
+/**
+ * FIXME: docu
+ */
+static struct GNUNET_FS_FileInformation *
+get_file_information (struct GNUNET_FS_ShareTreeItem *item)
+{
+  struct GNUNET_FS_FileInformation *fi;
+  struct GNUNET_FS_FileInformation *fic;
+  struct GNUNET_FS_ShareTreeItem *child;
+
+  if (item->is_directory == GNUNET_YES)
+  {
+    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
+  {
+    fi = GNUNET_FS_file_information_create_from_file (
+        ctx, NULL, item->filename,
+        item->ksk_uri, item->meta, !do_insert,
+        &bo);
+  }
+  return fi;
+}
+
+
+/**
+ * FIXME: docu
+ */
+static void
+directory_trim_complete ()
+{
+  struct GNUNET_FS_FileInformation *fi;
+
+  fi = get_file_information (directory_scan_result);
+  GNUNET_FS_share_tree_free (directory_scan_result);
+  directory_scan_result = NULL;
+  if (fi == NULL)
+  {
+    FPRINTF (stderr, "%s", _("Could not publish\n"));
+    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);
+    if (kill_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (kill_task);
+      kill_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    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);
+  if (NULL == pc)
+  {
+    FPRINTF (stderr, "%s",  _("Could not start publishing.\n"));
+    GNUNET_FS_stop (ctx);
+    ret = 1;
+    return;
+  }
+}
+
+
+/**
+ * Function called by the directory scanner as we build the tree
+ * that we will need to publish later.
+ *
+ * @param cls closure
+ * @param filename which file we are making progress on
+ * @param is_directory GNUNET_YES if this is a directory,
+ *                     GNUNET_NO if this is a file
+ *                     GNUNET_SYSERR if it is neither (or unknown)
+ * @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)
+{
+  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);      
+    }
+    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 ();
+    break;
+  case GNUNET_FS_DIRSCANNER_INTERNAL_ERROR:
+    FPRINTF (stdout, "%s", _("Internal error scanning directory.\n"));
+    if (kill_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (kill_task);
+      kill_task = GNUNET_SCHEDULER_NO_TASK;
+    }
+    kill_task = GNUNET_SCHEDULER_add_now (&stop_scanner_task, NULL);
+    break;
+  default:
+    GNUNET_assert (0);
+    break;
+  }
+  fflush (stdout);

 }
 
 
 }
 
 


@@ -345,301 +535,134 @@ uri_ksk_continuation (void *cls,
  * Main function that will be run by the scheduler.
  *
  * @param cls closure
  * Main function that will be run by the scheduler.
  *
  * @param cls closure

- * @param s the scheduler to use

  * @param args remaining command-line arguments
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param c configuration
  */
 static void
  * @param args remaining command-line arguments
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param c configuration
  */
 static void

-run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
-     char *const *args,
-     const char *cfgfile,
+run (void *cls, char *const *args, const char *cfgfile,

      const struct GNUNET_CONFIGURATION_Handle *c)
 {
      const struct GNUNET_CONFIGURATION_Handle *c)
 {

-  struct GNUNET_FS_FileInformation *fi;
-  struct GNUNET_FS_Namespace *namespace;
-  struct EXTRACTOR_PluginList *l;
-  struct stat sbuf;

   char *ex;
   char *emsg;
   char *ex;
   char *emsg;

-  struct GNUNET_FS_Uri *uri;
-  
-  sched = s;
+

   /* check arguments */
   /* check arguments */

-  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) && (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))
   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 (_("You must NOT specify an URI and a filename.\n"));
+      FPRINTF (stderr, _("Option `%s' is required when using option `%s'.\n"),
+               "-t", "-P");

       ret = -1;
       return;
     }
       ret = -1;
       return;
     }

-  if ((uri_string != NULL) && (extract_only))
+  }
+  else
+  {                             /* ordinary insertion checks */
+    if (NULL != next_id)

     {
     {

-      printf (_("Cannot extract metadata from a URI!\n"));
+      FPRINTF (stderr, _("Option `%s' makes no sense without option `%s'.\n"),
+               "-N", "-P");

       ret = -1;
       return;
     }
       ret = -1;
       return;
     }

-  if (pseudonym != NULL)
+    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;
-        }
-    }
-  if (args[0] == NULL)
-    {
-      fprintf (stderr,
-              _("Need the name of a file to publish!\n"));
-      ret = 1;
+      FPRINTF (stderr, _("Option `%s' makes no sense without option `%s'.\n"),
+               "-t", "-P");
+      ret = -1;

       return;
     }
       return;
     }

+  }

   cfg = c;
   cfg = c;

-  ctx = GNUNET_FS_start (sched,
-                        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)
   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 = 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;
-       }
-    }
-  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);
-         GNUNET_FS_stop (ctx);
-         ret = 1;
-         return;         
-       }
-      GNUNET_FS_publish_ksk (ctx,
-                            topKeywords,
-                            meta,
-                            uri,
-                            GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION),
-                            anonymity,
-                            priority,
-                            GNUNET_FS_PUBLISH_OPTION_NONE,
-                            &uri_ksk_continuation,
-                            NULL);
-      return;
-    }
-  l = NULL;
-  if (! disable_extractor)
-    {
-      l = EXTRACTOR_plugin_add_defaults (EXTRACTOR_OPTION_DEFAULT_POLICY);
-      if (GNUNET_OK ==
-         GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS",
-                                                &ex))
-       {
-         if (strlen (ex) > 0)
-           l = EXTRACTOR_plugin_add_config (l, ex, EXTRACTOR_OPTION_DEFAULT_POLICY);
-         GNUNET_free (ex);
-       }
-    }
-  emsg = NULL;
-  if (0 != STAT (args[0], &sbuf))
-    {
-      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 (NULL,
-                                                            args[0],
-                                                            &GNUNET_FS_directory_scanner_default,
-                                                            l,
-                                                            !do_insert,
-                                                            anonymity,
-                                                            priority,
-                                                            GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION),
-                                                            &emsg);
-    }
-  else
-    {
-      fi = GNUNET_FS_file_information_create_from_file (NULL,
-                                                       args[0],
-                                                       NULL,
-                                                       NULL,
-                                                       !do_insert,
-                                                       anonymity,
-                                                       priority,
-                                                       GNUNET_TIME_relative_to_absolute (DEFAULT_EXPIRATION));
-      GNUNET_break (fi != NULL);
-    }
-  EXTRACTOR_plugin_remove_all (l);  
-  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);
+      FPRINTF (stderr, _("Could not create namespace `%s'\n"), pseudonym);

       GNUNET_FS_stop (ctx);
       ret = 1;
       return;
     }
       GNUNET_FS_stop (ctx);
       ret = 1;
       return;
     }

-  GNUNET_FS_file_information_inspect (fi,
-                                     &publish_inspector,
-                                     NULL);
-  if (extract_only)
+  }
+  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)
       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);
-  if (NULL == pc)
-    {
-      fprintf (stderr,
-              _("Could not start publishing.\n"));
+        GNUNET_FS_namespace_delete (namespace, GNUNET_NO);

       GNUNET_FS_stop (ctx);
       ret = 1;
       return;
     }
       GNUNET_FS_stop (ctx);
       ret = 1;
       return;
     }

-  kill_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                           GNUNET_TIME_UNIT_FOREVER_REL,
-                                           &do_stop_task,
-                                           NULL);
+    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;
+  }
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, "FS", "EXTRACTORS", &ex))
+    ex = NULL;
+  if (0 != ACCESS (args[0], R_OK))
+  {
+    FPRINTF (stderr,
+            _("Failed to access `%s': %s\n"),
+            args[0],
+            STRERROR (errno));
+    return;
+  }
+  ds = GNUNET_FS_directory_scan_start (args[0],
+                                      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"));
+    return;
+  }
+  kill_task =
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &do_stop_task,
+                                    NULL);

 }
 
 
 }
 
 

-/**
- * gnunet-publish command line options
- */
-static struct GNUNET_GETOPT_CommandLineOption options[] = {
-  {'a', "anonymity", "LEVEL",
-   gettext_noop ("set the desired LEVEL of sender-anonymity"),
-   1, &GNUNET_GETOPT_set_uint, &anonymity},
-  {'d', "disable-creation-time", NULL,
-   gettext_noop
-   ("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"),
-   0, &GNUNET_GETOPT_set_one, &disable_extractor},
-  {'e', "extract", NULL,
-   gettext_noop
-   ("print list of extracted keywords that would be used, but do not perform upload"),
-   0, &GNUNET_GETOPT_set_one, &extract_only},
-  {'k', "key", "KEYWORD",
-   gettext_noop
-   ("add an additional keyword for the top-level file or directory"
-    " (this option can be specified multiple times)"),
-   1, &GNUNET_FS_getopt_set_keywords, &topKeywords},
-  // *: option not yet used... (can handle in a pass over FI)
-  {'m', "meta", "TYPE:VALUE",
-   gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
-   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)"),
-   0, &GNUNET_GETOPT_set_one, &do_insert},
-  {'N', "next", "ID",
-   gettext_noop
-   ("specify ID of an updated version to be published in the future"
-    " (for namespace insertions only)"),
-   1, &GNUNET_GETOPT_set_string, &next_id},
-  {'p', "priority", "PRIORITY",
-   gettext_noop ("specify the priority of the content"),
-   1, &GNUNET_GETOPT_set_uint, &priority},
-  {'P', "pseudonym", "NAME",
-   gettext_noop
-   ("publish the files under the pseudonym NAME (place file into namespace)"),
-   1, &GNUNET_GETOPT_set_string, &pseudonym},
-  // *: option not yet used... (need FS API support!)
-  {'s', "simulate-only", NULL,
-   gettext_noop ("only simulate the process but do not do any "
-                 "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)"),
-   1, &GNUNET_GETOPT_set_string, &this_id},
-  // *: option not yet used... (need FS API support!)
-  {'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}, 
-  {'V', "verbose", NULL,
-   gettext_noop ("be verbose (print progress information)"),
-   0, &GNUNET_GETOPT_set_one, &verbose},
-  GNUNET_GETOPT_OPTION_END
-};
-
-

 /**
  * The main function to publish content to GNUnet.
  *
 /**
  * The main function to publish content to GNUnet.
  *


@@ -650,96 +673,74 @@ static struct GNUNET_GETOPT_CommandLineOption options[] = {
 int
 main (int argc, char *const *argv)
 {
 int
 main (int argc, char *const *argv)
 {

+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    {'a', "anonymity", "LEVEL",
+     gettext_noop ("set the desired LEVEL of sender-anonymity"),
+     1, &GNUNET_GETOPT_set_uint, &bo.anonymity_level},
+    {'d', "disable-creation-time", NULL,
+     gettext_noop
+     ("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"),
+     0, &GNUNET_GETOPT_set_one, &disable_extractor},
+    {'e', "extract", NULL,
+     gettext_noop
+     ("print list of extracted keywords that would be used, but do not perform upload"),
+     0, &GNUNET_GETOPT_set_one, &extract_only},
+    {'k', "key", "KEYWORD",
+     gettext_noop
+     ("add an additional keyword for the top-level file or directory"
+      " (this option can be specified multiple times)"),
+     1, &GNUNET_FS_getopt_set_keywords, &topKeywords},
+    {'m', "meta", "TYPE:VALUE",
+     gettext_noop ("set the meta-data for the given TYPE to the given VALUE"),
+     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)"),
+     0, &GNUNET_GETOPT_set_one, &do_insert},
+    {'N', "next", "ID",
+     gettext_noop
+     ("specify ID of an updated version to be published in the future"
+      " (for namespace insertions only)"),
+     1, &GNUNET_GETOPT_set_string, &next_id},
+    {'p', "priority", "PRIORITY",
+     gettext_noop ("specify the priority of the content"),
+     1, &GNUNET_GETOPT_set_uint, &bo.content_priority},
+    {'P', "pseudonym", "NAME",
+     gettext_noop
+     ("publish the files under the pseudonym NAME (place file into namespace)"),
+     1, &GNUNET_GETOPT_set_string, &pseudonym},
+    {'r', "replication", "LEVEL",
+     gettext_noop ("set the desired replication LEVEL"),
+     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)"),
+     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)"),
+     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},
+    {'V', "verbose", NULL,
+     gettext_noop ("be verbose (print progress information)"),
+     0, &GNUNET_GETOPT_set_one, &verbose},
+    GNUNET_GETOPT_OPTION_END
+  };
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+             "GNUnet publish starts\n");
+  bo.expiration_time =
+      GNUNET_FS_year_to_time (GNUNET_FS_get_current_year () + 2);

   return (GNUNET_OK ==
   return (GNUNET_OK ==

-          GNUNET_PROGRAM_run (argc,
-                              argv,
-                              "gnunet-publish",
+          GNUNET_PROGRAM_run (argc, argv, "gnunet-publish [OPTIONS] FILENAME",

                               gettext_noop
                               gettext_noop

-                              ("Publish files on GNUnet."),
+                              ("Publish a file or directory on GNUnet"),

                               options, &run, NULL)) ? ret : 1;
 }
 
 /* end of gnunet-publish.c */
                               options, &run, NULL)) ? ret : 1;
 }
 
 /* end of gnunet-publish.c */

-
-////////////////////////////////////////////////////////////////
-
-#if 0
-/**
- * Print progess message.
- */
-static void *
-printstatus (void *ctx, const GNUNET_FSUI_Event * event)
-{
-  unsigned long long delta;
-  char *fstring;
-
-  switch (event->type)
-    {
-    case GNUNET_FSUI_upload_progress:
-      if (*verboselevel)
-        {
-          char *ret;
-          GNUNET_CronTime now;
-
-          now = GNUNET_get_time ();
-          delta = event->data.UploadProgress.eta - now;
-          if (event->data.UploadProgress.eta < now)
-            delta = 0;
-          ret = GNUNET_get_time_interval_as_fancy_string (delta);
-          PRINTF (_("%16llu of %16llu bytes inserted "
-                    "(estimating %6s to completion) - %s\n"),
-                  event->data.UploadProgress.completed,
-                  event->data.UploadProgress.total,
-                  ret, event->data.UploadProgress.filename);
-          GNUNET_free (ret);
-        }
-      break;
-    case GNUNET_FSUI_upload_completed:
-      if (*verboselevel)
-        {
-          delta = GNUNET_get_time () - start_time;
-          PRINTF (_("Upload of `%s' complete, "
-                    "%llu bytes took %llu seconds (%8.3f KiB/s).\n"),
-                  event->data.UploadCompleted.filename,
-                  event->data.UploadCompleted.total,
-                  delta / GNUNET_CRON_SECONDS,
-                  (delta == 0)
-                  ? (double) (-1.0)
-                  : (double) (event->data.UploadCompleted.total
-                              / 1024.0 * GNUNET_CRON_SECONDS / delta));
-        }
-      fstring = GNUNET_ECRS_uri_to_string (event->data.UploadCompleted.uri);
-      printf (_("File `%s' has URI: %s\n"),
-              event->data.UploadCompleted.filename, fstring);
-      GNUNET_free (fstring);
-      if (ul == event->data.UploadCompleted.uc.pos)
-        {
-          postProcess (event->data.UploadCompleted.uri);
-          errorCode = 0;
-          GNUNET_shutdown_initiate ();
-        }
-      break;
-    case GNUNET_FSUI_upload_aborted:
-      printf (_("\nUpload aborted.\n"));
-      errorCode = 2;
-      GNUNET_shutdown_initiate ();
-      break;
-    case GNUNET_FSUI_upload_error:
-      printf (_("\nError uploading file: %s"),
-              event->data.UploadError.message);
-      errorCode = 3;
-      GNUNET_shutdown_initiate ();
-      break;
-    case GNUNET_FSUI_upload_started:
-    case GNUNET_FSUI_upload_stopped:
-      break;
-    default:
-      printf (_("\nUnexpected event: %d\n"), event->type);
-      GNUNET_GE_BREAK (ectx, 0);
-      break;
-    }
-  return NULL;
-}
-#endif
-
-/* end of gnunet-publish.c */