1 files changed, 236 insertions, 66 deletions

diff --git a/src/fuse/gnunet-fuse.c b/src/fuse/gnunet-fuse.c
index a0b43de..69c226c 100644
--- a/src/fuse/gnunet-fuse.c
+++ b/src/fuse/gnunet-fuse.c
@@ -25,6 +25,7 @@
  * @author Mauricio Günther
  */
 #include "gnunet-fuse.h"
+#include "gfs_download.h"
 
 /**
  * Anonymity level to use.
@@ -57,35 +58,181 @@ static char *source;
 static char *directory;
 
 /**
- * Global mapping of paths to GNUnet URIs (and file names) for
- * the respective entries.
+ * Root of the file tree.
  */
-static struct GNUNET_CONTAINER_MultiHashMap *map;
+static struct GNUNET_FUSE_PathInfo *root;
+
 
 /**
- * Mutex for synchronizing access to 'map'.
+ * Function used to process entries in a directory; adds the 
+ * respective entry to the parent directory.
+ *
+ * @param cls closure with the 'struct GNUNET_FUSE_PathInfo' of the parent
+ * @param filename name of the file in the directory
+ * @param uri URI of the file
+ * @param metadata metadata for the file; metadata for
+ *        the directory if everything else is NULL/zero
+ * @param length length of the available data for the file
+ *           (of type size_t since data must certainly fit
+ *            into memory; if files are larger than size_t
+ *            permits, then they will certainly not be
+ *            embedded with the directory itself).
+ * @param data data available for the file (length bytes)
  */
-static struct GNUNET_Mutex *map_mutex;
+static void 
+process_directory_entry (void *cls,
+                         const char *filename,
+                         const struct GNUNET_FS_Uri *
+                         uri,
+                         const struct
+                         GNUNET_CONTAINER_MetaData *
+                         meta, size_t length,
+                         const void *data)
+{
+  struct GNUNET_FUSE_PathInfo *parent = cls;
+  struct GNUNET_FUSE_PathInfo *pi;
+  int is_directory;
+
+  if (NULL == filename)
+    return; /* info about the directory itself */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Adding file `%s' to directory `%s'\n",
+              filename,
+              parent->filename);
+  is_directory = GNUNET_FS_meta_data_test_for_directory (meta);
+  if (GNUNET_SYSERR == is_directory)
+    is_directory = GNUNET_NO; /* if in doubt, say no */
+  pi = GNUNET_FUSE_path_info_create (parent, filename, uri, is_directory);
+  GNUNET_FUSE_path_info_done (pi);
+}
+
+
+/**
+ * Load and parse a directory.
+ *
+ * @param pi path to the directory
+ * @param eno where to store 'errno' on errors
+ * @return GNUNET_OK on success
+ */
+int
+GNUNET_FUSE_load_directory (struct GNUNET_FUSE_PathInfo *pi,
+                            int * eno)
+{
+  size_t size;
+  void *data;
+  struct GNUNET_DISK_MapHandle *mh;
+  struct GNUNET_DISK_FileHandle *fh;
+
+  /* Need to download directory; store to temporary file */
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Downloading directory `%s'\n",
+              pi->filename);
+  pi->tmpfile = GNUNET_DISK_mktemp ("gnunet-fuse-tempfile");
+  if (GNUNET_OK != GNUNET_FUSE_download_file (pi,
+                                              0,
+                                              GNUNET_FS_uri_chk_get_file_size (pi->uri)))
+  {
+    UNLINK (pi->tmpfile);
+    GNUNET_free (pi->tmpfile);
+    pi->tmpfile = NULL;
+    *eno = EIO; /* low level IO error */
+    return GNUNET_SYSERR;
+  }
+
+  size = (size_t) GNUNET_FS_uri_chk_get_file_size (pi->uri);
+  fh = GNUNET_DISK_file_open (pi->tmpfile,
+                              GNUNET_DISK_OPEN_READ,
+                              GNUNET_DISK_PERM_NONE);                         
+  if (NULL == fh)
+  {
+    *eno = EIO;
+    return GNUNET_SYSERR;
+  }
+  data = GNUNET_DISK_file_map (fh, 
+                               &mh,
+                               GNUNET_DISK_MAP_TYPE_READ,
+                               size);
+  if (NULL == data)
+  {
+    GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fh));
+    return - ENOMEM;
+  }
+  *eno = 0;
+  if (GNUNET_OK !=
+      GNUNET_FS_directory_list_contents (size,
+                                         data, 0LL,
+                                         &process_directory_entry,
+                                         pi))
+    *eno = ENOTDIR;
+  GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_unmap (mh));
+  GNUNET_DISK_file_close (fh);
+  if (0 != *eno)
+    return GNUNET_SYSERR;
+  return GNUNET_OK;
+} 
 
 
 /**
  * Obtain an existing path info entry from the global map.
  *
  * @param path path the entry represents
+ * @param eno where to store 'errno' on errors
  * @return NULL if no such path entry exists
  */
 struct GNUNET_FUSE_PathInfo *
-GNUNET_FUSE_path_info_get (const char *path)
+GNUNET_FUSE_path_info_get (const char *path,
+                           int *eno)
 {
+  size_t slen = strlen (path) + 1;
+  char buf[slen];
   struct GNUNET_FUSE_PathInfo *pi;
-  GNUNET_HashCode path_hash;
-
-  GNUNET_CRYPTO_hash (path, strlen (path), &path_hash);
-  GNUNET_mutex_lock (map_mutex);
-  pi = GNUNET_CONTAINER_multihashmap_get (map, &path_hash);
-  if (NULL != pi)
-    ++pi->rc;
-  GNUNET_mutex_unlock (map_mutex);
+  struct GNUNET_FUSE_PathInfo *pos;
+  char *tok;
+  
+  memcpy (buf, path, slen);
+  pi = root;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Looking up path `%s'\n",
+              path);
+  GNUNET_mutex_lock (pi->lock);
+  for (tok = strtok (buf, "/"); NULL != tok; tok = strtok (NULL, "/"))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Searching for token `%s'\n",
+                tok);
+    if (NULL == pi->tmpfile)
+    {
+      if (GNUNET_OK != GNUNET_FUSE_load_directory (pi, eno))
+      {
+        GNUNET_mutex_unlock (pi->lock);
+        return NULL; 
+      }
+    }
+
+    pos = pi->child_head;
+    while ( (NULL != pos) &&
+            (0 != strcmp (tok,
+                          pos->filename)) )
+      pos = pos->next;
+    if (NULL == pos)
+    {      
+      GNUNET_mutex_unlock (pi->lock);
+      *eno = ENOENT;
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "No file with name `%s' in directory `%s'\n",
+                  tok,
+                  pi->filename);
+      return NULL;
+    }
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Descending into directory `%s'\n",
+                tok);
+    GNUNET_mutex_lock (pos->lock);
+    GNUNET_mutex_unlock (pi->lock);
+    pi = pos;
+  }
+  ++pi->rc;
+  GNUNET_mutex_unlock (pi->lock);
   return pi;  
 }
 
@@ -93,36 +240,37 @@ GNUNET_FUSE_path_info_get (const char *path)
 /**
  * Create a new path info entry in the global map.
  *
- * @param path path the entry represents
+ * @param parent parent directory (can be NULL)
+ * @param filename name of the file to create
  * @param uri URI to use for the path
+ * @param is_directory GNUNET_YES if this entry is for a directory
  * @return existing path entry if one already exists, otherwise
- *         new path entry with the desired URI
+ *         new path entry with the desired URI; in both cases
+ *         the reference counter has been incremented by 1
  */
 struct GNUNET_FUSE_PathInfo *
-GNUNET_FUSE_path_info_create (const char *path, 
+GNUNET_FUSE_path_info_create (struct GNUNET_FUSE_PathInfo *parent,
+                              const char *filename,
                               const struct GNUNET_FS_Uri *uri,
                               int is_directory)
 {
   struct GNUNET_FUSE_PathInfo *pi;
-  GNUNET_HashCode path_hash;
+  size_t len;
 
-  GNUNET_CRYPTO_hash (path, strlen (path), &path_hash);
-  GNUNET_mutex_lock (map_mutex);
-  pi = GNUNET_CONTAINER_multihashmap_get (map, &path_hash);
-  if (NULL != pi)
+  if (NULL != parent)
   {
-    GNUNET_mutex_unlock (map_mutex);
-    return pi;
+    GNUNET_mutex_lock (parent->lock);
   }
+
   pi = GNUNET_malloc (sizeof (struct GNUNET_FUSE_PathInfo));
-  pi->path = GNUNET_strdup (path);
+  pi->parent = parent;
+  pi->filename = GNUNET_strdup (filename);
+  len = strlen (pi->filename);
+  if ('/' == pi->filename[len - 1])
+    pi->filename[len - 1] = '\0';
   pi->uri = GNUNET_FS_uri_dup (uri);
   pi->lock = GNUNET_mutex_create (GNUNET_YES);
   pi->rc = 1;
-  GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (map,
-                                                                 &path_hash,
-                                                                 pi,
-                                                                 GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
   pi->stbuf.st_mode = (S_IRUSR | S_IRGRP | S_IROTH); /* read-only */
   if (GNUNET_YES == is_directory)
   {
@@ -133,7 +281,14 @@ GNUNET_FUSE_path_info_create (const char *path,
     pi->stbuf.st_mode |= S_IFREG; /* regular file */
     pi->stbuf.st_size = (off_t) GNUNET_FS_uri_chk_get_file_size (uri);
   }
-  GNUNET_mutex_unlock (map_mutex);
+
+  if (NULL != parent)
+  {
+    GNUNET_CONTAINER_DLL_insert_tail (parent->child_head,
+                                      parent->child_tail,
+                                      pi);
+    GNUNET_mutex_unlock (parent->lock);
+  }
   return pi;
 }
 
@@ -151,14 +306,14 @@ GNUNET_FUSE_path_info_done (struct GNUNET_FUSE_PathInfo *pi)
     (void) GNUNET_FUSE_path_info_delete (pi);
     return;
   }
-  GNUNET_mutex_lock (map_mutex);
+  GNUNET_mutex_lock (pi->lock);
   --pi->rc;
-  GNUNET_mutex_unlock (map_mutex);  
+  GNUNET_mutex_unlock (pi->lock);  
 }
 
 
 /**
- * Delete a path info entry from the global map (does not actually
+ * Delete a path info entry from the tree (does not actually
  * remove anything from the file system).  Also decrements the RC.
  *
  * @param pi entry to remove
@@ -166,19 +321,32 @@ GNUNET_FUSE_path_info_done (struct GNUNET_FUSE_PathInfo *pi)
  */
 int
 GNUNET_FUSE_path_info_delete (struct GNUNET_FUSE_PathInfo *pi)
-{
-  GNUNET_HashCode path_hash;
-  int ret;
+{  
+  struct GNUNET_FUSE_PathInfo *parent = pi->parent;
   int rc;
+  int ret;
 
-  GNUNET_CRYPTO_hash (pi->path, strlen (pi->path), &path_hash);
-  GNUNET_mutex_lock (map_mutex);
-  ret = GNUNET_CONTAINER_multihashmap_remove (map, &path_hash, pi);
+  if (NULL != parent)
+  {
+    ret = 0;
+    GNUNET_mutex_lock (parent->lock);
+    GNUNET_mutex_lock (pi->lock);
+    GNUNET_CONTAINER_DLL_remove (parent->child_head,
+                                 parent->child_tail,
+                                 pi);
+    pi->parent = NULL;
+    GNUNET_mutex_unlock (parent->lock);
+  }
+  else
+  {
+    ret = - ENOENT;
+    GNUNET_mutex_lock (pi->lock);
+  }
   rc = --pi->rc;
-  GNUNET_mutex_unlock (map_mutex);
   if (0 != rc)
   {
     pi->delete_later = GNUNET_YES;
+    GNUNET_mutex_unlock (pi->lock);
   }
   else
   {
@@ -187,33 +355,30 @@ GNUNET_FUSE_path_info_delete (struct GNUNET_FUSE_PathInfo *pi)
       GNUNET_break (0 == UNLINK (pi->tmpfile));
       GNUNET_free (pi->tmpfile);
     }
-    GNUNET_free (pi->path);
+    GNUNET_free (pi->filename);
     GNUNET_FS_uri_destroy (pi->uri);
+    GNUNET_mutex_unlock (pi->lock);
     GNUNET_mutex_destroy (pi->lock);
     GNUNET_free (pi);
   }
-  if (GNUNET_YES == ret)
-    return 0;
-  return - ENOENT;
+  return ret;
 }
 
 
 /**
- * Called on each entry in our global 'map' to clean it up.
+ * Called on each node in the path info tree to clean it up.
  *
- * @param cls closure, NULL
- * @param key current key code
- * @param value value in the hash map, a 'struct GNUNET_FUSE_PathInfo'
- * @return GNUNET_YES (we should continue to iterate)
+ * @param pi path info to clean up
  */
-static int
-cleanup_path_info (void *cls, const GNUNET_HashCode * key, void *value)
+static void
+cleanup_path_info (struct GNUNET_FUSE_PathInfo *pi)
 {
-  struct GNUNET_FUSE_PathInfo *pi = value;
+  struct GNUNET_FUSE_PathInfo *pos;
 
+  while (NULL != (pos = pi->child_head))
+    cleanup_path_info (pos);
   ++pi->rc;
   (void) GNUNET_FUSE_path_info_delete (pi);
-  return GNUNET_YES;
 }
 
 
@@ -249,8 +414,7 @@ run (void *cls,
   int argc;
   struct GNUNET_FS_Uri *uri;
   char *emsg;
-  const char *path = "/";
-  struct GNUNET_FUSE_PathInfo *pi;
+  int eno;
 
   cfg = c;
   ret = 0;
@@ -279,20 +443,31 @@ run (void *cls,
        (GNUNET_YES != GNUNET_FS_uri_test_loc (uri)) )
   {
     fprintf (stderr, 
-             _("The given URI is not for a directory and can thus not be mounted\n"), 
-             emsg);
+             _("The given URI is not for a directory and can thus not be mounted\n"));
     ret = 4;
+    GNUNET_FS_uri_destroy (uri);
     return;
   }
 
-  map_mutex = GNUNET_mutex_create (GNUNET_NO);
-  map = GNUNET_CONTAINER_multihashmap_create (1024);
-  pi = GNUNET_FUSE_path_info_create (path, uri, GNUNET_YES);
+  root = GNUNET_FUSE_path_info_create (NULL, "/", uri, GNUNET_YES);
+  if (GNUNET_OK != 
+      GNUNET_FUSE_load_directory (root, &eno))
+  {
+    fprintf (stderr,
+             _("Failed to mount `%s': %s\n"),
+             source,
+             STRERROR (eno));    
+    ret = 5;
+    cleanup_path_info (root);
+    GNUNET_FS_uri_destroy (uri);
+    return;
+  }
 
   if (GNUNET_YES == single_threaded)
     argc = 5;
   else
     argc = 2;
+
   {
     char *a[argc + 1];
     a[0] = "gnunet-fuse";
@@ -306,12 +481,7 @@ run (void *cls,
     a[argc] = NULL;
     fuse_main (argc, a, &fops, NULL);
   }
-  GNUNET_FUSE_path_info_done (pi);
-  GNUNET_CONTAINER_multihashmap_iterate (map, &cleanup_path_info, NULL);
-  GNUNET_CONTAINER_multihashmap_destroy (map);
-  map = NULL;
-  GNUNET_mutex_destroy (map_mutex);
-  map_mutex = NULL;
+  cleanup_path_info (root);
   GNUNET_FS_uri_destroy (uri);
 }