/*
This file is part of GNUnet.
- (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
*/
struct GNUNET_FS_Uri *chk_uri;
+ /**
+ * SKS URI for this file or directory. NULL if
+ * we have not yet computed it.
+ */
+ struct GNUNET_FS_Uri *sks_uri;
+
/**
* Block options for the file.
*/
};
-/**
- * The job is now ready to run and should use the given client
- * handle to communicate with the FS service.
- *
- * @param cls closure
- * @param client handle to use for FS communication
- */
-typedef void (*GNUNET_FS_QueueStart) (void *cls,
- struct GNUNET_CLIENT_Connection * client);
-
-
-/**
- * The job must now stop to run and should destry the client handle as
- * soon as possible (ideally prior to returning).
- */
-typedef void (*GNUNET_FS_QueueStop) (void *cls);
-
-
-
/**
* Priorities for the queue.
*/
/**
* Function to call when the job is started.
*/
- GNUNET_FS_QueueStart start;
+ GNUNET_SCHEDULER_TaskCallback start;
/**
* Function to call when the job needs to stop (or is done / dequeued).
*/
- GNUNET_FS_QueueStop stop;
+ GNUNET_SCHEDULER_TaskCallback stop;
/**
* Closure for start and stop.
struct GNUNET_FS_Handle *h;
/**
- * Client handle, or NULL if job is not running.
+ * Message queue handle, or NULL if job is not running.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_MQ_Handle *mq;
/**
* Time the job was originally queued.
*/
unsigned int start_times;
+ /**
+ * #GNUNET_YES if the job is active now.
+ */
+ int active;
+
};
*/
struct GNUNET_FS_Handle *h;
+ /**
+ * Kept in a DLL while probing.
+ */
+ struct GNUNET_FS_SearchResult *next;
+
+ /**
+ * Kept in a DLL while probing.
+ */
+ struct GNUNET_FS_SearchResult *prev;
+
/**
* Search context this result belongs to; can be NULL
* for probes that come from a directory result.
uint8_t *keyword_bitmap;
/**
- * Key for the search result
+ * Key for the search result based on the URI.
*/
struct GNUNET_HashCode key;
* complete on time (and that will need to be cancelled if we clean
* up the search result before then).
*/
- GNUNET_SCHEDULER_TaskIdentifier probe_cancel_task;
-
- /**
- * Task we use to report periodically to the application that the
- * probe is still running.
- */
- GNUNET_SCHEDULER_TaskIdentifier probe_ping_task;
+ struct GNUNET_SCHEDULER_Task * probe_cancel_task;
/**
* When did the current probe become active?
* @return queue handle
*/
struct GNUNET_FS_QueueEntry *
-GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h, GNUNET_FS_QueueStart start,
- GNUNET_FS_QueueStop stop, void *cls, unsigned int blocks,
+GNUNET_FS_queue_ (struct GNUNET_FS_Handle *h,
+ GNUNET_SCHEDULER_TaskCallback start,
+ GNUNET_SCHEDULER_TaskCallback stop,
+ void *cls,
+ unsigned int blocks,
enum GNUNET_FS_QueuePriority priority);
* that the caller might need to go backwards
* a bit at times
* @param max maximum number of bytes that should be
- * copied to buf; readers are not allowed
+ * copied to @a buf; readers are not allowed
* to provide less data unless there is an error;
* a value of "0" will be used at the end to allow
* the reader to clean up its internal state
* @return number of bytes written, usually "max", 0 on error
*/
size_t
-GNUNET_FS_data_reader_file_ (void *cls, uint64_t offset, size_t max, void *buf,
+GNUNET_FS_data_reader_file_ (void *cls,
+ uint64_t offset,
+ size_t max,
+ void *buf,
char **emsg);
/**
- * Create the closure for the 'GNUNET_FS_data_reader_file_' callback.
+ * Create the closure for the #GNUNET_FS_data_reader_file_() callback.
*
* @param filename file to read
* @return closure to use
* that the caller might need to go backwards
* a bit at times
* @param max maximum number of bytes that should be
- * copied to buf; readers are not allowed
+ * copied to @a buf; readers are not allowed
* to provide less data unless there is an error;
* a value of "0" will be used at the end to allow
* the reader to clean up its internal state
* @param buf where the reader should write the data
* @param emsg location for the reader to store an error message
- * @return number of bytes written, usually "max", 0 on error
+ * @return number of bytes written, usually @a max, 0 on error
*/
size_t
-GNUNET_FS_data_reader_copy_ (void *cls, uint64_t offset, size_t max, void *buf,
+GNUNET_FS_data_reader_copy_ (void *cls,
+ uint64_t offset,
+ size_t max,
+ void *buf,
char **emsg);
/**
* Notification of FS that a search probe has made progress.
* This function is used INSTEAD of the client's event handler
- * for downloads where the GNUNET_FS_DOWNLOAD_IS_PROBE flag is set.
+ * for downloads where the #GNUNET_FS_DOWNLOAD_IS_PROBE flag is set.
*
* @param cls closure, always NULL (!), actual closure
* is in the client-context of the info struct
* for this operation; should be set to NULL for
* SUSPEND and STOPPED events). The value returned
* will be passed to future callbacks in the respective
- * field in the GNUNET_FS_ProgressInfo struct.
+ * field in the `struct GNUNET_FS_ProgressInfo`.
*/
void *
GNUNET_FS_search_probe_progress_ (void *cls,
/**
* Main function that performs the upload.
*
- * @param cls "struct GNUNET_FS_PublishContext" identifies the upload
- * @param tc task context
+ * @param cls `struct GNUNET_FS_PublishContext` identifies the upload
*/
void
-GNUNET_FS_publish_main_ (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc);
+GNUNET_FS_publish_main_ (void *cls);
/**
* @param file_id computed hash, NULL on error
*/
void
-GNUNET_FS_unindex_process_hash_ (void *cls, const struct GNUNET_HashCode * file_id);
+GNUNET_FS_unindex_process_hash_ (void *cls,
+ const struct GNUNET_HashCode *file_id);
/**
* request for the file.
*
* @param cls the 'struct GNUNET_FS_DownloadContext'
- * @param tc scheduler context
*/
void
-GNUNET_FS_download_start_task_ (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc);
+GNUNET_FS_download_start_task_ (void *cls);
void
GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr);
+
/**
* Remove serialization/deserialization file from disk.
*
* @param ent entity identifier
*/
void
-GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h, const char *ext,
+GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h,
+ const char *ext,
const char *ent);
* @param uni unique name of parent
*/
void
-GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h, const char *ext,
+GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h,
+ const char *ext,
const char *uni);
* Create SUSPEND event for the given publish operation
* and then clean up our state (without stop signal).
*
- * @param cls the 'struct GNUNET_FS_PublishContext' to signal for
+ * @param cls the `struct GNUNET_FS_PublishContext` to signal for
*/
void
GNUNET_FS_publish_signal_suspend_ (void *cls);
* Create SUSPEND event for the given download operation
* and then clean up our state (without stop signal).
*
- * @param cls the 'struct GNUNET_FS_DownloadContext' to signal for
+ * @param cls the `struct GNUNET_FS_DownloadContext` to signal for
*/
void
GNUNET_FS_download_signal_suspend_ (void *cls);
* Create SUSPEND event for the given unindex operation
* and then clean up our state (without stop signal).
*
- * @param cls the 'struct GNUNET_FS_UnindexContext' to signal for
+ * @param cls the `struct GNUNET_FS_UnindexContext` to signal for
*/
void
GNUNET_FS_unindex_signal_suspend_ (void *cls);
*/
struct GNUNET_FS_QueueEntry *pending_tail;
+ /**
+ * Head of active probes.
+ */
+ struct GNUNET_FS_SearchResult *probes_head;
+
+ /**
+ * Tail of active probes.
+ */
+ struct GNUNET_FS_SearchResult *probes_tail;
+
/**
* Task that processes the jobs in the running and pending queues
* (and moves jobs around as needed).
*/
- GNUNET_SCHEDULER_TaskIdentifier queue_job;
+ struct GNUNET_SCHEDULER_Task * queue_job;
+
+ /**
+ * Task we use to report periodically to the application that
+ * certain search probes (from @e probes_head) are still running.
+ */
+ struct GNUNET_SCHEDULER_Task * probe_ping_task;
/**
* Average time we take for a single request to be satisfied.
char *serialization;
/**
- * Our own client handle for the FS service; only briefly used when
+ * Our own message queue for the FS service; only briefly used when
* we start to index a file, otherwise NULL.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_MQ_Handle *mq;
/**
* Current position in the file-tree for the upload.
* ID of the task performing the upload. NO_TASK if the upload has
* completed.
*/
- GNUNET_SCHEDULER_TaskIdentifier upload_task;
+ struct GNUNET_SCHEDULER_Task * upload_task;
/**
* Storage space to reserve for the operation.
*/
int rid;
+ /**
+ * Set to #GNUNET_YES if we were able to publish any block.
+ * (and thus unindexing on error might make sense).
+ */
+ int any_done;
+
/**
* Set to #GNUNET_YES if all processing has completed.
*/
* Connection to the FS service, only valid during the
* #UNINDEX_STATE_FS_NOTIFY phase.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_MQ_Handle *mq;
/**
* Connection to the datastore service, only valid during the
*/
struct GNUNET_HashCode uquery;
- /**
- * First content UID, 0 for none.
- */
- uint64_t first_uid;
-
/**
* Error message, NULL on success.
*/
*/
uint64_t file_size;
- /**
- * Random offset given to #GNUNET_DATASTORE_get_key.
- */
- uint64_t roff;
-
/**
* When did we start?
*/
/**
- * Information we keep for each keyword in
- * a keyword search.
+ * Information we keep for each keyword in a keyword search.
*/
struct SearchRequestEntry
{
/**
* Connection to the FS service.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_MQ_Handle *mq;
/**
* Pointer we keep for the client.
char *emsg;
/**
- * Map that contains a "struct GNUNET_FS_SearchResult" for each result that
+ * Map that contains a `struct GNUNET_FS_SearchResult` for each result that
* was found in the search. The key for each entry is the XOR of
* the key and query in the CHK URI (as a unique identifier for the
* search result).
/**
* ID of a task that is using this struct and that must be cancelled
* when the search is being stopped (if not
- * #GNUNET_SCHEDULER_NO_TASK). Used for the task that adds some
+ * NULL). Used for the task that adds some
* artificial delay when trying to reconnect to the FS service.
*/
- GNUNET_SCHEDULER_TaskIdentifier task;
-
- /**
- * How many of the entries in the search request
- * map have been passed to the service so far?
- */
- unsigned int search_request_map_offset;
-
- /**
- * How many of the keywords in the KSK
- * map have been passed to the service so far?
- */
- unsigned int keyword_offset;
+ struct GNUNET_SCHEDULER_Task *task;
/**
* Anonymity level for the search.
*/
struct DownloadRequest
{
- /**
- * While pending, we keep all download requests in a doubly-linked list.
- */
- struct DownloadRequest *next;
-
- /**
- * While pending, we keep all download requests in a doubly-linked list.
- */
- struct DownloadRequest *prev;
/**
* Parent in the CHK-tree.
uint64_t offset;
/**
- * Number of entries in 'children' array.
+ * Number of entries in @e children array.
*/
unsigned int num_children;
*/
enum BlockRequestState state;
- /**
- * #GNUNET_YES if this entry is in the pending list.
- */
- int is_pending;
-
};
GNUNET_FS_free_download_request_ (struct DownloadRequest *dr);
+/**
+ * Stop the ping task for this search result.
+ *
+ * @param sr result to start pinging for.
+ */
+void
+GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr);
+
+
/**
* Context for controlling a download.
*/
/**
* Connection to the FS service.
*/
- struct GNUNET_CLIENT_Connection *client;
+ struct GNUNET_MQ_Handle *mq;
/**
* Parent download (used when downloading files
*/
struct GNUNET_FS_QueueEntry *job_queue;
- /**
- * Non-NULL if we are currently having a request for
- * transmission pending with the client handle.
- */
- struct GNUNET_CLIENT_TransmitHandle *th;
-
/**
* Tree encoder used for the reconstruction.
*/
*/
struct GNUNET_CONTAINER_MultiHashMap *active;
- /**
- * Head of linked list of pending requests.
- */
- struct DownloadRequest *pending_head;
-
- /**
- * Head of linked list of pending requests.
- */
- struct DownloadRequest *pending_tail;
-
/**
* Top-level download request.
*/
/**
* ID of a task that is using this struct and that must be cancelled
* when the download is being stopped (if not
- * GNUNET_SCHEDULER_NO_TASK). Used for the task that adds some
+ * NULL). Used for the task that adds some
* artificial delay when trying to reconnect to the FS service or
* the task processing incrementally the data on disk, or the
* task requesting blocks, etc.
*/
- GNUNET_SCHEDULER_TaskIdentifier task;
+ struct GNUNET_SCHEDULER_Task *task;
/**
* What is the first offset that we're interested
*/
int has_finished;
- /**
- * Have we started the receive continuation yet?
- */
- int in_receive;
-
/**
* Are we ready to issue requests (reconstructions are finished)?
*/
projects / oweals / gnunet.git / blobdiff