1 files changed, 293 insertions, 0 deletions

diff --git a/src/fuse/readdir.c b/src/fuse/readdir.c
new file mode 100644
index 0000000..17145ae
--- /dev/null
+++ b/src/fuse/readdir.c
@@ -0,0 +1,293 @@
+/*
+ * reddir.c - FUSE read directory function
+ *
+ *  Created on: Mar 14, 2012
+ *      Author: MG, Christian Grothoff, Matthias Wachs,
+ *                      Krista Bennett, James Blackwell, Igor Wronsky
+ *
+ * Read directory
+ *
+ * This supersedes the old getdir() interface.  New applications
+ * should use this.
+ *
+ * The filesystem may choose between two modes of operation:
+ *
+ * 1) The readdir implementation ignores the offset parameter, and
+ * passes zero to the filler function's offset.  The filler
+ * function will not return '1' (unless an error happens), so the
+ * whole directory is read in a single readdir operation.  This
+ * works just like the old getdir() method.
+ *
+ * 2) The readdir implementation keeps track of the offsets of the
+ * directory entries.  It uses the offset parameter and always
+ * passes non-zero offset to the filler function.  When the buffer
+ * is full (or an error happens) the filler function will return
+ * '1'.
+ *
+ * Introduced in version 2.3
+ */
+
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <gnunet-fuse.h>
+#include <gnunet/gnunet_fs_service.h>
+#include <gnunet/gnunet_container_lib.h>
+#include "gnunet/gnunet_crypto_lib.h"
+#include <fuse.h>
+
+static int ret;
+
+static int verbose;
+
+static int delete_incomplete;
+
+static struct GNUNET_FS_DownloadContext *dc;
+
+static unsigned int parallelism = 16;
+
+static unsigned int request_parallelism = 4092;
+
+static int do_recursive;
+
+static int local_only;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static unsigned int anonymity = 1;
+
+struct GNUNET_FS_Handle *fs;
+
+static struct GNUNET_FS_Handle *ctx;
+
+struct GNUNET_CONTAINER_MultiHashMap *map;
+
+struct GNUNET_FS_Uri *uri;
+
+char *emsg;
+
+struct GNUNET_FUSE_path_info *r;
+
+
+
+
+static void
+cleanup_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_FS_stop (ctx);
+  ctx = NULL;
+}
+
+static void
+shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct GNUNET_FS_DownloadContext *d;
+
+  if (dc != NULL)
+  {
+    d = dc;
+    dc = NULL;
+    GNUNET_FS_download_stop (d, delete_incomplete);
+  }
+}
+
+
+/* callback function */
+void *progress_cb (void *cls, const struct GNUNET_FS_ProgressInfo * info)
+{
+
+        char *s;
+        char*s2;
+        char *t;
+
+        switch (info->status)
+        {
+        case GNUNET_FS_STATUS_DOWNLOAD_START:
+          if (verbose > 1)
+                  FPRINTF (stderr, _("Starting download `%s'.\n"),
+                               info->value.download.filename);
+          break;
+        case GNUNET_FS_STATUS_DOWNLOAD_PROGRESS:
+          if (verbose)
+        {
+          s = GNUNET_STRINGS_relative_time_to_string (info->value.download.eta);
+          if (info->value.download.specifics.progress.block_download_duration.rel_value
+              == GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+             s2 = GNUNET_strdup (_("<unknown time>"));
+          else
+            s2 = GNUNET_STRINGS_relative_time_to_string (
+                 info->value.download.specifics.progress.block_download_duration);
+          t = GNUNET_STRINGS_byte_size_fancy (info->value.download.completed *
+                                                          1000LL /
+                                                          (info->value.download.
+                                                           duration.rel_value + 1));
+          FPRINTF (stdout,
+                   _("Downloading `%s' at %llu/%llu (%s remaining, %s/s). Block took %s to download\n"),
+                   info->value.download.filename,
+                   (unsigned long long) info->value.download.completed,
+                   (unsigned long long) info->value.download.size, s, t, s2);
+         GNUNET_free (s);
+         GNUNET_free (s2);
+         GNUNET_free (t);
+        }
+        break;
+        case GNUNET_FS_STATUS_DOWNLOAD_ERROR:
+        FPRINTF (stderr, _("Error downloading: %s.\n"),
+                 info->value.download.specifics.error.message);
+        GNUNET_SCHEDULER_shutdown ();
+        break;
+        case GNUNET_FS_STATUS_DOWNLOAD_COMPLETED:
+        s = GNUNET_STRINGS_byte_size_fancy (info->value.download.completed * 1000 /
+                                            (info->value.download.
+                                             duration.rel_value + 1));
+        FPRINTF (stdout, _("Downloading `%s' done (%s/s).\n"),
+                 info->value.download.filename, s);
+        GNUNET_free (s);
+        if (info->value.download.dc == dc)
+          GNUNET_SCHEDULER_shutdown ();
+        break;
+        case GNUNET_FS_STATUS_DOWNLOAD_STOPPED:
+          if (info->value.download.dc == dc)
+            GNUNET_SCHEDULER_add_continuation (&cleanup_task, NULL,
+                                               GNUNET_SCHEDULER_REASON_PREREQ_DONE);
+          break;
+        case GNUNET_FS_STATUS_DOWNLOAD_ACTIVE:
+        case GNUNET_FS_STATUS_DOWNLOAD_INACTIVE:
+          break;
+        default:
+          FPRINTF (stderr, _("Unexpected status: %d\n"), info->status);
+          break;
+        }
+
+return NULL;
+}
+
+
+void readdir_task (void *cls,
+                                   const struct GNUNET_SCHEDULER_TaskContext* tc)
+{
+        enum GNUNET_FS_DownloadOptions options;
+
+        if (NULL == uri)
+        {
+          FPRINTF (stderr, _("Failed to parse URI: %s\n"), emsg);
+          GNUNET_free (emsg);
+          GNUNET_FS_stop (ctx); // ?? hmmm....stop before start ??
+        }
+
+
+        fs = GNUNET_FS_start (cfg, "gnunet-fuse", &progress_cb, NULL,
+                                                GNUNET_FS_FLAGS_NONE,
+                                                GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, parallelism,
+                                                GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, request_parallelism,
+                                                GNUNET_FS_OPTIONS_END);
+
+        if (NULL == fs)
+          {
+            FPRINTF (stderr, _("Could not initialize `%s' subsystem.\n"), "FS");
+            GNUNET_FS_uri_destroy (uri);
+            ret = 1;
+            return;
+          }
+
+        options = GNUNET_FS_DOWNLOAD_OPTION_NONE;
+          if (do_recursive)
+            options |= GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE;
+          if (local_only)
+            options |= GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY;
+
+        struct GNUNET_FS_DownloadContext* dc;
+        dc = GNUNET_FS_download_start (fs, uri, NULL, r->tmpfile, NULL, 0,
+                                                                GNUNET_FS_uri_chk_get_file_size(uri),
+                                                                anonymity, options, NULL, NULL);
+
+        GNUNET_FS_uri_destroy (uri);
+        if (dc == NULL)
+        {
+        GNUNET_FS_stop (ctx);
+        ctx = NULL;
+        return;
+        }
+
+        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task, NULL);
+
+}
+
+
+int gn_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+                                off_t offset, struct fuse_file_info *fi)
+{
+        struct GNUNET_FUSE_path_info * path_info = NULL;
+        printf("FUSE PATH  gives me: `%s'\n", path);
+        (void) fi;
+        (void) offset;
+
+        GNUNET_HashCode path_hash;
+        GNUNET_CRYPTO_hash (path, strlen (path), &path_hash);
+        /* NOTE: Path can be like /.Trash/1000/files for the trash directory */
+        if (GNUNET_NO == GNUNET_CONTAINER_multihashmap_contains(map, &path_hash))
+        {
+                /* new path */
+                //path_info = create_path_info (path, NULL);
+                //GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put(map, &path_hash, path_info, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
+        }
+        else
+        {
+                /* existing path */
+            path_info = GNUNET_CONTAINER_multihashmap_get (map, &path_hash);
+        }
+
+        //GNUNET_assert (path_info != NULL);
+
+#if 0
+        r = GNUNET_malloc (sizeof (struct GNUNET_FUSE_path_info));
+
+        int len = strlen(path);
+        int exist = 0;
+        r->path = path;
+
+        /* compute key */
+
+                GNUNET_CRYPTO_hash (r->path, len, r->hash);
+
+
+        exist = GNUNET_CONTAINER_multihashmap_contains (map, r->hash);
+        if ( exist == GNUNET_NO)
+        {
+
+
+/* Store a key-value pair in the map */
+        GNUNET_CONTAINER_multihashmap_put (map, r->hash, r->path, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+
+/* store to temporary file */
+        r->tmpfile = GNUNET_DISK_mktemp("gnunet-fuse-tempfile");
+
+/* find value with given key */
+        r->source = GNUNET_CONTAINER_multihashmap_get (map, r->hash);
+
+/* parse uri from given source */
+        uri = GNUNET_FS_uri_parse(r->source, &emsg);
+        GNUNET_SCHEDULER_run(&readdir_task, NULL);
+
+        filler(buf, ".", NULL, 0);
+        filler(buf, "..", NULL, 0);
+
+        return 0;
+        }
+
+        else
+        {
+        uri = GNUNET_FS_uri_parse(r->source, &emsg);
+        GNUNET_SCHEDULER_run(&readdir_task, NULL);
+
+        filler(buf, ".", NULL, 0);
+        filler(buf, "..", NULL, 0);
+        return 0;
+        }
+#endif
+
+        filler(buf, ".", NULL, 0);
+        filler(buf, "..", NULL, 0);
+        return 0;
+}