[GNUnet-SVN] r8930 - gnunet/src/fs

[gnunet]

Author: grothoff
Date: 2009-09-02 13:20:51 -0600 (Wed, 02 Sep 2009)
New Revision: 8930

Modified:
   gnunet/src/fs/fs.h
   gnunet/src/fs/fs_publish.c
   gnunet/src/fs/fs_tree.h
   gnunet/src/fs/fs_unindex.c
Log:
fixing fixmes

Modified: gnunet/src/fs/fs.h
===================================================================
--- gnunet/src/fs/fs.h  2009-09-02 18:52:09 UTC (rev 8929)
+++ gnunet/src/fs/fs.h  2009-09-02 19:20:51 UTC (rev 8930)
@@ -238,19 +238,6 @@
    * (for operational persistence).
    */
   char *serialization;
-
-  /**
-   * In-memory cache of the current CHK tree.
-   * This struct will contain the CHK values
-   * from the root to the currently processed
-   * node in the tree as identified by 
-   * "current_depth" and "publish_offset".
-   * The "chktree" will be initially NULL,
-   * then allocated to a sufficient number of
-   * entries for the size of the file and
-   * finally freed once the upload is complete.
-   */
-  // struct ContentHashKey *chk_tree;
   
   /**
    * Encoder being used to publish this file.
@@ -262,26 +249,8 @@
    * failed).
    */
   char *emsg;
-  
-  /**
-   * Number of entries in "chk_tree".
-   */
-  // unsigned int chk_tree_depth;
 
   /**
-   * Depth in the CHK-tree at which we are
-   * currently publishing.  0 is the root
-   * of the tree.
-   */
-  // unsigned int current_depth;
-
-  /**
-   * How many bytes of this file or directory have been
-   * published so far?
-   */
-  // uint64_t publish_offset;
-
-  /**
    * Data describing either the file or the directory.
    */
   union
@@ -580,16 +549,21 @@
   void *client_info;
 
   /**
+   * Merkle-ish tree encoder context.
+   */
+  struct GNUNET_FS_TreeEncoder *tc;
+
+  /**
+   * Handle used to read the file.
+   */
+  struct GNUNET_DISK_FileHandle *fh;
+
+  /**
    * Overall size of the file.
    */ 
   uint64_t file_size;
 
   /**
-   * How far have we gotten?
-   */ 
-  uint64_t unindex_offset;
-
-  /**
    * When did we start?
    */
   struct GNUNET_TIME_Absolute start_time;

Modified: gnunet/src/fs/fs_publish.c
===================================================================
--- gnunet/src/fs/fs_publish.c  2009-09-02 18:52:09 UTC (rev 8929)
+++ gnunet/src/fs/fs_publish.c  2009-09-02 19:20:51 UTC (rev 8930)
@@ -372,7 +372,7 @@
 {
   struct GNUNET_FS_PublishContext *sc = cls;
   struct GNUNET_FS_FileInformation *p;
-  uint16_t pt_size;
+  size_t pt_size;
   const char *dd;
 
   p = sc->fi_pos;

Modified: gnunet/src/fs/fs_tree.h
===================================================================
--- gnunet/src/fs/fs_tree.h     2009-09-02 18:52:09 UTC (rev 8929)
+++ gnunet/src/fs/fs_tree.h     2009-09-02 19:20:51 UTC (rev 8930)
@@ -95,6 +95,7 @@
  * @param proc function to call on each encrypted block
  * @param progress function to call with progress information 
  * @param cont function to call when done
+ * @return tree encoder context
  */
 struct GNUNET_FS_TreeEncoder *
 GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h,

Modified: gnunet/src/fs/fs_unindex.c
===================================================================
--- gnunet/src/fs/fs_unindex.c  2009-09-02 18:52:09 UTC (rev 8929)
+++ gnunet/src/fs/fs_unindex.c  2009-09-02 19:20:51 UTC (rev 8930)
@@ -32,11 +32,99 @@
 #include "gnunet_fs_service.h"
 #include "gnunet_protocols.h"
 #include "fs.h"
+#include "fs_tree.h"
 
 
+/**
+ * Function called by the tree encoder to obtain
+ * a block of plaintext data (for the lowest level
+ * of the tree).
+ *
+ * @param cls our publishing context
+ * @param offset identifies which block to get
+ * @param max (maximum) number of bytes to get; returning
+ *        fewer will also cause errors
+ * @param buf where to copy the plaintext buffer
+ * @param emsg location to store an error message (on error)
+ * @return number of bytes copied to buf, 0 on error
+ */
+static size_t
+unindex_reader (void *cls,
+               uint64_t offset,
+               size_t max, 
+               void *buf,
+               char **emsg)
+{
+  struct GNUNET_FS_UnindexContext *uc = cls;
+  size_t pt_size;
 
+  pt_size = GNUNET_MIN(max,
+                      uc->file_size - offset);
+  if (offset != 
+      GNUNET_DISK_file_seek (uc->fh, offset, GNUNET_DISK_SEEK_SET))
+    {
+      *emsg = GNUNET_strdup (_("Failed to find given position in file"));
+      return 0;
+    }
+  if (pt_size !=
+      GNUNET_DISK_file_read (uc->fh,
+                            buf,
+                            pt_size))
+    {
+      *emsg = GNUNET_strdup (_("Failed to read file"));
+      return 0;
+    }
+  return pt_size;
+}
 
+
 /**
+ * Function called asking for the current (encoded)
+ * block to be processed.  After processing the
+ * client should either call "GNUNET_FS_tree_encode_next"
+ * or (on error) "GNUNET_FS_tree_encode_finish".
+ *
+ * @param cls closure
+ * @param query the query for the block (key for lookup in the datastore)
+ * @param offset offset of the block
+ * @param type type of the block (IBLOCK or DBLOCK)
+ * @param block the (encrypted) block
+ * @param block_size size of block (in bytes)
+ */
+static void 
+unindex_process (void *cls,
+                const GNUNET_HashCode *query,
+                uint64_t offset,
+                unsigned int type,
+                const void *block,
+                uint16_t block_size)
+{
+}
+                                            
+
+/**
+ * Function called with information about our
+ * progress in computing the tree encoding.
+ *
+ * @param cls closure
+ * @param offset where are we in the file
+ * @param pt_block plaintext of the currently processed block
+ * @param pt_size size of pt_block
+ * @param depth depth of the block in the tree
+ */
+static void
+unindex_progress (void *cls,
+                 uint64_t offset,
+                 const void *pt_block,
+                 size_t pt_size,
+                 unsigned int depth)
+{
+  // FIXME
+}
+                                              
+
+
+/**
  * Fill in all of the generic fields for 
  * an unindex event.
  *
@@ -45,7 +133,8 @@
  */
 static void
 make_unindex_status (struct GNUNET_FS_ProgressInfo *pi,
-                    struct GNUNET_FS_UnindexContext *uc)
+                    struct GNUNET_FS_UnindexContext *uc,
+                    uint64_t offset)
 {
   pi->value.unindex.uc = uc;
   pi->value.unindex.cctx = uc->client_info;
@@ -53,10 +142,10 @@
   pi->value.unindex.size = uc->file_size;
   pi->value.unindex.eta 
     = GNUNET_TIME_calculate_eta (uc->start_time,
-                                uc->unindex_offset,
+                                offset,
                                 uc->file_size);
   pi->value.publish.duration = GNUNET_TIME_absolute_get_duration 
(uc->start_time);
-  pi->value.publish.completed = uc->unindex_offset;
+  pi->value.publish.completed = offset;
 }
 
 
@@ -74,7 +163,7 @@
   struct GNUNET_FS_ProgressInfo pi;
   
   pi.status = GNUNET_FS_STATUS_UNINDEX_ERROR;
-  make_unindex_status (&pi, uc);
+  make_unindex_status (&pi, uc, 0);
   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
   pi.value.unindex.specifics.error.message = emsg;
   uc->client_info
@@ -83,6 +172,13 @@
 }
 
 
+static void
+unindex_finish (void *cls,
+               const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+}
+
+
 /**
  * Function called with the response from the
  * FS service to our unindexing request.
@@ -127,8 +223,25 @@
                            _("Failed to connect to `datastore' service."));
       return;
     }
-
-  // FIXME: call shared code with publishing...
+  uc->fh = GNUNET_DISK_file_open (uc->filename,
+                                 GNUNET_DISK_OPEN_READ);
+  if (NULL == uc->fh)
+    {
+      GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
+      uc->dsh = NULL;
+      uc->state = UNINDEX_STATE_ERROR;
+      signal_unindex_error (uc, 
+                           _("Failed to open file for unindexing."));
+      return;
+    }
+  uc->tc = GNUNET_FS_tree_encoder_create (uc->h,
+                                         uc->file_size,
+                                         uc,
+                                         &unindex_reader,
+                                         &unindex_process,
+                                         &unindex_progress,
+                                         &unindex_finish);
+  GNUNET_FS_tree_encoder_next (uc->tc);
 }
 
 
@@ -203,7 +316,7 @@
 
   // FIXME: make persistent!
   pi.status = GNUNET_FS_STATUS_UNINDEX_START;
-  make_unindex_status (&pi, ret);
+  make_unindex_status (&pi, ret, 0);
   pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
   ret->client_info
     = h->upcb (h->upcb_cls,
@@ -236,8 +349,10 @@
       return;
     }
   // FIXME: make unpersistent!
+  make_unindex_status (&pi, uc, 
+                      (uc->state == UNINDEX_STATE_COMPLETE)
+                      ? uc->file_size : 0);
   pi.status = GNUNET_FS_STATUS_UNINDEX_STOPPED;
-  make_unindex_status (&pi, uc);
   pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
   uc->client_info
     = uc->h->upcb (uc->h->upcb_cls,