From: Christian Grothoff Date: Wed, 2 Sep 2009 19:20:51 +0000 (+0000) Subject: fixing fixmes X-Git-Tag: initial-import-from-subversion-38251~23539 X-Git-Url: https://git.librecmc.org/?a=commitdiff_plain;h=8922e187c0d77dfa7cbd56440b10de5670d9d311;p=oweals%2Fgnunet.git fixing fixmes --- 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,