fixing fixmes

4 files changed, 135 insertions, 45 deletions

diff --git a/src/fs/fs.h b/src/fs/fs.h
index c8712b492..7df395e86 100644
--- a/src/fs/fs.h
+++ b/src/fs/fs.h
@@ -238,19 +238,6 @@ struct GNUNET_FS_FileInformation
    * (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,24 +249,6 @@ struct GNUNET_FS_FileInformation
    * 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.
@@ -580,14 +549,19 @@ struct GNUNET_FS_UnindexContext
   void *client_info;
 
   /**
-   * Overall size of the file.
-   */ 
-  uint64_t file_size;
+   * Merkle-ish tree encoder context.
+   */
+  struct GNUNET_FS_TreeEncoder *tc;
 
   /**
-   * How far have we gotten?
+   * Handle used to read the file.
+   */
+  struct GNUNET_DISK_FileHandle *fh;
+
+  /**
+   * Overall size of the file.
    */ 
-  uint64_t unindex_offset;
+  uint64_t file_size;
 
   /**
    * When did we start?
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c
index 76f73fdc0..8417f6082 100644
--- a/src/fs/fs_publish.c
+++ b/src/fs/fs_publish.c
@@ -372,7 +372,7 @@ block_reader (void *cls,
 {
   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;
diff --git a/src/fs/fs_tree.h b/src/fs/fs_tree.h
index f24130a3c..47d383fb5 100644
--- a/src/fs/fs_tree.h
+++ b/src/fs/fs_tree.h
@@ -95,6 +95,7 @@ typedef void (*GNUNET_FS_TreeProgressCallback)(void *cls,
  * @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,
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c
index 9f1caac3a..1416667f3 100644
--- a/src/fs/fs_unindex.c
+++ b/src/fs/fs_unindex.c
@@ -32,8 +32,96 @@
 #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
+}
+                                               
 
 
 /**
@@ -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 @@ make_unindex_status (struct GNUNET_FS_ProgressInfo *pi,
   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 @@ signal_unindex_error (struct GNUNET_FS_UnindexContext *uc,
   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 @@ signal_unindex_error (struct GNUNET_FS_UnindexContext *uc,
 }
 
 
+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 @@ process_fs_response (void *cls,
                             _("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 @@ GNUNET_FS_unindex (struct GNUNET_FS_Handle *h,
 
   // 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 @@ GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc)
       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,