GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
- by the Free Software Foundation; either version 2, or (at your
+ by the Free Software Foundation; either version 3, or (at your
option) any later version.
GNUnet is distributed in the hope that it will be useful, but
* @file include/gnunet_fs_service.h
* @brief API for file-sharing via GNUnet
* @author Christian Grothoff
- *
- * TODO:
- * - extend API with support for publish simulation (-s)
- * and URI-argument binding to keyword/namespace (-u)
*/
#ifndef GNUNET_FS_LIB_H
#define GNUNET_FS_LIB_H
char *
GNUNET_FS_uri_ksk_to_string_fancy (const struct GNUNET_FS_Uri *uri);
+
/**
* Convert a UTF-8 String to a URI.
*
GNUNET_FS_uri_loc_get_uri (const struct GNUNET_FS_Uri *uri);
+/**
+ * Obtain the expiration of the LOC URI.
+ *
+ * @param uri location URI to get the expiration from
+ * @return expiration time of the URI
+ */
+struct GNUNET_TIME_Absolute
+GNUNET_FS_uri_loc_get_expiration (const struct GNUNET_FS_Uri *uri);
+
+
/**
* Construct a location URI (this peer will be used for the location).
*
- * @param baseURI content offered by the sender
+ * @param baseUri content offered by the sender
* @param cfg configuration information (used to find our hostkey)
* @param expiration_time how long will the content be offered?
* @return the location URI, NULL on error
*/
struct GNUNET_FS_Uri *
GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
- struct GNUNET_CONFIGURATION_Handle *cfg,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TIME_Absolute expiration_time);
GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri);
+/**
+ * Handle to one of our namespaces.
+ */
+struct GNUNET_FS_Namespace;
+
+
+/**
+ * Create an SKS URI from a namespace and an identifier.
+ *
+ * @param ns namespace
+ * @param id identifier
+ * @param emsg where to store an error message
+ * @return an FS URI for the given namespace and identifier
+ */
+struct GNUNET_FS_Uri *
+GNUNET_FS_uri_sks_create (struct GNUNET_FS_Namespace *ns,
+ const char *id,
+ char **emsg);
+
+
/**
* Get the ID of a namespace from the given
* namespace URI.
* What is the size of the file that this URI
* refers to?
*
- * @param uri the CHK URI to inspect
+ * @param uri the CHK (or LOC) URI to inspect
* @return size of the file as specified in the CHK URI
*/
uint64_t
* Construct a keyword-URI from meta-data (take all entries
* in the meta-data and construct one large keyword URI
* that lists all keywords that can be found in the meta-data).
- * @deprecated
+ *
+ * @param md metadata to use
+ * @return NULL on error, otherwise a KSK URI
*/
struct GNUNET_FS_Uri *
GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData *md);
* the metadata must be passed as the "scls" argument.
*
* @param ctx command line processor context
- * @param scls must be of type "struct GNUNET_MetaData **"
+ * @param scls must be of type "struct GNUNET_CONTAINER_MetaData **"
* @param option name of the option (typically 'k')
* @param value command line argument given
* @return GNUNET_OK on success
*/
int
GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext* ctx,
- void *scls,
- const char *option,
- const char *value);
+ void *scls,
+ const char *option,
+ const char *value);
*/
GNUNET_FS_STATUS_DOWNLOAD_STOPPED,
+ /**
+ * Notification that this download is now actively being
+ * pursued (as opposed to waiting in the queue).
+ */
+ GNUNET_FS_STATUS_DOWNLOAD_ACTIVE,
+
+ /**
+ * Notification that this download is no longer actively
+ * being pursued (back in the queue).
+ */
+ GNUNET_FS_STATUS_DOWNLOAD_INACTIVE,
+
+ /**
+ * Notification that this download is no longer part of a
+ * recursive download or search but now a 'stand-alone'
+ * download (and may thus need to be moved in the GUI
+ * into a different category).
+ */
+ GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT,
+
/**
* First event generated when a client requests
* a search to begin or when a namespace result
*/
GNUNET_FS_STATUS_SEARCH_SUSPEND,
- /**
- * Event generated for each search result
- * when the respective search is suspended.
- */
- GNUNET_FS_STATUS_SEARCH_SUSPEND_RESULT,
-
/**
* This search has yielded a result.
*/
*/
GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED,
+ /**
+ * Event generated for each search result
+ * when the respective search is suspended.
+ */
+ GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND,
+
/**
* Last message from a search; this signals
* that there will be no further events associated
*/
GNUNET_FS_STATUS_UNINDEX_ERROR,
+ /**
+ * Notification that the unindexing of this file
+ * was completed.
+ */
+ GNUNET_FS_STATUS_UNINDEX_COMPLETED,
+
/**
* Notification that the unindexing of this file
* was stopped (final event for this action).
};
-/**
- * Handle to one of our namespaces.
- */
-struct GNUNET_FS_Namespace;
-
-
/**
* Handle for controlling an upload.
*/
struct GNUNET_FS_SearchContext;
+/**
+ * Result from a search. Opaque handle to refer to the search
+ * (typically used when starting a download associated with the search
+ * result).
+ */
+struct GNUNET_FS_SearchResult;
+
+
/**
* Context for controlling a download.
*/
/**
* Context for controlling the upload.
*/
- struct GNUNET_FS_PublishContext *sc;
+ struct GNUNET_FS_PublishContext *pc;
/**
* Information about the file that is being publishd.
const struct GNUNET_FS_FileInformation *fi;
/**
- * Client context pointer (set the last time
- * by the client for this operation; initially
- * NULL on START/RESUME events).
+ * Client context pointer (set the last time by the client for
+ * this operation; initially NULL on START/RESUME events).
*/
void *cctx;
* (if this is a file in a directory or a subdirectory).
*/
void *pctx;
+
+ /**
+ * Name of the file being published; can be NULL.
+ */
+ const char *filename;
/**
* How large is the file overall? For directories,
/**
* What anonymity level is used for this upload?
*/
- unsigned int anonymity;
+ uint32_t anonymity;
/**
* Additional values for specific events.
*/
uint64_t data_len;
+ /**
+ * Depth of the given block in the tree;
+ * 0 would be the highest level (the first
+ * call is guaranteed to be for the lowest
+ * level).
+ */
+ unsigned int depth;
+
} progress;
/**
* (if this is a file in a directory or a subdirectory).
*/
void *pctx;
+
+ /**
+ * Client context pointer for the associated search operation
+ * (specifically, context pointer for the specific search
+ * result, not the overall search); only set if this
+ * download was started from a search result.
+ */
+ void *sctx;
/**
* URI used for this download.
*/
const struct GNUNET_FS_Uri *uri;
+
+ /**
+ * Name of the file that we are downloading.
+ */
+ const char *filename;
/**
- * How large is the file overall? For directories,
- * this is only the size of the directory itself,
- * not of the other files contained within the
- * directory.
+ * How large is the download overall? This
+ * is NOT necessarily the size from the
+ * URI since we may be doing a partial download.
*/
uint64_t size;
/**
* What anonymity level is used for this download?
*/
- unsigned int anonymity;
+ uint32_t anonymity;
+
+ /**
+ * Is the download currently active.
+ */
+ int is_active;
/**
* Additional values for specific events.
uint64_t data_len;
/**
- * Amount of trust we offered to get the block.
+ * Depth of the given block in the tree;
+ * 0 would be the highest level (the first
+ * call is guaranteed to be for the lowest
+ * level).
*/
- unsigned int trust_offered;
+ unsigned int depth;
} progress;
/**
* Known metadata for the download.
*/
- const struct GNUNET_MetaData *meta;
-
+ const struct GNUNET_CONTAINER_MetaData *meta;
+
} start;
/**
/**
* Known metadata for the download.
*/
- const struct GNUNET_MetaData *meta;
+ const struct GNUNET_CONTAINER_MetaData *meta;
/**
* Error message, NULL if we have not encountered any error yet.
/**
* Client parent-context pointer; NULL for top-level searches,
- * non-NULL for automatically triggered searches for updates in
- * namespaces.
+ * refers to the client context of the associated search result
+ * for automatically triggered searches for updates in
+ * namespaces. In this case, 'presult' refers to that search
+ * result.
*/
void *pctx;
/**
* What anonymity level is used for this search?
*/
- unsigned int anonymity;
-
- /**
- * How much trust have we been offering for this search
- * so far?
- */
- unsigned int trust_offered;
+ uint32_t anonymity;
/**
* Additional values for specific events.
/**
* Metadata for the search result.
*/
- const struct GNUNET_MetaData *meta;
+ const struct GNUNET_CONTAINER_MetaData *meta;
/**
* URI for the search result.
*/
const struct GNUNET_FS_Uri *uri;
+ /**
+ * Handle to the result (for starting downloads).
+ */
+ struct GNUNET_FS_SearchResult *result;
+
+ /**
+ * Applicability rank (the larger, the better the result
+ * fits the search criteria).
+ */
+ uint32_t applicability_rank;
+
} result;
/**
/**
* Metadata for the search result.
*/
- const struct GNUNET_MetaData *meta;
+ const struct GNUNET_CONTAINER_MetaData *meta;
/**
* URI for the search result.
*/
const struct GNUNET_FS_Uri *uri;
+ /**
+ * Handle to the result (for starting downloads).
+ */
+ struct GNUNET_FS_SearchResult *result;
+
/**
* Current availability rank (negative:
* unavailable, positive: available)
*/
- int availability_rank;
+ int32_t availability_rank;
/**
* On how many total queries is the given
* availability_rank based?
*/
- unsigned int availabiliy_certainty;
+ uint32_t availability_certainty;
/**
* Updated applicability rank (the larger,
* the better the result fits the search
* criteria).
*/
- unsigned int applicabiliy_rank;
+ uint32_t applicability_rank;
} resume_result;
/**
* Metadata for the search result.
*/
- const struct GNUNET_MetaData *meta;
+ const struct GNUNET_CONTAINER_MetaData *meta;
/**
* URI for the search result.
* Current availability rank (negative:
* unavailable, positive: available)
*/
- int availability_rank;
+ int32_t availability_rank;
/**
* On how many total queries is the given
* availability_rank based?
*/
- unsigned int availabiliy_certainty;
+ uint32_t availability_certainty;
/**
* Updated applicability rank (the larger,
* the better the result fits the search
* criteria).
*/
- unsigned int applicabiliy_rank;
+ uint32_t applicability_rank;
} update;
/**
* Metadata for the search result.
*/
- const struct GNUNET_MetaData *meta;
+ const struct GNUNET_CONTAINER_MetaData *meta;
/**
* URI for the search result.
/**
* Metadata for the search result.
*/
- const struct GNUNET_MetaData *meta;
+ const struct GNUNET_CONTAINER_MetaData *meta;
/**
* URI for the search result.
} error;
/**
- * Values for all "GNUNET_FS_STATUS_RESULT_NAMESPACE" events.
+ * Values for all "GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE" events.
*/
struct {
*/
uint64_t data_len;
+ /**
+ * Depth of the given block in the tree;
+ * 0 would be the highest level (the first
+ * call is guaranteed to be for the lowest
+ * level).
+ */
+ unsigned int depth;
+
} progress;
/**
const struct GNUNET_FS_ProgressInfo *info);
+/**
+ * General (global) option flags for file-sharing.
+ */
+enum GNUNET_FS_Flags
+ {
+ /**
+ * No special flags set.
+ */
+ GNUNET_FS_FLAGS_NONE = 0,
+
+ /**
+ * Is persistence of operations desired?
+ * (will create SUSPEND/RESUME events).
+ */
+ GNUNET_FS_FLAGS_PERSISTENCE = 1,
+
+ /**
+ * Should we automatically trigger probes for search results
+ * to determine availability?
+ * (will create GNUNET_FS_STATUS_SEARCH_UPDATE events).
+ */
+ GNUNET_FS_FLAGS_DO_PROBES = 2
+
+ };
+
+/**
+ * Options specified in the VARARGs portion of GNUNET_FS_start.
+ */
+enum GNUNET_FS_OPTIONS
+ {
+
+ /**
+ * Last option in the VARARG list.
+ */
+ GNUNET_FS_OPTIONS_END = 0,
+
+ /**
+ * Select the desired amount of parallelism (this option should be
+ * followed by an "unsigned int" giving the desired maximum number
+ * of parallel downloads).
+ */
+ GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM = 1,
+
+ /**
+ * Maximum number of requests that should be pending at a given
+ * point in time (invidivual downloads may go above this, but
+ * if we are above this threshold, we should not activate any
+ * additional downloads.
+ */
+ GNUNET_FS_OPTIONS_REQUEST_PARALLELISM = 2
+
+ };
+
+
/**
* Handle to the file-sharing service.
*/
* @param client_name unique identifier for this client
* @param upcb function to call to notify about FS actions
* @param upcb_cls closure for upcb
+ * @param flags specific attributes for fs-operations
+ * @param ... list of optional options, terminated with GNUNET_FS_OPTIONS_END
+ * @return NULL on error
*/
struct GNUNET_FS_Handle *
GNUNET_FS_start (struct GNUNET_SCHEDULER_Handle *sched,
const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *client_name,
GNUNET_FS_ProgressCallback upcb,
- void *upcb_cls);
+ void *upcb_cls,
+ enum GNUNET_FS_Flags flags,
+ ...);
/**
GNUNET_FS_stop (struct GNUNET_FS_Handle *h);
+/**
+ * Extract meta-data from a file.
+ *
+ * @param md metadata to set
+ * @param filename name of file to inspect
+ * @param extractors plugins to use
+ * @return GNUNET_SYSERR on error, otherwise the number
+ * of meta-data items obtained
+ */
+int
+GNUNET_FS_meta_data_extract_from_file (struct
+ GNUNET_CONTAINER_MetaData
+ *md, const char *filename,
+ struct EXTRACTOR_PluginList *
+ extractors);
+
+
/**
* Function called on entries in a GNUNET_FS_FileInformation publish-structure.
*
* @param uri pointer to the keywords that will be used for this entry (can be modified)
* @param anonymity pointer to selected anonymity level (can be modified)
* @param priority pointer to selected priority (can be modified)
+ * @param do_index should we index (can be modified)
* @param expirationTime pointer to selected expiration time (can be modified)
* @param client_info pointer to client context set upon creation (can be modified)
* @return GNUNET_OK to continue, GNUNET_NO to remove
uint64_t length,
struct GNUNET_CONTAINER_MetaData *meta,
struct GNUNET_FS_Uri **uri,
- unsigned int *anonymity,
- unsigned int *priority,
+ uint32_t *anonymity,
+ uint32_t *priority,
+ int *do_index,
struct GNUNET_TIME_Absolute *expirationTime,
void **client_info);
-/**
- * Recover file information structure from disk.
- *
- * @param name filename for the structure on disk
- * @return NULL on error
- */
-struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_recover (const char *name);
-
-
/**
* Obtain the name under which this file information
* structure is stored on disk. Only works for top-level
GNUNET_FS_file_information_get_id (struct GNUNET_FS_FileInformation *s);
-/**
- * Synchronize this file-information struct with its mirror
- * on disk. Note that all internal FS-operations that change
- * file information data should already call "sync" internally,
- * so this function is likely not useful for clients.
- *
- * @param s the struct to sync
- */
-void
-GNUNET_FS_file_information_sync (struct GNUNET_FS_FileInformation *s);
-
/**
* Create an entry for a file in a publish-structure.
*
+ * @param h handle to the file sharing subsystem
+ * @param client_info initial client-info value for this entry
* @param filename name of the file or directory to publish
* @param keywords under which keywords should this file be available
* directly; can be NULL
* @return publish structure entry for the file
*/
struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_from_file (void *client_info,
+GNUNET_FS_file_information_create_from_file (struct GNUNET_FS_Handle *h,
+ void *client_info,
const char *filename,
const struct GNUNET_FS_Uri *keywords,
const struct GNUNET_CONTAINER_MetaData *meta,
int do_index,
- unsigned int anonymity,
- unsigned int priority,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expirationTime);
/**
* Create an entry for a file in a publish-structure.
*
+ * @param h handle to the file sharing subsystem
+ * @param client_info initial client-info value for this entry
* @param length length of the file
* @param data data for the file (should not be used afterwards by
- * the caller; caller will "free")
+ * the caller; callee will "free")
* @param keywords under which keywords should this file be available
* directly; can be NULL
* @param meta metadata for the file
* @return publish structure entry for the file
*/
struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_from_data (void *client_info,
+GNUNET_FS_file_information_create_from_data (struct GNUNET_FS_Handle *h,
+ void *client_info,
uint64_t length,
void *data,
const struct GNUNET_FS_Uri *keywords,
const struct GNUNET_CONTAINER_MetaData *meta,
int do_index,
- unsigned int anonymity,
- unsigned int priority,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expirationTime);
/**
* Create an entry for a file in a publish-structure.
*
+ * @param h handle to the file sharing subsystem
+ * @param client_info initial client-info value for this entry
* @param length length of the file
* @param reader function that can be used to obtain the data for the file
* @param reader_cls closure for "reader"
* @return publish structure entry for the file
*/
struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_from_reader (void *client_info,
+GNUNET_FS_file_information_create_from_reader (struct GNUNET_FS_Handle *h,
+ void *client_info,
uint64_t length,
GNUNET_FS_DataReader reader,
void *reader_cls,
const struct GNUNET_FS_Uri *keywords,
const struct GNUNET_CONTAINER_MetaData *meta,
int do_index,
- unsigned int anonymity,
- unsigned int priority,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expirationTime);
* Type of a function that will be used to scan a directory.
*
* @param cls closure
+ * @param h handle to the file sharing subsystem
* @param dirname name of the directory to scan
* @param do_index should files be indexed or inserted
* @param anonymity desired anonymity level
* @return GNUNET_OK on success
*/
typedef int (*GNUNET_FS_DirectoryScanner)(void *cls,
+ struct GNUNET_FS_Handle *h,
const char *dirname,
int do_index,
- unsigned int anonymity,
- unsigned int priority,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expirationTime,
GNUNET_FS_FileProcessor proc,
void *proc_cls,
* convenience function.
*
* @param cls must be of type "struct EXTRACTOR_Extractor*"
+ * @param h handle to the file sharing subsystem
* @param dirname name of the directory to scan
* @param do_index should files be indexed or inserted
* @param anonymity desired anonymity level
*/
int
GNUNET_FS_directory_scanner_default (void *cls,
+ struct GNUNET_FS_Handle *h,
const char *dirname,
int do_index,
- unsigned int anonymity,
- unsigned int priority,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expirationTime,
GNUNET_FS_FileProcessor proc,
void *proc_cls,
* passed (GNUNET_FS_directory_scanner_default). This is strictly a
* convenience function.
*
+ * @param h handle to the file sharing subsystem
+ * @param client_info initial client-info value for this entry
* @param filename name of the top-level file or directory
* @param scanner function used to get a list of files in a directory
* @param scanner_cls closure for scanner
* @return publish structure entry for the directory, NULL on error
*/
struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_from_directory (void *client_info,
+GNUNET_FS_file_information_create_from_directory (struct GNUNET_FS_Handle *h,
+ void *client_info,
const char *filename,
GNUNET_FS_DirectoryScanner scanner,
void *scanner_cls,
int do_index,
- unsigned int anonymity,
- unsigned int priority,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expirationTime,
char **emsg);
* use of "GNUNET_FS_file_information_create_from_directory"
* is not appropriate.
*
- * @param meta metadata for the directory
+ * @param h handle to the file sharing subsystem
+ * @param client_info initial client-info value for this entry
* @param keywords under which keywords should this directory be available
* directly; can be NULL
+ * @param meta metadata for the directory
* @param anonymity what is the desired anonymity level for sharing?
* @param priority what is the priority for OUR node to
* keep this file available? Use 0 for maximum anonymity and
* @return publish structure entry for the directory , NULL on error
*/
struct GNUNET_FS_FileInformation *
-GNUNET_FS_file_information_create_empty_directory (void *client_info,
- const struct GNUNET_CONTAINER_MetaData *meta,
+GNUNET_FS_file_information_create_empty_directory (struct GNUNET_FS_Handle *h,
+ void *client_info,
const struct GNUNET_FS_Uri *keywords,
- unsigned int anonymity,
- unsigned int priority,
+ const struct GNUNET_CONTAINER_MetaData *meta,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expirationTime);
+/**
+ * Test if a given entry represents a directory.
+ *
+ * @param ent check if this FI represents a directory
+ * @return GNUNET_YES if so, GNUNET_NO if not
+ */
+int
+GNUNET_FS_file_information_is_directory (struct GNUNET_FS_FileInformation *ent);
+
+
/**
* Add an entry to a directory in a publish-structure. Clients
* should never modify publish structures that were passed to
* "GNUNET_FS_publish_start" already.
*
* @param dir the directory
- * @param end the entry to add; the entry must not have been
+ * @param ent the entry to add; the entry must not have been
* added to any other directory at this point and
* must not include "dir" in its structure
* @return GNUNET_OK on success, GNUNET_SYSERR on error
*/
int
GNUNET_FS_file_information_add (struct GNUNET_FS_FileInformation *dir,
- struct GNUNET_FS_FileInformation *end);
+ struct GNUNET_FS_FileInformation *ent);
/**
void *cleaner_cls);
+/**
+ * Options for publishing. Compatible options
+ * can be OR'ed together.
+ */
+enum GNUNET_FS_PublishOptions
+ {
+ /**
+ * No options (use defaults for everything).
+ */
+ GNUNET_FS_PUBLISH_OPTION_NONE = 0,
+
+ /**
+ * Simulate publishing. With this option, no data will be stored
+ * in the datastore. Useful for computing URIs from files.
+ */
+ GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY = 1
+ };
+
/**
* Publish a file or directory.
*
* @param h handle to the file sharing subsystem
- * @param ctx initial value to use for the '*ctx'
- * in the callback (for the GNUNET_FS_STATUS_PUBLISH_START event).
* @param fi information about the file or directory structure to publish
* @param namespace namespace to publish the file in, NULL for no namespace
* @param nid identifier to use for the publishd content in the namespace
* (can be NULL, must be NULL if namespace is NULL)
* @param nuid update-identifier that will be used for future updates
* (can be NULL, must be NULL if namespace or nid is NULL)
+ * @param options options for the publication
* @return context that can be used to control the publish operation
*/
struct GNUNET_FS_PublishContext *
GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h,
- void *ctx,
struct GNUNET_FS_FileInformation *fi,
struct GNUNET_FS_Namespace *namespace,
const char *nid,
- const char *nuid);
+ const char *nuid,
+ enum GNUNET_FS_PublishOptions options);
/**
- * Stop an upload. Will abort incomplete uploads (but
- * not remove blocks that have already been publishd) or
- * simply clean up the state for completed uploads.
+ * Stop a publication. Will abort incomplete publications (but
+ * not remove blocks that have already been published) or
+ * simply clean up the state for completed publications.
+ * Must NOT be called from within the event callback!
*
- * @param sc context for the upload to stop
+ * @param pc context for the publication to stop
*/
void
-GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *sc);
+GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc);
+/**
+ * Signature of a function called as the continuation of a KBlock or
+ * SBlock publication.
+ *
+ * @param cls closure
+ * @param uri URI under which the block is now available, NULL on error
+ * @param emsg error message, NULL on success
+ */
+typedef void (*GNUNET_FS_PublishContinuation)(void *cls,
+ const struct GNUNET_FS_Uri *uri,
+ const char *emsg);
+
+
/**
* Publish a KBlock on GNUnet.
*
* @param h handle to the file sharing subsystem
- * @param keyword keyword to use
+ * @param ksk_uri keywords to use
* @param meta metadata to use
* @param uri URI to refer to in the KBlock
* @param expirationTime when the KBlock expires
* @param anonymity anonymity level for the KBlock
* @param priority priority for the KBlock
+ * @param cont continuation
+ * @param cont_cls closure for cont
*/
-// FIXME: CPS this one..
void
GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h,
- const char *keyword,
- struct GNUNET_CONTAINER_MetaData *meta,
- struct GNUNET_FS_Uri *uri,
+ const struct GNUNET_FS_Uri *ksk_uri,
+ const struct GNUNET_CONTAINER_MetaData *meta,
+ const struct GNUNET_FS_Uri *uri,
struct GNUNET_TIME_Absolute expirationTime,
- unsigned int anonymity,
- unsigned int priority);
+ uint32_t anonymity,
+ uint32_t priority,
+ enum GNUNET_FS_PublishOptions options,
+ GNUNET_FS_PublishContinuation cont,
+ void *cont_cls);
/**
* @param expirationTime when the SBlock expires
* @param anonymity anonymity level for the SBlock
* @param priority priority for the SBlock
+ * @param cont continuation
+ * @param cont_cls closure for cont
*/
-// FIXME: CPS this one..
void
GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h,
struct GNUNET_FS_Namespace *namespace,
const char *identifier,
const char *update,
- struct GNUNET_CONTAINER_MetaData *meta,
- struct GNUNET_FS_Uri *uri,
+ const struct GNUNET_CONTAINER_MetaData *meta,
+ const struct GNUNET_FS_Uri *uri,
struct GNUNET_TIME_Absolute expirationTime,
- unsigned int anonymity,
- unsigned int priority);
+ uint32_t anonymity,
+ uint32_t priority,
+ enum GNUNET_FS_PublishOptions options,
+ GNUNET_FS_PublishContinuation cont,
+ void *cont_cls);
/**
*
* @param cls closure
* @param filename the name of the file
+ * @param file_id hash of the contents of the indexed file
* @return GNUNET_OK to continue iteration, GNUNET_SYSERR to abort
*/
typedef int (*GNUNET_FS_IndexedFileProcessor) (void *cls,
- const char *filename);
+ const char *filename,
+ const GNUNET_HashCode *file_id);
/**
* @param h handle to the file sharing subsystem
* @param iterator function to call on each indexed file
* @param iterator_cls closure for iterator
+ * @param cont continuation to call when done;
+ * reason should be "TIMEOUT" (on
+ * error) or "PREREQ_DONE" (on success)
+ * @param cont_cls closure for cont
*/
void
GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h,
GNUNET_FS_IndexedFileProcessor iterator,
- void *iterator_cls);
+ void *iterator_cls,
+ GNUNET_SCHEDULER_Task cont,
+ void *cont_cls);
/**
*
* @param h handle to the file sharing subsystem
* @param filename file to unindex
+ * @param cctx initial value for the client context
* @return NULL on error, otherwise handle
*/
struct GNUNET_FS_UnindexContext *
-GNUNET_FS_unindex (struct GNUNET_FS_Handle *h,
- const char *filename);
+GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h,
+ const char *filename,
+ void *cctx);
/**
* Publish an advertismement for a namespace.
*
* @param h handle to the file sharing subsystem
+ * @param ksk_uri keywords to use for advertisment
* @param namespace handle for the namespace that should be advertised
* @param meta meta-data for the namespace advertisement
* @param anonymity for the namespace advertismement
* @param priority for the namespace advertisement
* @param expiration for the namespace advertisement
- * @param advertisementURI the keyword (!) URI to advertise the
- * namespace under (we will create a GNUNET_EC_KNBlock)
- * @param rootEntry name of the root entry in the namespace (for
- * the namespace advertisement)
- *
- * @return uri of the advertisement
+ * @param rootEntry name of the root of the namespace
+ * @param cont continuation
+ * @param cont_cls closure for cont
*/
-struct GNUNET_FS_Uri *
+void
GNUNET_FS_namespace_advertise (struct GNUNET_FS_Handle *h,
+ struct GNUNET_FS_Uri *ksk_uri,
struct GNUNET_FS_Namespace *namespace,
- const struct GNUNET_MetaData *meta,
- unsigned int anonymity,
- unsigned int priority,
+ const struct GNUNET_CONTAINER_MetaData *meta,
+ uint32_t anonymity,
+ uint32_t priority,
struct GNUNET_TIME_Absolute expiration,
- const struct GNUNET_FS_Uri *advertisementURI,
- const char *rootEntry);
+ const char *rootEntry,
+ GNUNET_FS_PublishContinuation cont,
+ void *cont_cls);
/**
void *ip_cls);
+/**
+ * Options for searching. Compatible options
+ * can be OR'ed together.
+ */
+enum GNUNET_FS_SearchOptions
+ {
+ /**
+ * No options (use defaults for everything).
+ */
+ GNUNET_FS_SEARCH_OPTION_NONE = 0,
+
+ /**
+ * Only search the local host, do not search remote systems (no P2P)
+ */
+ GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY = 1
+
+ };
+
+
/**
* Start search for content.
*
* @param uri specifies the search parameters; can be
* a KSK URI or an SKS URI.
* @param anonymity desired level of anonymity
+ * @param options options for the search
+ * @param cctx initial value for the client context
* @return context that can be used to control the search
*/
struct GNUNET_FS_SearchContext *
GNUNET_FS_search_start (struct GNUNET_FS_Handle *h,
const struct GNUNET_FS_Uri *uri,
- unsigned int anonymity);
+ uint32_t anonymity,
+ enum GNUNET_FS_SearchOptions options,
+ void *cctx);
/**
GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc);
+
+
+/**
+ * Options for downloading. Compatible options
+ * can be OR'ed together.
+ */
+enum GNUNET_FS_DownloadOptions
+ {
+ /**
+ * No options (use defaults for everything).
+ */
+ GNUNET_FS_DOWNLOAD_OPTION_NONE = 0,
+
+ /**
+ * Only download from the local host, do not access remote systems (no P2P)
+ */
+ GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY = 1,
+
+ /**
+ * Do a recursive download (that is, automatically trigger the
+ * download of files in directories).
+ */
+ GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE = 2,
+
+ /**
+ * Do not append temporary data to
+ * the target file (for the IBlocks).
+ */
+ GNUNET_FS_DOWNLOAD_NO_TEMPORARIES = 4,
+
+ /**
+ * Internal option used to flag this download as a 'probe' for a
+ * search result. Impacts the priority with which the download is
+ * run and causes signalling callbacks to be done differently.
+ * Also, probe downloads are not serialized on suspension. Normal
+ * clients should not use this!
+ */
+ GNUNET_FS_DOWNLOAD_IS_PROBE = (1<<31)
+
+ };
+
+
+
/**
* Download parts of a file. Note that this will store
* the blocks at the respective offset in the given file. Also, the
* given boundaries (if offset and length do not match the 32k FS
* block boundaries). <p>
*
- * This function should be used to focus a download towards a
+ * The given range can be used to focus a download towards a
* particular portion of the file (optimization), not to strictly
* limit the download to exactly those bytes.
*
* @param h handle to the file sharing subsystem
* @param uri the URI of the file (determines what to download); CHK or LOC URI
+ * @param meta known metadata for the file (can be NULL)
* @param filename where to store the file, maybe NULL (then no file is
* created on disk and data must be grabbed from the callbacks)
+ * @param tempname where to store temporary file data, not used if filename is non-NULL;
+ * can be NULL (in which case we will pick a name if needed); the temporary file
+ * may already exist, in which case we will try to use the data that is there and
+ * if it is not what is desired, will overwrite it
* @param offset at what offset should we start the download (typically 0)
* @param length how many bytes should be downloaded starting at offset
* @param anonymity anonymity level to use for the download
- * @param no_temporaries set to GNUNET_YES to disallow generation of temporary files
- * @param recursive should this be a recursive download (useful for directories
- * to automatically trigger download of files in the directories)
+ * @param options various download options
+ * @param cctx initial value for the client context for this download
* @param parent parent download to associate this download with (use NULL
* for top-level downloads; useful for manually-triggered recursive downloads)
* @return context that can be used to control this download
*/
struct GNUNET_FS_DownloadContext *
-GNUNET_FS_file_download_start (struct GNUNET_FS_Handle *h,
- const struct GNUNET_FS_Uri *uri,
- const char *filename,
- unsigned long long offset,
- unsigned long long length,
- unsigned int anonymity,
- int no_temporaries,
- int recursive,
- struct GNUNET_FS_DownloadContext *parent);
-
-
-/**
- * Stop a download (aborts if download is incomplete).
- *
- * @param rm handle for the download
- * @param do_delete delete files of incomplete downloads
- */
-void
-GNUNET_FS_file_download_stop (struct GNUNET_FS_DownloadContext *rm,
- int do_delete);
-
-
-/**
- * Initialize collection.
- *
- * @param h handle to the file sharing subsystem
- * @param namespace namespace to use for the collection
- * @return GNUNET_OK on success, GNUNET_SYSERR if another
- * namespace is already set for our collection
- */
-int
-GNUNET_FS_collection_start (struct GNUNET_FS_Handle *h,
- struct GNUNET_FS_Namespace *namespace);
-
-
-/**
- * Stop collection.
- *
- * @param h handle to the file sharing subsystem
- * @return GNUNET_OK on success, GNUNET_SYSERR if no collection is active
- */
-int
-GNUNET_FS_collection_stop (struct GNUNET_FS_Handle *h);
-
-
-/**
- * Are we using a collection?
+GNUNET_FS_download_start (struct GNUNET_FS_Handle *h,
+ const struct GNUNET_FS_Uri *uri,
+ const struct GNUNET_CONTAINER_MetaData *meta,
+ const char *filename,
+ const char *tempname,
+ uint64_t offset,
+ uint64_t length,
+ uint32_t anonymity,
+ enum GNUNET_FS_DownloadOptions options,
+ void *cctx,
+ struct GNUNET_FS_DownloadContext *parent);
+
+
+/**
+ * Download parts of a file based on a search result. The download
+ * will be associated with the search result (and the association
+ * will be preserved when serializing/deserializing the state).
+ * If the search is stopped, the download will not be aborted but
+ * be 'promoted' to a stand-alone download.
+ *
+ * As with the other download function, this will store
+ * the blocks at the respective offset in the given file. Also, the
+ * download is still using the blocking of the underlying FS
+ * encoding. As a result, the download may *write* outside of the
+ * given boundaries (if offset and length do not match the 32k FS
+ * block boundaries). <p>
*
- * @param h handle to the file sharing subsystem
- * @return NULL if there is no collection,
- */
-struct GNUNET_FS_Namespace *
-GNUNET_FS_collection_get(struct GNUNET_FS_Handle *h);
-
-
-/**
- * Publish an update of the current collection information to the
- * network now. The function has no effect if the collection has not
- * changed since the last publication. If we are currently not
- * collecting, this function does nothing.
+ * The given range can be used to focus a download towards a
+ * particular portion of the file (optimization), not to strictly
+ * limit the download to exactly those bytes.
*
* @param h handle to the file sharing subsystem
+ * @param sr the search result to use for the download (determines uri and
+ * meta data and associations)
+ * @param filename where to store the file, maybe NULL (then no file is
+ * created on disk and data must be grabbed from the callbacks)
+ * @param tempname where to store temporary file data, not used if filename is non-NULL;
+ * can be NULL (in which case we will pick a name if needed); the temporary file
+ * may already exist, in which case we will try to use the data that is there and
+ * if it is not what is desired, will overwrite it
+ * @param offset at what offset should we start the download (typically 0)
+ * @param length how many bytes should be downloaded starting at offset
+ * @param anonymity anonymity level to use for the download
+ * @param options various download options
+ * @param cctx initial value for the client context for this download
+ * @return context that can be used to control this download
*/
-void GNUNET_FS_collection_publish (struct GNUNET_FS_Handle *h);
+struct GNUNET_FS_DownloadContext *
+GNUNET_FS_download_start_from_search (struct GNUNET_FS_Handle *h,
+ struct GNUNET_FS_SearchResult *sr,
+ const char *filename,
+ const char *tempname,
+ uint64_t offset,
+ uint64_t length,
+ uint32_t anonymity,
+ enum GNUNET_FS_DownloadOptions options,
+ void *cctx);
/**
- * If we are currently building a collection, publish the given file
- * information in that collection. If we are currently not
- * collecting, this function does nothing.
+ * Stop a download (aborts if download is incomplete).
*
- * @param h handle to the file sharing subsystem
- * @param uri uri to add to the collection
- * @param meta metadata for the uri
+ * @param dc handle for the download
+ * @param do_delete delete files of incomplete downloads
*/
-void GNUNET_FS_collection_add (const struct GNUNET_FS_Handle *h,
- const struct GNUNET_FS_Uri *uri,
- const struct GNUNET_CONTAINER_MetaData *meta);
-
-
+void
+GNUNET_FS_download_stop (struct GNUNET_FS_DownloadContext *dc,
+ int do_delete);
GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md);
+/**
+ * Suggest a filename based on given metadata.
+ *
+ * @param md given meta data
+ * @return NULL if meta data is useless for suggesting a filename
+ */
+char *
+GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md);
+
+
/**
* Function used to process entries in a directory.
*
* @param offset offset of data in the directory
* @param dep function to call on each entry
* @param dep_cls closure for dep
+ * @return GNUNET_OK if this could be a block in a directory,
+ * GNUNET_NO if this could be part of a directory (but not 100% OK)
+ * GNUNET_SYSERR if 'data' does not represent a directory
*/
-void
+int
GNUNET_FS_directory_list_contents (size_t size,
const void *data,
uint64_t offset,
* in-memory.
*
* @param bld directory to finish
- * @param size set to the number of bytes needed
- * @param data set to the encoded directory
+ * @param rsize set to the number of bytes needed
+ * @param rdata set to the encoded directory
+ * @return GNUNET_OK on success
*/
-void
+int
GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
- size_t *size,
- void **data);
+ size_t *rsize,
+ void **rdata);
#if 0 /* keep Emacsens' auto-indent happy */
projects / oweals / gnunet.git / blobdiff