FS service

File sharing. More...

Data Structures
struct	GNUNET_FS_ProgressInfo
	Argument given to the progress callback with information about what is going on. More...
struct	GNUNET_FS_BlockOptions
	Settings for publishing a block (which may of course also apply to an entire directory or file). More...
struct	GNUNET_FS_ShareTreeItem
	A node of a directory tree (produced by dirscanner) More...

Macros
#define	GNUNET_FS_VERSION   0x00090300
	Version number of the implementation. More...
#define	GNUNET_FS_URI_PREFIX   "gnunet://fs/"
#define	GNUNET_FS_URI_KSK_INFIX   "ksk/"
#define	GNUNET_FS_URI_SKS_INFIX   "sks/"
#define	GNUNET_FS_URI_CHK_INFIX   "chk/"
#define	GNUNET_FS_URI_LOC_INFIX   "loc/"
#define	GNUNET_FS_PROBE_UPDATE_FREQUENCY   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
	How often do we signal applications that a probe for a particular search result is running? (used to visualize probes). More...
#define	GNUNET_FS_DIRECTORY_MIME   "application/gnunet-directory"
#define	GNUNET_FS_DIRECTORY_MAGIC   "\211GND\r\n\032\n"
#define	GNUNET_FS_DIRECTORY_EXT   ".gnd"

Typedefs
typedef int(*	GNUNET_FS_KeywordIterator) (void *cls, const char *keyword, int is_mandatory)
	Iterator over keywords. More...
typedef void *(*	GNUNET_FS_ProgressCallback) (void *cls, const struct GNUNET_FS_ProgressInfo *info)
	Notification of FS to a client about the progress of an operation. More...
typedef int(*	GNUNET_FS_FileInformationProcessor) (void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
	Function called on entries in a struct GNUNET_FS_FileInformation iteration. More...
typedef size_t(*	GNUNET_FS_DataReader) (void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
	Function that provides data. More...
typedef void(*	GNUNET_FS_PublishContinuation) (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)
	Signature of a function called as the continuation of a KBlock or SBlock publication. More...
typedef int(*	GNUNET_FS_IndexedFileProcessor) (void *cls, const char *filename, const struct GNUNET_HashCode *file_id)
	Type of a function called by GNUNET_FS_get_indexed_files. More...
typedef void(*	GNUNET_FS_IdentifierProcessor) (void *cls, const char *last_id, const struct GNUNET_FS_Uri *last_uri, const struct GNUNET_CONTAINER_MetaData *last_meta, const char *next_id)
	Function called on updateable identifiers. More...
typedef void(*	GNUNET_FS_DirectoryEntryProcessor) (void *cls, const char *filename, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, size_t length, const void *data)
	Function used to process entries in a directory. More...
typedef void(*	GNUNET_FS_DirScannerProgressCallback) (void *cls, const char *filename, int is_directory, enum GNUNET_FS_DirScannerProgressUpdateReason reason)
	Function called over time as the directory scanner makes progress on the job at hand. More...

Enumerations
enum	GNUNET_FS_Status {   GNUNET_FS_STATUS_PUBLISH_START = 0, GNUNET_FS_STATUS_PUBLISH_RESUME = 1, GNUNET_FS_STATUS_PUBLISH_SUSPEND = 2, GNUNET_FS_STATUS_PUBLISH_PROGRESS = 3,   GNUNET_FS_STATUS_PUBLISH_ERROR = 4, GNUNET_FS_STATUS_PUBLISH_COMPLETED = 5, GNUNET_FS_STATUS_PUBLISH_STOPPED = 6, GNUNET_FS_STATUS_DOWNLOAD_START = 7,   GNUNET_FS_STATUS_DOWNLOAD_RESUME = 8, GNUNET_FS_STATUS_DOWNLOAD_SUSPEND = 9, GNUNET_FS_STATUS_DOWNLOAD_PROGRESS = 10, GNUNET_FS_STATUS_DOWNLOAD_ERROR = 11,   GNUNET_FS_STATUS_DOWNLOAD_COMPLETED = 12, GNUNET_FS_STATUS_DOWNLOAD_STOPPED = 13, GNUNET_FS_STATUS_DOWNLOAD_ACTIVE = 14, GNUNET_FS_STATUS_DOWNLOAD_INACTIVE = 15,   GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT = 16, GNUNET_FS_STATUS_SEARCH_START = 17, GNUNET_FS_STATUS_SEARCH_RESUME = 18, GNUNET_FS_STATUS_SEARCH_RESUME_RESULT = 19,   GNUNET_FS_STATUS_SEARCH_SUSPEND = 20, GNUNET_FS_STATUS_SEARCH_RESULT = 21, GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE = 22, GNUNET_FS_STATUS_SEARCH_UPDATE = 23,   GNUNET_FS_STATUS_SEARCH_ERROR = 24, GNUNET_FS_STATUS_SEARCH_PAUSED = 25, GNUNET_FS_STATUS_SEARCH_CONTINUED = 26, GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED = 27,   GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND = 28, GNUNET_FS_STATUS_SEARCH_STOPPED = 29, GNUNET_FS_STATUS_UNINDEX_START = 30, GNUNET_FS_STATUS_UNINDEX_RESUME = 31,   GNUNET_FS_STATUS_UNINDEX_SUSPEND = 32, GNUNET_FS_STATUS_UNINDEX_PROGRESS = 33, GNUNET_FS_STATUS_UNINDEX_ERROR = 34, GNUNET_FS_STATUS_UNINDEX_COMPLETED = 35,   GNUNET_FS_STATUS_UNINDEX_STOPPED = 36, GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY = 37 }
	Possible status codes used in the callback for the various file-sharing operations. More...
enum	GNUNET_FS_Flags { GNUNET_FS_FLAGS_NONE = 0, GNUNET_FS_FLAGS_PERSISTENCE = 1, GNUNET_FS_FLAGS_DO_PROBES = 2 }
	General (global) option flags for file-sharing. More...
enum	GNUNET_FS_OPTIONS { GNUNET_FS_OPTIONS_END = 0, GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM = 1, GNUNET_FS_OPTIONS_REQUEST_PARALLELISM = 2 }
	Options specified in the VARARGs portion of GNUNET_FS_start. More...
enum	GNUNET_FS_PublishOptions { GNUNET_FS_PUBLISH_OPTION_NONE = 0, GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY = 1 }
	Options for publishing. More...
enum	GNUNET_FS_SearchOptions { GNUNET_FS_SEARCH_OPTION_NONE = 0, GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY = 1 }
	Options for searching. More...
enum	GNUNET_FS_DownloadOptions {   GNUNET_FS_DOWNLOAD_OPTION_NONE = 0, GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY = 1, GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE = 2, GNUNET_FS_DOWNLOAD_NO_TEMPORARIES = 4,   GNUNET_FS_DOWNLOAD_IS_PROBE = (1 << 31) }
	Options for downloading. More...
enum	GNUNET_FS_DirScannerProgressUpdateReason {   GNUNET_FS_DIRSCANNER_FILE_START = 0, GNUNET_FS_DIRSCANNER_FILE_IGNORED, GNUNET_FS_DIRSCANNER_ALL_COUNTED, GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED,   GNUNET_FS_DIRSCANNER_FINISHED, GNUNET_FS_DIRSCANNER_INTERNAL_ERROR }
	Progress reasons of the directory scanner. More...

Functions
int	GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode *key)
	Get a unique key from a URI. More...
char *	GNUNET_FS_uri_to_string (const struct GNUNET_FS_Uri *uri)
	Convert a URI to a UTF-8 String. More...
char *	GNUNET_FS_uri_ksk_to_string_fancy (const struct GNUNET_FS_Uri *uri)
	Convert keyword URI to a human readable format (i.e. More...
void	GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri, const char *keyword, int is_mandatory)
	Add the given keyword to the set of keywords represented by the URI. More...
void	GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri *uri, const char *keyword)
	Remove the given keyword from the set of keywords represented by the URI. More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_parse (const char *uri, char **emsg)
	Convert a UTF-8 String to a URI. More...
void	GNUNET_FS_uri_destroy (struct GNUNET_FS_Uri *uri)
	Free URI. More...
unsigned int	GNUNET_FS_uri_ksk_get_keyword_count (const struct GNUNET_FS_Uri *uri)
	How many keywords are ANDed in this keyword URI? More...
int	GNUNET_FS_uri_ksk_get_keywords (const struct GNUNET_FS_Uri *uri, GNUNET_FS_KeywordIterator iterator, void *iterator_cls)
	Iterate over all keywords in this keyword URI. More...
int	GNUNET_FS_uri_loc_get_peer_identity (const struct GNUNET_FS_Uri *uri, struct GNUNET_PeerIdentity *peer)
	Obtain the identity of the peer offering the data. More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_loc_get_uri (const struct GNUNET_FS_Uri *uri)
	Obtain the URI of the content itself. More...
struct GNUNET_TIME_Absolute	GNUNET_FS_uri_loc_get_expiration (const struct GNUNET_FS_Uri *uri)
	Obtain the expiration of the LOC URI. More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *base_uri, const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key, struct GNUNET_TIME_Absolute expiration_time)
	Construct a location URI (this peer will be used for the location). More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
	Merge the sets of keywords from two KSK URIs. More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri)
	Duplicate URI. More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_create (const char *keywords, char **emsg)
	Create an FS URI from a single user-supplied string of keywords. More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_create_from_args (unsigned int argc, const char **argv)
	Create an FS URI from a user-supplied command line of keywords. More...
int	GNUNET_FS_uri_test_equal (const struct GNUNET_FS_Uri *u1, const struct GNUNET_FS_Uri *u2)
	Test if two URIs are equal. More...
int	GNUNET_FS_uri_test_sks (const struct GNUNET_FS_Uri *uri)
	Is this a namespace URI? More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *id)
	Create an SKS URI from a namespace ID and an identifier. More...
int	GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri, struct GNUNET_CRYPTO_EcdsaPublicKey *pseudonym)
	Get the public key of a namespace from the given namespace URI. More...
char *	GNUNET_FS_uri_sks_get_content_id (const struct GNUNET_FS_Uri *uri)
	Get the content identifier of an SKS URI. More...
int	GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri)
	Is this a keyword URI? More...
int	GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri)
	Is this a file (or directory) URI? More...
uint64_t	GNUNET_FS_uri_chk_get_file_size (const struct GNUNET_FS_Uri *uri)
	What is the size of the file that this URI refers to? More...
int	GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
	Is this a location URI? More...
struct GNUNET_FS_Uri *	GNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData *md)
	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). More...
struct GNUNET_GETOPT_CommandLineOption	GNUNET_FS_GETOPT_KEYWORDS (char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_FS_Uri **topKeywords)
	Allow user to specify keywords. More...
struct GNUNET_GETOPT_CommandLineOption	GNUNET_FS_GETOPT_METADATA (char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_CONTAINER_MetaData **meta)
	Allow user to specify metadata. More...
int	GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx, void *scls, const char *option, const char *value)
	Command-line option parser function that allows the user to specify one or more '-m' options with metadata. More...
struct GNUNET_FS_Handle *	GNUNET_FS_start (const struct GNUNET_CONFIGURATION_Handle *cfg, const char *client_name, GNUNET_FS_ProgressCallback upcb, void *upcb_cls, enum GNUNET_FS_Flags flags,...)
	Setup a connection to the file-sharing service. More...
void	GNUNET_FS_stop (struct GNUNET_FS_Handle *h)
	Close our connection with the file-sharing service. More...
const char *	GNUNET_FS_file_information_get_id (struct GNUNET_FS_FileInformation *s)
	Obtain the name under which this file information structure is stored on disk. More...
const char *	GNUNET_FS_file_information_get_filename (struct GNUNET_FS_FileInformation *s)
	Obtain the filename from the file information structure. More...
void	GNUNET_FS_file_information_set_filename (struct GNUNET_FS_FileInformation *s, const char *filename)
	Set the filename in the file information structure. More...
struct GNUNET_FS_FileInformation *	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, const struct GNUNET_FS_BlockOptions *bo)
	Create an entry for a file in a publish-structure. More...
struct GNUNET_FS_FileInformation *	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, const struct GNUNET_FS_BlockOptions *bo)
	Create an entry for a file in a publish-structure. More...
struct GNUNET_FS_FileInformation *	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, const struct GNUNET_FS_BlockOptions *bo)
	Create an entry for a file in a publish-structure. More...
struct GNUNET_FS_FileInformation *	GNUNET_FS_file_information_create_empty_directory (struct GNUNET_FS_Handle *h, void *client_info, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_BlockOptions *bo, const char *filename)
	Create an entry for an empty directory in a publish-structure. More...
int	GNUNET_FS_file_information_is_directory (const struct GNUNET_FS_FileInformation *ent)
	Test if a given entry represents a directory. More...
int	GNUNET_FS_file_information_add (struct GNUNET_FS_FileInformation *dir, struct GNUNET_FS_FileInformation *ent)
	Add an entry to a directory in a publish-structure. More...
void	GNUNET_FS_file_information_inspect (struct GNUNET_FS_FileInformation *dir, GNUNET_FS_FileInformationProcessor proc, void *proc_cls)
	Inspect a file or directory in a publish-structure. More...
void	GNUNET_FS_file_information_destroy (struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
	Destroy publish-structure. More...
struct GNUNET_FS_PublishContext *	GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h, struct GNUNET_FS_FileInformation *fi, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *nid, const char *nuid, enum GNUNET_FS_PublishOptions options)
	Publish a file or directory. More...
void	GNUNET_FS_publish_stop (struct GNUNET_FS_PublishContext *pc)
	Stop a publication. More...
struct GNUNET_FS_PublishKskContext *	GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *ksk_uri, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
	Publish a KBlock on GNUnet. More...
void	GNUNET_FS_publish_ksk_cancel (struct GNUNET_FS_PublishKskContext *pkc)
	Abort the KSK publishing operation. More...
struct GNUNET_FS_PublishSksContext *	GNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *identifier, const char *update, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
	Publish an SBlock on GNUnet. More...
void	GNUNET_FS_publish_sks_cancel (struct GNUNET_FS_PublishSksContext *psc)
	Abort the SKS publishing operation. More...
struct GNUNET_FS_GetIndexedContext *	GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h, GNUNET_FS_IndexedFileProcessor iterator, void *iterator_cls)
	Iterate over all indexed files. More...
void	GNUNET_FS_get_indexed_files_cancel (struct GNUNET_FS_GetIndexedContext *gic)
	Cancel iteration over all indexed files. More...
struct GNUNET_FS_UnindexContext *	GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h, const char *filename, void *cctx)
	Unindex a file. More...
void	GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc)
	Clean up after completion of an unindex operation. More...
void	GNUNET_FS_namespace_list_updateable (struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *next_id, GNUNET_FS_IdentifierProcessor ip, void *ip_cls)
	List all of the identifiers in the namespace for which we could produce an update. More...
struct GNUNET_FS_SearchContext *	GNUNET_FS_search_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx)
	Start search for content. More...
void	GNUNET_FS_search_pause (struct GNUNET_FS_SearchContext *sc)
	Pause search. More...
void	GNUNET_FS_search_continue (struct GNUNET_FS_SearchContext *sc)
	Continue paused search. More...
void	GNUNET_FS_search_stop (struct GNUNET_FS_SearchContext *sc)
	Stop search for content. More...
struct GNUNET_FS_SearchResult *	GNUNET_FS_probe (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, void *client_info, uint32_t anonymity)
	Start download probes for the given search result. More...
void *	GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr)
	Stop probe activity. More...
struct GNUNET_FS_DownloadContext *	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. More...
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)
	Download parts of a file based on a search result. More...
void	GNUNET_FS_download_stop (struct GNUNET_FS_DownloadContext *dc, int do_delete)
	Stop a download (aborts if download is incomplete). More...
void	GNUNET_FS_download_suspend (struct GNUNET_FS_DownloadContext *dc)
	Suspend a download. More...
void	GNUNET_FS_download_resume (struct GNUNET_FS_DownloadContext *dc)
	Resume a suspended download. More...
int	GNUNET_FS_meta_data_test_for_directory (const struct GNUNET_CONTAINER_MetaData *md)
	Does the meta-data claim that this is a directory? Checks if the mime-type is that of a GNUnet directory. More...
void	GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md)
	Set the MIMETYPE information for the given metadata to "application/gnunet-directory". More...
char *	GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md)
	Suggest a filename based on given metadata. More...
int	GNUNET_FS_directory_list_contents (size_t size, const void *data, uint64_t offset, GNUNET_FS_DirectoryEntryProcessor dep, void *dep_cls)
	Iterate over all entries in a directory. More...
struct GNUNET_FS_DirectoryBuilder *	GNUNET_FS_directory_builder_create (const struct GNUNET_CONTAINER_MetaData *mdir)
	Create a directory builder. More...
void	GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *md, const void *data)
	Add an entry to a directory. More...
int	GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld, size_t *rsize, void **rdata)
	Finish building the directory. More...
struct GNUNET_FS_DirScanner *	GNUNET_FS_directory_scan_start (const char *filename, int disable_extractor, const char *ex, GNUNET_FS_DirScannerProgressCallback cb, void *cb_cls)
	Start a directory scanner. More...
void	GNUNET_FS_directory_scan_abort (struct GNUNET_FS_DirScanner *ds)
	Abort the scan. More...
struct GNUNET_FS_ShareTreeItem *	GNUNET_FS_directory_scan_get_result (struct GNUNET_FS_DirScanner *ds)
	Obtain the result of the scan after the scan has signalled completion. More...
void	GNUNET_FS_share_tree_trim (struct GNUNET_FS_ShareTreeItem *toplevel)
	Process a share item tree, moving frequent keywords up and copying frequent metadata up. More...
void	GNUNET_FS_share_tree_free (struct GNUNET_FS_ShareTreeItem *toplevel)
	Release memory of a share item tree. More...

Detailed Description

File sharing.

See also

Documentation

Macro Definition Documentation

GNUNET_FS_VERSION

#define GNUNET_FS_VERSION   0x00090300

Version number of the implementation.

History:

1.x.x: initial version with triple GNUNET_hash and merkle tree 2.x.x: root node with mime-type, filename and version number 2.1.x: combined GNUNET_EC_ContentHashKey/3HASH encoding with 25:1 super-nodes 2.2.x: with directories 3.0.x: with namespaces 3.1.x: with namespace meta-data 3.2.x: with collections 4.0.x: with expiration, variable meta-data, kblocks 4.1.x: with new error and configuration handling 5.0.x: with location URIs 6.0.0: with support for OR in KSKs 6.1.x: with simplified namespace support 9.0.0: CPS-style integrated API 9.1.1: asynchronous directory scanning 9.2.0: unified K-Block and S-block format (#2564) 9.3.0: base32crockford encoded URLs

Definition at line 67 of file gnunet_fs_service.h.

Referenced by process_kblock().

GNUNET_FS_URI_PREFIX

#define GNUNET_FS_URI_PREFIX   "gnunet://fs/"

Definition at line 72 of file gnunet_fs_service.h.

Referenced by GNUNET_FS_uri_ksk_create_from_args(), uri_chk_to_string(), uri_ksk_to_string(), uri_loc_to_string(), and uri_sks_to_string().

GNUNET_FS_URI_KSK_INFIX

#define GNUNET_FS_URI_KSK_INFIX   "ksk/"

Definition at line 73 of file gnunet_fs_service.h.

Referenced by uri_ksk_to_string().

GNUNET_FS_URI_SKS_INFIX

#define GNUNET_FS_URI_SKS_INFIX   "sks/"

Definition at line 74 of file gnunet_fs_service.h.

Referenced by uri_sks_to_string().

GNUNET_FS_URI_CHK_INFIX

#define GNUNET_FS_URI_CHK_INFIX   "chk/"

Definition at line 75 of file gnunet_fs_service.h.

Referenced by uri_chk_to_string().

GNUNET_FS_URI_LOC_INFIX

#define GNUNET_FS_URI_LOC_INFIX   "loc/"

Definition at line 76 of file gnunet_fs_service.h.

Referenced by uri_loc_to_string().

GNUNET_FS_PROBE_UPDATE_FREQUENCY

#define GNUNET_FS_PROBE_UPDATE_FREQUENCY   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)

How often do we signal applications that a probe for a particular search result is running? (used to visualize probes).

Definition at line 83 of file gnunet_fs_service.h.

Referenced by probe_ping_task_cb().

GNUNET_FS_DIRECTORY_MIME

#define GNUNET_FS_DIRECTORY_MIME   "application/gnunet-directory"

Definition at line 2514 of file gnunet_fs_service.h.

Referenced by get_file_information(), GNUNET_FS_meta_data_make_directory(), and GNUNET_FS_meta_data_test_for_directory().

GNUNET_FS_DIRECTORY_MAGIC

#define GNUNET_FS_DIRECTORY_MAGIC   "\211GND\r\n\032\n"

Definition at line 2515 of file gnunet_fs_service.h.

Referenced by GNUNET_FS_directory_list_contents().

GNUNET_FS_DIRECTORY_EXT

#define GNUNET_FS_DIRECTORY_EXT   ".gnd"

Definition at line 2516 of file gnunet_fs_service.h.

Referenced by is_recursive_download(), progress_cb(), and trigger_recursive_download().

Typedef Documentation

GNUNET_FS_KeywordIterator

typedef int(* GNUNET_FS_KeywordIterator) (void *cls, const char *keyword, int is_mandatory)

Iterator over keywords.

Parameters

cls	closure
keyword	the keyword
is_mandatory	is the keyword mandatory (in a search)

Returns

GNUNET_OK to continue to iterate, GNUNET_SYSERR to abort

Definition at line 100 of file gnunet_fs_service.h.

GNUNET_FS_ProgressCallback

typedef void*(* GNUNET_FS_ProgressCallback) (void *cls, const struct GNUNET_FS_ProgressInfo *info)

Notification of FS to a client about the progress of an operation.

Callbacks of this type will be used for uploads, downloads and searches. Some of the arguments depend a bit in their meaning on the context in which the callback is used.

Parameters

cls	closure
info	details about the event, specifying the event type and various bits about the event

Returns

client-context (for the next progress call 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 struct GNUNET_FS_ProgressInfo.

Definition at line 1608 of file gnunet_fs_service.h.

GNUNET_FS_FileInformationProcessor

typedef int(* GNUNET_FS_FileInformationProcessor) (void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)

Function called on entries in a struct GNUNET_FS_FileInformation iteration.

Parameters

cls	closure
fi	the entry in the publish-structure
length	length of the file or directory
meta	metadata for the file or directory (can be modified)
uri	pointer to the keywords that will be used for this entry (can be modified)
bo	block options (can be modified)
do_index	should we index (can be modified)
client_info	pointer to client context set upon creation (can be modified)

Returns

GNUNET_OK to continue, GNUNET_NO to remove this entry from the directory, GNUNET_SYSERR to abort the iteration

Definition at line 1765 of file gnunet_fs_service.h.

GNUNET_FS_DataReader

typedef size_t(* GNUNET_FS_DataReader) (void *cls, uint64_t offset, size_t max, void *buf, char **emsg)

Function that provides data.

Parameters

cls	closure
offset	offset to read from; it is possible that the caller might need to go backwards a bit at times; set to UINT64_MAX to tell the reader that we won't be reading for a while (used to close the file descriptor but NOT fully clean up the reader's state); in this case, a value of '0' for max should be ignored
max	maximum number of bytes that should be copied to 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
buf	where the reader should write the data
emsg	location for the reader to store an error message

Returns

number of bytes written, usually max, 0 on error

Definition at line 1883 of file gnunet_fs_service.h.

GNUNET_FS_PublishContinuation

typedef void(* GNUNET_FS_PublishContinuation) (void *cls, const struct GNUNET_FS_Uri *uri, const char *emsg)

Signature of a function called as the continuation of a KBlock or SBlock publication.

Parameters

cls	closure
uri	URI under which the block is now available, NULL on error
emsg	error message, NULL on success

Definition at line 2071 of file gnunet_fs_service.h.

GNUNET_FS_IndexedFileProcessor

typedef int(* GNUNET_FS_IndexedFileProcessor) (void *cls, const char *filename, const struct GNUNET_HashCode *file_id)

Type of a function called by GNUNET_FS_get_indexed_files.

Parameters

cls	closure
filename	the name of the file, NULL for end of list
file_id	hash of the contents of the indexed file

Returns

GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 2165 of file gnunet_fs_service.h.

GNUNET_FS_IdentifierProcessor

typedef void(* GNUNET_FS_IdentifierProcessor) (void *cls, const char *last_id, const struct GNUNET_FS_Uri *last_uri, const struct GNUNET_CONTAINER_MetaData *last_meta, const char *next_id)

Function called on updateable identifiers.

Parameters

cls	closure
last_id	last identifier
last_uri	uri used for the content published under the last_id
last_meta	metadata associated with last_uri
next_id	identifier that should be used for updates

Definition at line 2231 of file gnunet_fs_service.h.

GNUNET_FS_DirectoryEntryProcessor

typedef void(* GNUNET_FS_DirectoryEntryProcessor) (void *cls, const char *filename, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, size_t length, const void *data)

Function used to process entries in a directory.

Parameters

cls	closure
filename	name of the file in the directory
uri	URI of the file
metadata	metadata for the file; metadata for the directory if everything else is NULL/zero
length	length of the available data for the file (of type size_t since data must certainly fit into memory; if files are larger than size_t permits, then they will certainly not be embedded with the directory itself).
data	data available for the file (length bytes)

Definition at line 2565 of file gnunet_fs_service.h.

GNUNET_FS_DirScannerProgressCallback

typedef void(* GNUNET_FS_DirScannerProgressCallback) (void *cls, const char *filename, int is_directory, enum GNUNET_FS_DirScannerProgressUpdateReason reason)

Function called over time as the directory scanner makes progress on the job at hand.

Parameters

cls	closure
filename	which file we are making progress on
is_directory	GNUNET_YES if this is a directory, GNUNET_NO if this is a file GNUNET_SYSERR if it is neither (or unknown)
reason	kind of progress we are making

Definition at line 2703 of file gnunet_fs_service.h.

Enumeration Type Documentation

GNUNET_FS_Status

enum GNUNET_FS_Status

Possible status codes used in the callback for the various file-sharing operations.

On each file (or search), the callback is guaranteed to be called once with "START" and once with STOPPED; calls with PROGRESS, ERROR or COMPLETED are optional and depend on the circumstances; parent operations will be STARTED before child-operations and STOPPED after their respective child-operations. START and STOP signals are typically generated either due to explicit client requests or because of suspend/resume operations.

Enumerator
GNUNET_FS_STATUS_PUBLISH_START	Notification that we have started to publish a file structure.
GNUNET_FS_STATUS_PUBLISH_RESUME	Notification that we have resumed sharing a file structure.
GNUNET_FS_STATUS_PUBLISH_SUSPEND	Notification that we have suspended sharing a file structure.
GNUNET_FS_STATUS_PUBLISH_PROGRESS	Notification that we are making progress sharing a file structure.
GNUNET_FS_STATUS_PUBLISH_ERROR	Notification that an error was encountered sharing a file structure. The application will continue to receive resume/suspend events for this structure until "GNUNET_FS_publish_stop" is called.
GNUNET_FS_STATUS_PUBLISH_COMPLETED	Notification that we completed sharing a file structure. The application will continue to receive resume/suspend events for this structure until "GNUNET_FS_publish_stop" is called.
GNUNET_FS_STATUS_PUBLISH_STOPPED	Notification that we have stopped the process of uploading a file structure; no futher events will be generated for this action.
GNUNET_FS_STATUS_DOWNLOAD_START	Notification that we have started this download.
GNUNET_FS_STATUS_DOWNLOAD_RESUME	Notification that this download is being resumed.
GNUNET_FS_STATUS_DOWNLOAD_SUSPEND	Notification that this download was suspended.
GNUNET_FS_STATUS_DOWNLOAD_PROGRESS	Notification about progress with this download.
GNUNET_FS_STATUS_DOWNLOAD_ERROR	Notification that this download encountered an error.
GNUNET_FS_STATUS_DOWNLOAD_COMPLETED	Notification that this download completed. Note that for directories, completion does not imply completion of all files in the directory.
GNUNET_FS_STATUS_DOWNLOAD_STOPPED	Notification that this download was stopped (final event with respect to this action).
GNUNET_FS_STATUS_DOWNLOAD_ACTIVE	Notification that this download is now actively being pursued (as opposed to waiting in the queue).
GNUNET_FS_STATUS_DOWNLOAD_INACTIVE	Notification that this download is no longer actively being pursued (back in the queue).
GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT	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_SEARCH_START	First event generated when a client requests a search to begin or when a namespace result automatically triggers the search for updates.
GNUNET_FS_STATUS_SEARCH_RESUME	Last event when a search is being resumed; note that "GNUNET_FS_SEARCH_START" will not be generated in this case.
GNUNET_FS_STATUS_SEARCH_RESUME_RESULT	Event generated for each search result when the respective search is resumed.
GNUNET_FS_STATUS_SEARCH_SUSPEND	Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generated in this case.
GNUNET_FS_STATUS_SEARCH_RESULT	This search has yielded a result.
GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE	We have discovered a new namespace.
GNUNET_FS_STATUS_SEARCH_UPDATE	We have additional data about the quality or availability of a search result.
GNUNET_FS_STATUS_SEARCH_ERROR	Signals a problem with this search.
GNUNET_FS_STATUS_SEARCH_PAUSED	Signals that this search was paused.
GNUNET_FS_STATUS_SEARCH_CONTINUED	Signals that this search was continued (unpaused).
GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED	Event generated for each search result when the respective search is stopped.
GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND	Event generated for each search result when the respective search is suspended.
GNUNET_FS_STATUS_SEARCH_STOPPED	Last message from a search; this signals that there will be no further events associated with this search.
GNUNET_FS_STATUS_UNINDEX_START	Notification that we started to unindex a file.
GNUNET_FS_STATUS_UNINDEX_RESUME	Notification that we resumed unindexing of a file.
GNUNET_FS_STATUS_UNINDEX_SUSPEND	Notification that we suspended unindexing a file.
GNUNET_FS_STATUS_UNINDEX_PROGRESS	Notification that we made progress unindexing a file.
GNUNET_FS_STATUS_UNINDEX_ERROR	Notification that we encountered an error unindexing a file.
GNUNET_FS_STATUS_UNINDEX_COMPLETED	Notification that the unindexing of this file was completed.
GNUNET_FS_STATUS_UNINDEX_STOPPED	Notification that the unindexing of this file was stopped (final event for this action).
GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY	Notification that we are making progress sharing a directory.

Definition at line 507 of file gnunet_fs_service.h.

{
  GNUNET_FS_STATUS_PUBLISH_START = 0,

  GNUNET_FS_STATUS_PUBLISH_RESUME = 1,

  GNUNET_FS_STATUS_PUBLISH_SUSPEND = 2,

  GNUNET_FS_STATUS_PUBLISH_PROGRESS = 3,

  GNUNET_FS_STATUS_PUBLISH_ERROR = 4,

  GNUNET_FS_STATUS_PUBLISH_COMPLETED = 5,

  GNUNET_FS_STATUS_PUBLISH_STOPPED = 6,

  GNUNET_FS_STATUS_DOWNLOAD_START = 7,

  GNUNET_FS_STATUS_DOWNLOAD_RESUME = 8,

  GNUNET_FS_STATUS_DOWNLOAD_SUSPEND = 9,

  GNUNET_FS_STATUS_DOWNLOAD_PROGRESS = 10,

  GNUNET_FS_STATUS_DOWNLOAD_ERROR = 11,

  GNUNET_FS_STATUS_DOWNLOAD_COMPLETED = 12,

  GNUNET_FS_STATUS_DOWNLOAD_STOPPED = 13,

  GNUNET_FS_STATUS_DOWNLOAD_ACTIVE = 14,

  GNUNET_FS_STATUS_DOWNLOAD_INACTIVE = 15,

  GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT = 16,

  GNUNET_FS_STATUS_SEARCH_START = 17,

  GNUNET_FS_STATUS_SEARCH_RESUME = 18,

  GNUNET_FS_STATUS_SEARCH_RESUME_RESULT = 19,

  GNUNET_FS_STATUS_SEARCH_SUSPEND = 20,

  GNUNET_FS_STATUS_SEARCH_RESULT = 21,

  GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE = 22,

  GNUNET_FS_STATUS_SEARCH_UPDATE = 23,

  GNUNET_FS_STATUS_SEARCH_ERROR = 24,

  GNUNET_FS_STATUS_SEARCH_PAUSED = 25,

  GNUNET_FS_STATUS_SEARCH_CONTINUED = 26,

  GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED = 27,

  GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND = 28,

  GNUNET_FS_STATUS_SEARCH_STOPPED = 29,

  GNUNET_FS_STATUS_UNINDEX_START = 30,

  GNUNET_FS_STATUS_UNINDEX_RESUME = 31,

  GNUNET_FS_STATUS_UNINDEX_SUSPEND = 32,

  GNUNET_FS_STATUS_UNINDEX_PROGRESS = 33,

  GNUNET_FS_STATUS_UNINDEX_ERROR = 34,

  GNUNET_FS_STATUS_UNINDEX_COMPLETED = 35,

  GNUNET_FS_STATUS_UNINDEX_STOPPED = 36,

  GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY = 37

};

GNUNET_FS_Flags

enum GNUNET_FS_Flags

General (global) option flags for file-sharing.

Enumerator
GNUNET_FS_FLAGS_NONE	No special flags set.
GNUNET_FS_FLAGS_PERSISTENCE	Is persistence of operations desired? (will create SUSPEND/RESUME events).
GNUNET_FS_FLAGS_DO_PROBES	Should we automatically trigger probes for search results to determine availability? (will create GNUNET_FS_STATUS_SEARCH_UPDATE events).

Definition at line 1615 of file gnunet_fs_service.h.

{
  GNUNET_FS_FLAGS_NONE = 0,

  GNUNET_FS_FLAGS_PERSISTENCE = 1,

  GNUNET_FS_FLAGS_DO_PROBES = 2
};

GNUNET_FS_OPTIONS

enum GNUNET_FS_OPTIONS

Options specified in the VARARGs portion of GNUNET_FS_start.

Enumerator
GNUNET_FS_OPTIONS_END	Last option in the VARARG list.
GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM	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_REQUEST_PARALLELISM	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.

Definition at line 1640 of file gnunet_fs_service.h.

{

  GNUNET_FS_OPTIONS_END = 0,

  GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM = 1,

  GNUNET_FS_OPTIONS_REQUEST_PARALLELISM = 2
};

GNUNET_FS_PublishOptions

enum GNUNET_FS_PublishOptions

Options for publishing.

Compatible options can be OR'ed together.

Enumerator
GNUNET_FS_PUBLISH_OPTION_NONE	No options (use defaults for everything).
GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY	Simulate publishing. With this option, no data will be stored in the datastore. Useful for computing URIs from files.

Definition at line 2013 of file gnunet_fs_service.h.

{
  GNUNET_FS_PUBLISH_OPTION_NONE = 0,

  GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY = 1
};

GNUNET_FS_SearchOptions

enum GNUNET_FS_SearchOptions

Options for searching.

Compatible options can be OR'ed together.

Enumerator
GNUNET_FS_SEARCH_OPTION_NONE	No options (use defaults for everything).
GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY	Only search the local host, do not search remote systems (no P2P)

Definition at line 2271 of file gnunet_fs_service.h.

{
  GNUNET_FS_SEARCH_OPTION_NONE = 0,

  GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY = 1
};

GNUNET_FS_DownloadOptions

enum GNUNET_FS_DownloadOptions

Options for downloading.

Compatible options can be OR'ed together.

Enumerator
GNUNET_FS_DOWNLOAD_OPTION_NONE	No options (use defaults for everything).
GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY	Only download from the local host, do not access remote systems (no P2P)
GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE	Do a recursive download (that is, automatically trigger the download of files in directories).
GNUNET_FS_DOWNLOAD_NO_TEMPORARIES	Do not append temporary data to the target file (for the IBlocks).
GNUNET_FS_DOWNLOAD_IS_PROBE	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!

Definition at line 2362 of file gnunet_fs_service.h.

{
  GNUNET_FS_DOWNLOAD_OPTION_NONE = 0,

  GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY = 1,

  GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE = 2,

  GNUNET_FS_DOWNLOAD_NO_TEMPORARIES = 4,

  GNUNET_FS_DOWNLOAD_IS_PROBE = (1 << 31)
};

GNUNET_FS_DirScannerProgressUpdateReason

enum GNUNET_FS_DirScannerProgressUpdateReason

Progress reasons of the directory scanner.

Enumerator
GNUNET_FS_DIRSCANNER_FILE_START	We've started processing a file or directory.
GNUNET_FS_DIRSCANNER_FILE_IGNORED	We're having trouble accessing a file (soft-error); it will be ignored.
GNUNET_FS_DIRSCANNER_ALL_COUNTED	We've found all files (in the pre-pass).
GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED	We've finished extracting meta data from a file.
GNUNET_FS_DIRSCANNER_FINISHED	Last call to the progress function: we have finished scanning the directory.
GNUNET_FS_DIRSCANNER_INTERNAL_ERROR	There was an internal error. Application should abort the scan.

Definition at line 2654 of file gnunet_fs_service.h.

{

  GNUNET_FS_DIRSCANNER_FILE_START = 0,

  GNUNET_FS_DIRSCANNER_FILE_IGNORED,

  GNUNET_FS_DIRSCANNER_ALL_COUNTED,

  GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED,

  GNUNET_FS_DIRSCANNER_FINISHED,

  GNUNET_FS_DIRSCANNER_INTERNAL_ERROR

};

Function Documentation

GNUNET_FS_uri_to_key()

int GNUNET_FS_uri_to_key	(	const struct GNUNET_FS_Uri *	uri,
		struct GNUNET_HashCode *	key
	)

Get a unique key from a URI.

This is for putting URIs into HashMaps. The key may change between FS implementations.

Parameters

uri	uri to convert to a unique key
key	wherer to store the unique key

Returns

GNUNET_OK on success

This is for putting URIs into HashMaps. The key may change between FS implementations.

Parameters

uri	uri to convert to a unique key
key	where to store the unique key

Returns

GNUNET_OK on success

Definition at line 104 of file fs_uri.c.

References GNUNET_FS_Uri::chk, FileIdentifier::chk, GNUNET_FS_Uri::data, Location::fi, GNUNET_CRYPTO_hash(), GNUNET_FS_URI_CHK, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC, GNUNET_FS_URI_SKS, GNUNET_OK, GNUNET_SYSERR, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::loc, ContentHashKey::query, GNUNET_FS_Uri::sks, and GNUNET_FS_Uri::type.

Referenced by process_ksk_result(), and process_sks_result().

{
  switch (uri->type)
  {
  case GNUNET_FS_URI_CHK:
    *key = uri->data.chk.chk.query;
    return GNUNET_OK;
  case GNUNET_FS_URI_SKS:
    GNUNET_CRYPTO_hash (uri->data.sks.identifier,
                        strlen (uri->data.sks.identifier),
                        key);
    return GNUNET_OK;
  case GNUNET_FS_URI_KSK:
    if (uri->data.ksk.keywordCount > 0)
    {
      GNUNET_CRYPTO_hash (uri->data.ksk.keywords[0],
                          strlen (uri->data.ksk.keywords[0]),
                          key);
      return GNUNET_OK;
    }
    else
    {
      memset (key, 0, sizeof (struct GNUNET_HashCode));
      return GNUNET_SYSERR;
    }
    break;
  case GNUNET_FS_URI_LOC:
    GNUNET_CRYPTO_hash (&uri->data.loc.fi,
                        sizeof (struct FileIdentifier) +
                        sizeof (struct GNUNET_PeerIdentity),
                        key);
    return GNUNET_OK;
  default:
    memset (key, 0, sizeof (struct GNUNET_HashCode));
    return GNUNET_SYSERR;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_to_string()

char* GNUNET_FS_uri_to_string

(

const struct GNUNET_FS_Uri *

uri

)

Convert a URI to a UTF-8 String.

Parameters

uri	uri to convert to a string

Returns

the UTF-8 string

Definition at line 1988 of file fs_uri.c.

References GNUNET_break, GNUNET_FS_URI_CHK, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC, GNUNET_FS_URI_SKS, GNUNET_FS_Uri::type, uri_chk_to_string(), uri_ksk_to_string(), uri_loc_to_string(), and uri_sks_to_string().

Referenced by GNUNET_FS_directory_builder_add(), GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_ublock_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_sync_(), GNUNET_FS_unindex_sync_(), print_entry(), progress_cb(), trigger_recursive_download(), and write_update_information_graph().

{
  if (uri == NULL)
  {
    GNUNET_break (0);
    return NULL;
  }
  switch (uri->type)
  {
  case GNUNET_FS_URI_KSK:
    return uri_ksk_to_string (uri);
  case GNUNET_FS_URI_SKS:
    return uri_sks_to_string (uri);
  case GNUNET_FS_URI_CHK:
    return uri_chk_to_string (uri);
  case GNUNET_FS_URI_LOC:
    return uri_loc_to_string (uri);
  default:
    GNUNET_break (0);
    return NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_to_string_fancy()

char* GNUNET_FS_uri_ksk_to_string_fancy

(

const struct GNUNET_FS_Uri *

uri

)

Convert keyword URI to a human readable format (i.e.

the search query that was used in the first place)

Parameters

uri	ksk uri to convert to a string

Returns

string with the keywords

Definition at line 152 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_FS_URI_KSK, GNUNET_malloc, GNUNET_FS_Uri::ksk, ret, and GNUNET_FS_Uri::type.

{
  size_t n;
  char *ret;
  unsigned int i;
  const char *keyword;
  char **keywords;
  unsigned int keywordCount;

  if ((NULL == uri) || (GNUNET_FS_URI_KSK != uri->type))
  {
    GNUNET_break (0);
    return NULL;
  }
  keywords = uri->data.ksk.keywords;
  keywordCount = uri->data.ksk.keywordCount;
  n = keywordCount + 1;
  for (i = 0; i < keywordCount; i++)
  {
    keyword = keywords[i];
    n += strlen (keyword) - 1;
    if (NULL != strstr (&keyword[1], " "))
      n += 2;
    if (keyword[0] == '+')
      n++;
  }
  ret = GNUNET_malloc (n);
  strcpy (ret, "");
  for (i = 0; i < keywordCount; i++)
  {
    keyword = keywords[i];
    if (NULL != strstr (&keyword[1], " "))
    {
      strcat (ret, "\"");
      if (keyword[0] == '+')
        strcat (ret, keyword);
      else
        strcat (ret, &keyword[1]);
      strcat (ret, "\"");
    }
    else
    {
      if (keyword[0] == '+')
        strcat (ret, keyword);
      else
        strcat (ret, &keyword[1]);
    }
    strcat (ret, " ");
  }
  return ret;
}

GNUNET_FS_uri_ksk_add_keyword()

void GNUNET_FS_uri_ksk_add_keyword	(	struct GNUNET_FS_Uri *	uri,
		const char *	keyword,
		int	is_mandatory
	)

Add the given keyword to the set of keywords represented by the URI.

Does nothing if the keyword is already present.

Parameters

uri	ksk uri to modify
keyword	keyword to add
is_mandatory	is this keyword mandatory?

Definition at line 751 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_array_append, GNUNET_asprintf(), GNUNET_assert, GNUNET_FS_URI_KSK, GNUNET_FS_Uri::ksk, and GNUNET_FS_Uri::type.

Referenced by get_file_information(), and migrate_and_drop_keywords().

{
  unsigned int i;
  const char *old;
  char *n;

  GNUNET_assert (uri->type == GNUNET_FS_URI_KSK);
  for (i = 0; i < uri->data.ksk.keywordCount; i++)
  {
    old = uri->data.ksk.keywords[i];
    if (0 == strcmp (&old[1], keyword))
      return;
  }
  GNUNET_asprintf (&n, is_mandatory ? "+%s" : " %s", keyword);
  GNUNET_array_append (uri->data.ksk.keywords, uri->data.ksk.keywordCount, n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_remove_keyword()

void GNUNET_FS_uri_ksk_remove_keyword	(	struct GNUNET_FS_Uri *	uri,
		const char *	keyword
	)

Remove the given keyword from the set of keywords represented by the URI.

Does nothing if the keyword is not present.

Parameters

uri	ksk uri to modify
keyword	keyword to add

Definition at line 779 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_array_grow, GNUNET_assert, GNUNET_free, GNUNET_FS_URI_KSK, GNUNET_FS_Uri::ksk, and GNUNET_FS_Uri::type.

Referenced by remove_high_frequency_keywords().

{
  unsigned int i;
  char *old;

  GNUNET_assert (uri->type == GNUNET_FS_URI_KSK);
  for (i = 0; i < uri->data.ksk.keywordCount; i++)
  {
    old = uri->data.ksk.keywords[i];
    if (0 == strcmp (&old[1], keyword))
    {
      uri->data.ksk.keywords[i] =
          uri->data.ksk.keywords[uri->data.ksk.keywordCount - 1];
      GNUNET_array_grow (uri->data.ksk.keywords, uri->data.ksk.keywordCount,
                         uri->data.ksk.keywordCount - 1);
      GNUNET_free (old);
      return;
    }
  }
}

Here is the caller graph for this function:

GNUNET_FS_uri_parse()

struct GNUNET_FS_Uri* GNUNET_FS_uri_parse	(	const char *	uri,
		char **	emsg
	)

Convert a UTF-8 String to a URI.

Parameters

uri	string to parse
emsg	where to store the parser error message (if any)

Returns

NULL on error

Definition at line 635 of file fs_uri.c.

References _, GNUNET_break, GNUNET_free, GNUNET_strdup, msg, ret, uri_chk_parse(), uri_ksk_parse(), uri_loc_parse(), and uri_sks_parse().

Referenced by deserialize_download(), deserialize_fi_node(), deserialize_search(), deserialize_search_result(), deserialize_unindex_file(), GNUNET_FS_directory_list_contents(), GNUNET_FS_uri_ksk_create_from_args(), identity_continuation(), process_kblock(), process_kblock_for_unindex(), process_sblock(), read_update_information_graph(), and run().

{
  struct GNUNET_FS_Uri *ret;
  char *msg;

  if (NULL == uri)
  {
    GNUNET_break (0);
    if (NULL != emsg)
      *emsg = GNUNET_strdup (_("invalid argument"));
    return NULL;
  }
  if (NULL == emsg)
    emsg = &msg;
  *emsg = NULL;
  if ((NULL != (ret = uri_chk_parse (uri, emsg))) ||
      (NULL != (ret = uri_ksk_parse (uri, emsg))) ||
      (NULL != (ret = uri_sks_parse (uri, emsg))) ||
      (NULL != (ret = uri_loc_parse (uri, emsg))))
    return ret;
  if (NULL == *emsg)
    *emsg = GNUNET_strdup (_("Unrecognized URI type"));
  if (emsg == &msg)
    GNUNET_free (msg);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_destroy()

void GNUNET_FS_uri_destroy

(

struct GNUNET_FS_Uri *

uri

)

Free URI.

Parameters

uri	uri to free

Definition at line 670 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_array_grow, GNUNET_free, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC, GNUNET_FS_URI_SKS, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::sks, and GNUNET_FS_Uri::type.

Referenced by deserialize_search_result(), do_stop_task(), download_timeout(), free_download_context(), free_result(), free_search_context(), free_update_information_graph(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_list_contents(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_stop(), GNUNET_FS_file_information_destroy(), GNUNET_FS_probe_stop(), GNUNET_FS_publish_ksk_cancel(), GNUNET_FS_publish_sks_cancel(), GNUNET_FS_search_signal_suspend_(), GNUNET_FS_search_stop(), GNUNET_FS_share_tree_free(), GNUNET_FS_tree_encoder_finish(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_stop(), handle_client_loc_sign(), make_file(), process_kblock(), process_kblock_for_unindex(), process_sblock(), publish_inspector(), report_success(), report_uri(), run(), search_result_free(), search_result_suspend(), search_start(), and share_tree_trim().

{
  unsigned int i;

  switch (uri->type)
  {
  case GNUNET_FS_URI_KSK:
    for (i = 0; i < uri->data.ksk.keywordCount; i++)
      GNUNET_free (uri->data.ksk.keywords[i]);
    GNUNET_array_grow (uri->data.ksk.keywords, uri->data.ksk.keywordCount, 0);
    break;
  case GNUNET_FS_URI_SKS:
    GNUNET_free (uri->data.sks.identifier);
    break;
  case GNUNET_FS_URI_LOC:
    break;
  default:
    /* do nothing */
    break;
  }
  GNUNET_free (uri);
}

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_get_keyword_count()

unsigned int GNUNET_FS_uri_ksk_get_keyword_count

(

const struct GNUNET_FS_Uri *

uri

)

How many keywords are ANDed in this keyword URI?

Parameters

uri	ksk uri to get the number of keywords from

Returns

0 if this is not a keyword URI

Definition at line 701 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_FS_URI_KSK, GNUNET_FS_Uri::ksk, and GNUNET_FS_Uri::type.

Referenced by fip_signal_start().

{
  if (uri->type != GNUNET_FS_URI_KSK)
    return 0;
  return uri->data.ksk.keywordCount;
}

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_get_keywords()

int GNUNET_FS_uri_ksk_get_keywords	(	const struct GNUNET_FS_Uri *	uri,
		GNUNET_FS_KeywordIterator	iterator,
		void *	iterator_cls
	)

Iterate over all keywords in this keyword URI.

Parameters

uri	ksk uri to get the keywords from
iterator	function to call on each keyword
iterator_cls	closure for iterator

Returns

-1 if this is not a keyword URI, otherwise number of keywords iterated over until iterator aborted

Parameters

uri	ksk uri to get the keywords from
iterator	function to call on each keyword
iterator_cls	closure for iterator

Returns

-1 if this is not a keyword URI, otherwise number of keywords iterated over until iterator aborted

Definition at line 719 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_FS_URI_KSK, GNUNET_OK, GNUNET_FS_Uri::ksk, and GNUNET_FS_Uri::type.

Referenced by publish_inspector(), and share_tree_trim().

{
  unsigned int i;
  char *keyword;

  if (uri->type != GNUNET_FS_URI_KSK)
    return -1;
  if (NULL == iterator)
    return uri->data.ksk.keywordCount;
  for (i = 0; i < uri->data.ksk.keywordCount; i++)
  {
    keyword = uri->data.ksk.keywords[i];
    /* first character of keyword indicates
     * if it is mandatory or not */
    if (GNUNET_OK != iterator (iterator_cls, &keyword[1], keyword[0] == '+'))
      return i;
  }
  return i;
}

Here is the caller graph for this function:

GNUNET_FS_uri_loc_get_peer_identity()

int GNUNET_FS_uri_loc_get_peer_identity	(	const struct GNUNET_FS_Uri *	uri,
		struct GNUNET_PeerIdentity *	peer
	)

Obtain the identity of the peer offering the data.

Parameters

uri	the location URI to inspect
peer	where to store the identify of the peer (presumably) offering the content

Returns

GNUNET_SYSERR if this is not a location URI, otherwise GNUNET_OK

Definition at line 810 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_FS_URI_LOC, GNUNET_OK, GNUNET_SYSERR, GNUNET_FS_Uri::loc, Location::peer, and GNUNET_FS_Uri::type.

Referenced by create_download_context(), and deserialize_download().

{
  if (uri->type != GNUNET_FS_URI_LOC)
    return GNUNET_SYSERR;
  *peer = uri->data.loc.peer;
  return GNUNET_OK;
}

Here is the caller graph for this function:

GNUNET_FS_uri_loc_get_uri()

struct GNUNET_FS_Uri* GNUNET_FS_uri_loc_get_uri

(

const struct GNUNET_FS_Uri *

uri

)

Obtain the URI of the content itself.

Parameters

uri	location URI to get the content URI from

Returns

NULL if argument is not a location URI

Definition at line 841 of file fs_uri.c.

References GNUNET_FS_Uri::chk, GNUNET_FS_Uri::data, Location::fi, GNUNET_FS_URI_CHK, GNUNET_FS_URI_LOC, GNUNET_new, GNUNET_FS_Uri::loc, ret, and GNUNET_FS_Uri::type.

Referenced by GNUNET_FS_directory_builder_add().

{
  struct GNUNET_FS_Uri *ret;

  if (uri->type != GNUNET_FS_URI_LOC)
    return NULL;
  ret = GNUNET_new (struct GNUNET_FS_Uri);
  ret->type = GNUNET_FS_URI_CHK;
  ret->data.chk = uri->data.loc.fi;
  return ret;
}

Here is the caller graph for this function:

GNUNET_FS_uri_loc_get_expiration()

struct GNUNET_TIME_Absolute GNUNET_FS_uri_loc_get_expiration

(

const struct GNUNET_FS_Uri *

uri

)

Obtain the expiration of the LOC URI.

Parameters

uri	location URI to get the expiration from

Returns

expiration time of the URI

Definition at line 827 of file fs_uri.c.

References GNUNET_FS_Uri::data, Location::expirationTime, GNUNET_assert, GNUNET_FS_URI_LOC, GNUNET_FS_Uri::loc, GNUNET_FS_Uri::type, and uri.

{
  GNUNET_assert (uri->type == GNUNET_FS_URI_LOC);
  return uri->data.loc.expirationTime;
}

GNUNET_FS_uri_loc_create()

struct GNUNET_FS_Uri* GNUNET_FS_uri_loc_create	(	const struct GNUNET_FS_Uri *	base_uri,
		const struct GNUNET_CRYPTO_EddsaPrivateKey *	sign_key,
		struct GNUNET_TIME_Absolute	expiration_time
	)

Construct a location URI (this peer will be used for the location).

This function should only be called from within gnunet-service-fs, as it requires the peer's private key which is generally unavailable to processes directly under the user's control. However, for testing and as it logically fits under URIs, it is in this API.

Parameters

base_uri	content offered by the sender
sign_key	private key of the peer
expiration_time	how long will the content be offered?

Returns

the location URI, NULL on error

Definition at line 867 of file fs_uri.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_FS_Uri::chk, Location::contentSignature, GNUNET_FS_Uri::data, Location::expirationTime, LocUriAssembly::exptime, Location::fi, LocUriAssembly::fi, GNUNET_assert, GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_eddsa_sign(), GNUNET_FS_URI_CHK, GNUNET_FS_URI_LOC, GNUNET_new, GNUNET_OK, GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT, GNUNET_TIME_absolute_hton(), GNUNET_FS_Uri::loc, Location::peer, LocUriAssembly::peer, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, LocUriAssembly::purpose, GNUNET_CRYPTO_EccSignaturePurpose::size, GNUNET_FS_Uri::type, and uri.

Referenced by handle_client_loc_sign().

{
  struct GNUNET_FS_Uri *uri;
  struct GNUNET_CRYPTO_EddsaPublicKey my_public_key;
  struct LocUriAssembly ass;
  struct GNUNET_TIME_Absolute et;

  if (GNUNET_FS_URI_CHK != base_uri->type)
    return NULL;
  /* we round expiration time to full seconds for SKS URIs */
  et.abs_value_us = (expiration_time.abs_value_us / 1000000LL) * 1000000LL;
  GNUNET_CRYPTO_eddsa_key_get_public (sign_key,
                                      &my_public_key);
  ass.purpose.size = htonl (sizeof (struct LocUriAssembly));
  ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
  ass.exptime = GNUNET_TIME_absolute_hton (et);
  ass.fi = base_uri->data.chk;
  ass.peer.public_key = my_public_key;
  uri = GNUNET_new (struct GNUNET_FS_Uri);
  uri->type = GNUNET_FS_URI_LOC;
  uri->data.loc.fi = base_uri->data.chk;
  uri->data.loc.expirationTime = et;
  uri->data.loc.peer.public_key = my_public_key;
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CRYPTO_eddsa_sign (sign_key,
                                           &ass.purpose,
                                           &uri->data.loc.contentSignature));
  return uri;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_merge()

struct GNUNET_FS_Uri* GNUNET_FS_uri_ksk_merge	(	const struct GNUNET_FS_Uri *	u1,
		const struct GNUNET_FS_Uri *	u2
	)

Merge the sets of keywords from two KSK URIs.

Parameters

u1	first uri
u2	second uri

Returns

merged URI, NULL on error

(useful for merging the canonicalized keywords with the original keywords for sharing).

Parameters

u1	first uri
u2	second uri

Returns

merged URI, NULL on error

Definition at line 931 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_FS_uri_dup(), GNUNET_FS_URI_KSK, GNUNET_new, GNUNET_new_array, GNUNET_strdup, GNUNET_FS_Uri::ksk, ret, and GNUNET_FS_Uri::type.

Referenced by publish_inspector().

{
  struct GNUNET_FS_Uri *ret;
  unsigned int kc;
  unsigned int i;
  unsigned int j;
  int found;
  const char *kp;
  char **kl;

  if ((u1 == NULL) && (u2 == NULL))
    return NULL;
  if (u1 == NULL)
    return GNUNET_FS_uri_dup (u2);
  if (u2 == NULL)
    return GNUNET_FS_uri_dup (u1);
  if ((u1->type != GNUNET_FS_URI_KSK) || (u2->type != GNUNET_FS_URI_KSK))
  {
    GNUNET_break (0);
    return NULL;
  }
  kc = u1->data.ksk.keywordCount;
  kl = GNUNET_new_array (kc + u2->data.ksk.keywordCount,
                         char *);
  for (i = 0; i < u1->data.ksk.keywordCount; i++)
    kl[i] = GNUNET_strdup (u1->data.ksk.keywords[i]);
  for (i = 0; i < u2->data.ksk.keywordCount; i++)
  {
    kp = u2->data.ksk.keywords[i];
    found = 0;
    for (j = 0; j < u1->data.ksk.keywordCount; j++)
      if (0 == strcmp (kp + 1, kl[j] + 1))
      {
        found = 1;
        if (kp[0] == '+')
          kl[j][0] = '+';
        break;
      }
    if (0 == found)
      kl[kc++] = GNUNET_strdup (kp);
  }
  ret = GNUNET_new (struct GNUNET_FS_Uri);
  ret->type = GNUNET_FS_URI_KSK;
  ret->data.ksk.keywordCount = kc;
  ret->data.ksk.keywords = kl;
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_dup()

struct GNUNET_FS_Uri* GNUNET_FS_uri_dup

(

const struct GNUNET_FS_Uri *

uri

)

Duplicate URI.

Parameters

uri	the URI to duplicate

Returns

copy of the URI

Definition at line 988 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_free, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC, GNUNET_FS_URI_SKS, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, GNUNET_new, GNUNET_new_array, GNUNET_strdup, GNUNET_FS_Uri::ksk, ret, GNUNET_FS_Uri::sks, and GNUNET_FS_Uri::type.

Referenced by create_download_context(), GNUNET_FS_file_information_create_empty_directory(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_probe(), GNUNET_FS_publish_ksk(), GNUNET_FS_publish_sks(), GNUNET_FS_TEST_download(), GNUNET_FS_tree_encoder_get_uri(), GNUNET_FS_uri_ksk_merge(), process_ksk_result(), process_sks_result(), publish_progress_cb(), publish_sblocks_cont(), search_start(), share_tree_trim(), and unindex_directory_scan_cb().

{
  struct GNUNET_FS_Uri *ret;
  unsigned int i;

  if (uri == NULL)
    return NULL;
  ret = GNUNET_new (struct GNUNET_FS_Uri);
  GNUNET_memcpy (ret, uri, sizeof (struct GNUNET_FS_Uri));
  switch (ret->type)
  {
  case GNUNET_FS_URI_KSK:
    if (ret->data.ksk.keywordCount >=
        GNUNET_MAX_MALLOC_CHECKED / sizeof (char *))
    {
      GNUNET_break (0);
      GNUNET_free (ret);
      return NULL;
    }
    if (ret->data.ksk.keywordCount > 0)
    {
      ret->data.ksk.keywords
        = GNUNET_new_array (ret->data.ksk.keywordCount,
                            char *);
      for (i = 0; i < ret->data.ksk.keywordCount; i++)
        ret->data.ksk.keywords[i] = GNUNET_strdup (uri->data.ksk.keywords[i]);
    }
    else
      ret->data.ksk.keywords = NULL;    /* just to be sure */
    break;
  case GNUNET_FS_URI_SKS:
    ret->data.sks.identifier = GNUNET_strdup (uri->data.sks.identifier);
    break;
  case GNUNET_FS_URI_LOC:
    break;
  default:
    break;
  }
  return ret;
}

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_create()

struct GNUNET_FS_Uri* GNUNET_FS_uri_ksk_create	(	const char *	keywords,
		char **	emsg
	)

Create an FS URI from a single user-supplied string of keywords.

The string is broken up at spaces into individual keywords. Keywords that start with "+" are mandatory. Double-quotes can be used to prevent breaking up strings at spaces (and also to specify non-mandatory keywords starting with "+").

Keywords must contain a balanced number of double quotes and double quotes can not be used in the actual keywords (for example, the string '""foo bar""' will be turned into two "OR"ed keywords 'foo' and 'bar', not into '"foo bar"'.

Parameters

keywords	the keyword string
emsg	where to store an error message

Returns

an FS URI for the given keywords, NULL if keywords is not legal (i.e. empty).

Definition at line 1048 of file fs_uri.c.

References _, GNUNET_break, GNUNET_free, GNUNET_FS_uri_ksk_create_from_args(), GNUNET_new_array, GNUNET_strdup, and uri.

Referenced by make_keywords().

{
  char **keywordarr;
  unsigned int num_Words;
  int inWord;
  char *pos;
  struct GNUNET_FS_Uri *uri;
  char *searchString;
  int saw_quote;

  if (keywords == NULL)
  {
    *emsg = GNUNET_strdup (_("No keywords specified!\n"));
    GNUNET_break (0);
    return NULL;
  }
  searchString = GNUNET_strdup (keywords);
  num_Words = 0;
  inWord = 0;
  saw_quote = 0;
  pos = searchString;
  while ('\0' != *pos)
  {
    if ((saw_quote == 0) && (isspace ((unsigned char) *pos)))
    {
      inWord = 0;
    }
    else if (0 == inWord)
    {
      inWord = 1;
      ++num_Words;
    }
    if ('"' == *pos)
      saw_quote = (saw_quote + 1) % 2;
    pos++;
  }
  if (num_Words == 0)
  {
    GNUNET_free (searchString);
    *emsg = GNUNET_strdup (_("No keywords specified!\n"));
    return NULL;
  }
  if (saw_quote != 0)
  {
    GNUNET_free (searchString);
    *emsg = GNUNET_strdup (_("Number of double-quotes not balanced!\n"));
    return NULL;
  }
  keywordarr = GNUNET_new_array (num_Words,
                                 char *);
  num_Words = 0;
  inWord = 0;
  pos = searchString;
  while ('\0' != *pos)
  {
    if ((saw_quote == 0) && (isspace ((unsigned char) *pos)))
    {
      inWord = 0;
      *pos = '\0';
    }
    else if (0 == inWord)
    {
      keywordarr[num_Words] = pos;
      inWord = 1;
      ++num_Words;
    }
    if ('"' == *pos)
      saw_quote = (saw_quote + 1) % 2;
    pos++;
  }
  uri =
      GNUNET_FS_uri_ksk_create_from_args (num_Words,
                                          (const char **) keywordarr);
  GNUNET_free (keywordarr);
  GNUNET_free (searchString);
  return uri;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_create_from_args()

struct GNUNET_FS_Uri* GNUNET_FS_uri_ksk_create_from_args	(	unsigned int	argc,
		const char **	argv
	)

Create an FS URI from a user-supplied command line of keywords.

Arguments should start with "+" to indicate mandatory keywords.

Parameters

argc	number of keywords
argv	keywords (double quotes are not required for keywords containing spaces; however, double quotes are required for keywords starting with "+"); there is no mechanism for having double quotes in the actual keywords (if the user did specifically specify double quotes, the caller should convert each double quote into two single quotes).

Returns

an FS URI for the given keywords, NULL if keywords is not legal (i.e. empty).

Definition at line 1146 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_asprintf(), GNUNET_free_non_null, GNUNET_FS_URI_KSK, GNUNET_FS_uri_parse(), GNUNET_FS_URI_PREFIX, GNUNET_new, GNUNET_new_array, GNUNET_strdup, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::type, and uri.

Referenced by get_file_information(), GNUNET_FS_uri_ksk_create(), migrate_and_drop_keywords(), and run().

{
  unsigned int i;
  struct GNUNET_FS_Uri *uri;
  const char *keyword;
  char *val;
  const char *r;
  char *w;
  char *emsg;

  if (argc == 0)
    return NULL;
  /* allow URI to be given as one and only keyword and
   * handle accordingly */
  emsg = NULL;
  if ((argc == 1) && (strlen (argv[0]) > strlen (GNUNET_FS_URI_PREFIX)) &&
      (0 ==
       strncmp (argv[0], GNUNET_FS_URI_PREFIX, strlen (GNUNET_FS_URI_PREFIX)))
      && (NULL != (uri = GNUNET_FS_uri_parse (argv[0], &emsg))))
    return uri;
  GNUNET_free_non_null (emsg);
  uri = GNUNET_new (struct GNUNET_FS_Uri);
  uri->type = GNUNET_FS_URI_KSK;
  uri->data.ksk.keywordCount = argc;
  uri->data.ksk.keywords = GNUNET_new_array (argc,
                                             char *);
  for (i = 0; i < argc; i++)
  {
    keyword = argv[i];
    if (keyword[0] == '+')
      val = GNUNET_strdup (keyword);
    else
      GNUNET_asprintf (&val, " %s", keyword);
    r = val;
    w = val;
    while ('\0' != *r)
    {
      if ('"' == *r)
        r++;
      else
        *(w++) = *(r++);
    }
    *w = '\0';
    uri->data.ksk.keywords[i] = val;
  }
  return uri;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_test_equal()

int GNUNET_FS_uri_test_equal	(	const struct GNUNET_FS_Uri *	u1,
		const struct GNUNET_FS_Uri *	u2
	)

Test if two URIs are equal.

Parameters

u1	one of the URIs
u2	the other URI

Returns

GNUNET_YES if the URIs are equal

Definition at line 1204 of file fs_uri.c.

References GNUNET_FS_Uri::chk, GNUNET_FS_Uri::data, GNUNET_assert, GNUNET_FS_URI_CHK, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC, GNUNET_FS_URI_SKS, GNUNET_NO, GNUNET_YES, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::loc, ret, GNUNET_FS_Uri::sks, and GNUNET_FS_Uri::type.

Referenced by get_result_present(), test_result_present(), and trigger_recursive_download().

{
  int ret;
  unsigned int i;
  unsigned int j;

  GNUNET_assert (u1 != NULL);
  GNUNET_assert (u2 != NULL);
  if (u1->type != u2->type)
    return GNUNET_NO;
  switch (u1->type)
  {
  case GNUNET_FS_URI_CHK:
    if (0 ==
        memcmp (&u1->data.chk, &u2->data.chk, sizeof (struct FileIdentifier)))
      return GNUNET_YES;
    return GNUNET_NO;
  case GNUNET_FS_URI_SKS:
    if ((0 ==
         memcmp (&u1->data.sks.ns, &u2->data.sks.ns,
                 sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))) &&
        (0 == strcmp (u1->data.sks.identifier, u2->data.sks.identifier)))

      return GNUNET_YES;
    return GNUNET_NO;
  case GNUNET_FS_URI_KSK:
    if (u1->data.ksk.keywordCount != u2->data.ksk.keywordCount)
      return GNUNET_NO;
    for (i = 0; i < u1->data.ksk.keywordCount; i++)
    {
      ret = GNUNET_NO;
      for (j = 0; j < u2->data.ksk.keywordCount; j++)
      {
        if (0 == strcmp (u1->data.ksk.keywords[i], u2->data.ksk.keywords[j]))
        {
          ret = GNUNET_YES;
          break;
        }
      }
      if (ret == GNUNET_NO)
        return GNUNET_NO;
    }
    return GNUNET_YES;
  case GNUNET_FS_URI_LOC:
    if (memcmp
        (&u1->data.loc, &u2->data.loc,
         sizeof (struct FileIdentifier) +
         sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey) +
         sizeof (struct GNUNET_TIME_Absolute) + sizeof (unsigned short) +
         sizeof (unsigned short)) != 0)
      return GNUNET_NO;
    return GNUNET_YES;
  default:
    return GNUNET_NO;
  }
}

Here is the caller graph for this function:

GNUNET_FS_uri_test_sks()

int GNUNET_FS_uri_test_sks

(

const struct GNUNET_FS_Uri *

uri

)

Is this a namespace URI?

Parameters

uri	the uri to check

Returns

GNUNET_YES if this is an SKS uri

Definition at line 1270 of file fs_uri.c.

References GNUNET_FS_URI_SKS, and GNUNET_FS_Uri::type.

Referenced by deserialize_fi_node(), deserialize_search(), GNUNET_FS_directory_builder_add(), GNUNET_FS_search_sync_(), GNUNET_FS_uri_sks_get_content_id(), GNUNET_FS_uri_sks_get_namespace(), and schedule_transmit_search_request().

{
  return uri->type == GNUNET_FS_URI_SKS;
}

Here is the caller graph for this function:

GNUNET_FS_uri_sks_create()

struct GNUNET_FS_Uri* GNUNET_FS_uri_sks_create	(	const struct GNUNET_CRYPTO_EcdsaPublicKey *	ns,
		const char *	id
	)

Create an SKS URI from a namespace ID and an identifier.

Parameters

ns	pseudonym to use
id	identifier

Returns

an FS URI for the given namespace and identifier

Parameters

ns	namespace ID
id	identifier

Returns

an FS URI for the given namespace and identifier

Definition at line 908 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_FS_URI_SKS, GNUNET_new, GNUNET_strdup, ns, GNUNET_FS_Uri::sks, and GNUNET_FS_Uri::type.

{
  struct GNUNET_FS_Uri *ns_uri;

  ns_uri = GNUNET_new (struct GNUNET_FS_Uri);
  ns_uri->type = GNUNET_FS_URI_SKS;
  ns_uri->data.sks.ns = *ns;
  ns_uri->data.sks.identifier = GNUNET_strdup (id);
  return ns_uri;
}

GNUNET_FS_uri_sks_get_namespace()

int GNUNET_FS_uri_sks_get_namespace	(	const struct GNUNET_FS_Uri *	uri,
		struct GNUNET_CRYPTO_EcdsaPublicKey *	pseudonym
	)

Get the public key of a namespace from the given namespace URI.

Parameters

uri	the uri to get the namespace ID from
pseudonym	where to store the public key of the namespace

Returns

GNUNET_OK on success

Get the public key of a namespace from the given namespace URI.

Parameters

uri	the uri to get the namespace ID from
pseudonym	where to store the ID of the namespace

Returns

GNUNET_OK on success

Definition at line 1285 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_FS_uri_test_sks(), GNUNET_OK, GNUNET_SYSERR, and GNUNET_FS_Uri::sks.

{
  if (!GNUNET_FS_uri_test_sks (uri))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  *pseudonym = uri->data.sks.ns;
  return GNUNET_OK;
}

Here is the call graph for this function:

GNUNET_FS_uri_sks_get_content_id()

char* GNUNET_FS_uri_sks_get_content_id

(

const struct GNUNET_FS_Uri *

uri

)

Get the content identifier of an SKS URI.

Parameters

uri	the sks uri

Returns

NULL on error (not a valid SKS URI)

Definition at line 1305 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_FS_uri_test_sks(), GNUNET_strdup, and GNUNET_FS_Uri::sks.

{
  if (!GNUNET_FS_uri_test_sks (uri))
  {
    GNUNET_break (0);
    return NULL;
  }
  return GNUNET_strdup (uri->data.sks.identifier);
}

Here is the call graph for this function:

GNUNET_FS_uri_test_ksk()

int GNUNET_FS_uri_test_ksk

(

const struct GNUNET_FS_Uri *

uri

)

Is this a keyword URI?

Parameters

uri

the uri

Returns

GNUNET_YES if this is a KSK uri

Definition at line 1323 of file fs_uri.c.

References GNUNET_FS_Uri::data, GNUNET_assert, GNUNET_FS_URI_KSK, GNUNET_FS_Uri::ksk, and GNUNET_FS_Uri::type.

Referenced by deserialize_fi_node(), deserialize_search(), GNUNET_FS_directory_builder_add(), GNUNET_FS_directory_list_contents(), GNUNET_FS_search_signal_suspend_(), GNUNET_FS_search_start_searching_(), GNUNET_FS_search_stop(), GNUNET_FS_search_sync_(), and schedule_transmit_search_request().

{
#if EXTRA_CHECKS
  unsigned int i;

  if (uri->type == GNUNET_FS_URI_KSK)
  {
    for (i=0;i < uri->data.ksk.keywordCount; i++)
      GNUNET_assert (uri->data.ksk.keywords[i] != NULL);
  }
#endif
  return uri->type == GNUNET_FS_URI_KSK;
}

Here is the caller graph for this function:

GNUNET_FS_uri_test_chk()

int GNUNET_FS_uri_test_chk

(

const struct GNUNET_FS_Uri *

uri

)

Is this a file (or directory) URI?

Parameters

uri	the uri to check

Returns

GNUNET_YES if this is a CHK uri

Definition at line 1345 of file fs_uri.c.

References GNUNET_FS_URI_CHK, and GNUNET_FS_Uri::type.

Referenced by create_download_context(), deserialize_download(), deserialize_fi_node(), GNUNET_FS_directory_builder_add(), GNUNET_FS_download_sync_(), progress_cb(), and run().

{
  return uri->type == GNUNET_FS_URI_CHK;
}

Here is the caller graph for this function:

GNUNET_FS_uri_chk_get_file_size()

uint64_t GNUNET_FS_uri_chk_get_file_size

(

const struct GNUNET_FS_Uri *

uri

)

What is the size of the file that this URI refers to?

Parameters

uri	the CHK (or LOC) URI to inspect

Returns

size of the file as specified in the CHK URI

Parameters

uri	the CHK URI to inspect

Returns

size of the file as specified in the CHK URI

Definition at line 1359 of file fs_uri.c.

References GNUNET_FS_Uri::chk, GNUNET_FS_Uri::data, Location::fi, FileIdentifier::file_length, GNUNET_assert, GNUNET_FS_URI_CHK, GNUNET_FS_URI_LOC, GNUNET_ntohll(), GNUNET_FS_Uri::loc, and GNUNET_FS_Uri::type.

Referenced by create_download_context(), deserialize_download(), encode_cont(), full_recursive_download(), GNUNET_FS_directory_builder_add(), GNUNET_FS_download_start_task_(), GNUNET_FS_search_start_probe_(), GNUNET_FS_TEST_download(), match_full_data(), progress_cb(), run(), trigger_recursive_download(), and try_top_down_reconstruction().

{
  switch (uri->type)
  {
  case GNUNET_FS_URI_CHK:
    return GNUNET_ntohll (uri->data.chk.file_length);
  case GNUNET_FS_URI_LOC:
    return GNUNET_ntohll (uri->data.loc.fi.file_length);
  default:
    GNUNET_assert (0);
  }
  return 0;                     /* unreachable */
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_test_loc()

int GNUNET_FS_uri_test_loc

(

const struct GNUNET_FS_Uri *

uri

)

Is this a location URI?

Parameters

uri	the uri to check

Returns

GNUNET_YES if this is a LOC uri

Definition at line 1381 of file fs_uri.c.

References GNUNET_FS_URI_LOC, and GNUNET_FS_Uri::type.

Referenced by create_download_context(), deserialize_download(), GNUNET_FS_download_sync_(), GNUNET_FS_publish_main_(), and run().

{
  return uri->type == GNUNET_FS_URI_LOC;
}

Here is the caller graph for this function:

GNUNET_FS_uri_ksk_create_from_meta_data()

struct GNUNET_FS_Uri* GNUNET_FS_uri_ksk_create_from_meta_data

(

const struct GNUNET_CONTAINER_MetaData *

md

)

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).

Parameters

md	metadata to use

Returns

NULL on error, otherwise a KSK URI

Definition at line 1758 of file fs_uri.c.

References GNUNET_FS_Uri::data, DIR_SEPARATOR_STR, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, filename, gather_uri_data(), get_keywords_from_parens(), get_keywords_from_tokens(), GNUNET_CONTAINER_meta_data_get_first_by_types(), GNUNET_CONTAINER_meta_data_iterate(), GNUNET_free_non_null, GNUNET_FS_URI_KSK, GNUNET_new, GNUNET_new_array, GNUNET_FS_Uri::ksk, ret, and GNUNET_FS_Uri::type.

Referenced by process_helper_msgs().

{
  struct GNUNET_FS_Uri *ret;
  char *filename;
  char *full_name = NULL;
  char *ss;
  int ent;
  int tok_keywords = 0;
  int paren_keywords = 0;

  if (NULL == md)
    return NULL;
  ret = GNUNET_new (struct GNUNET_FS_Uri);
  ret->type = GNUNET_FS_URI_KSK;
  ent = GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL);
  if (ent > 0)
  {
    full_name = GNUNET_CONTAINER_meta_data_get_first_by_types (md,
        EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, -1);
    if (NULL != full_name)
    {
      filename = full_name;
      while (NULL != (ss = strstr (filename, DIR_SEPARATOR_STR)))
        filename = ss + 1;
      tok_keywords = get_keywords_from_tokens (filename, NULL, 0);
      paren_keywords = get_keywords_from_parens (filename, NULL, 0);
    }
    /* x3 because there might be a normalized variant of every keyword,
       plus theoretically one more for mime... */
    ret->data.ksk.keywords
      = GNUNET_new_array ((ent + tok_keywords + paren_keywords) * 3,
                          char *);
    GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
  }
  if (tok_keywords > 0)
    ret->data.ksk.keywordCount += get_keywords_from_tokens (filename,
                                                            ret->data.ksk.keywords,
                                                            ret->data.ksk.keywordCount);
  if (paren_keywords > 0)
    ret->data.ksk.keywordCount += get_keywords_from_parens (filename,
                                                            ret->data.ksk.keywords,
                                                            ret->data.ksk.keywordCount);
  if (ent > 0)
    GNUNET_free_non_null (full_name);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_GETOPT_KEYWORDS()

struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_KEYWORDS	(	char	shortName,
		const char *	name,
		const char *	argumentHelp,
		const char *	description,
		struct GNUNET_FS_Uri **	topKeywords
	)

Allow user to specify keywords.

Parameters

	shortName	short name of the option
	name	long name of the option
	argumentHelp	help text for the option argument
	description	long help text for the option
[out]	topKeywords	set to the desired value

Definition at line 129 of file fs_getopt.c.

References GNUNET_GETOPT_CommandLineOption::argumentHelp, GNUNET_GETOPT_CommandLineOption::description, getopt_set_keywords(), name, GNUNET_GETOPT_CommandLineOption::shortName, and topKeywords.

Referenced by main().

{
  struct GNUNET_GETOPT_CommandLineOption clo = {
    .shortName = shortName,
    .name = name,
    .argumentHelp = argumentHelp,
    .description = description,
    .require_argument = 1,
    .processor = &getopt_set_keywords,
    .scls = (void *) topKeywords  
  };

  return clo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_GETOPT_METADATA()

struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_METADATA	(	char	shortName,
		const char *	name,
		const char *	argumentHelp,
		const char *	description,
		struct GNUNET_CONTAINER_MetaData **	meta
	)

Allow user to specify metadata.

Parameters

	shortName	short name of the option
	name	long name of the option
	argumentHelp	help text for the option argument
	description	long help text for the option
[out]	metadata	set to the desired value

Definition at line 251 of file fs_getopt.c.

References GNUNET_GETOPT_CommandLineOption::argumentHelp, GNUNET_GETOPT_CommandLineOption::description, getopt_set_metadata(), meta, name, and GNUNET_GETOPT_CommandLineOption::shortName.

Referenced by main().

{
  struct GNUNET_GETOPT_CommandLineOption clo = {
    .shortName = shortName,
    .name = name,
    .argumentHelp = argumentHelp,
    .description = description,
    .require_argument = 1,
    .processor = &getopt_set_metadata,
    .scls = (void *) meta
  };

  return clo;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_getopt_set_metadata()

int GNUNET_FS_getopt_set_metadata	(	struct GNUNET_GETOPT_CommandLineProcessorContext *	ctx,
		void *	scls,
		const char *	option,
		const char *	value
	)

Command-line option parser function that allows the user to specify one or more '-m' options with metadata.

Each specified entry of the form "type=value" will be added to the metadata. A pointer to the metadata must be passed as the "scls" argument.

Parameters

ctx	command line processor context
scls	must be of type struct GNUNET_CONTAINER_MetaData **
option	name of the option (typically 'k')
value	command line argument given

Returns

GNUNET_OK on success

GNUNET_FS_start()

struct GNUNET_FS_Handle* GNUNET_FS_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const char *	client_name,
		GNUNET_FS_ProgressCallback	upcb,
		void *	upcb_cls,
		enum GNUNET_FS_Flags	flags,
			...
	)

Setup a connection to the file-sharing service.

Parameters

cfg	configuration to use
client_name	unique identifier for this client
upcb	function to call to notify about FS actions
upcb_cls	closure for upcb
flags	specific attributes for fs-operations
...	list of optional options, terminated with GNUNET_FS_OPTIONS_END

Returns

NULL on error

Definition at line 3097 of file fs_api.c.

References GNUNET_FS_Handle::avg_block_latency, cfg, GNUNET_FS_Handle::cfg, GNUNET_FS_Handle::client_name, DEFAULT_MAX_PARALLEL_DOWNLOADS, DEFAULT_MAX_PARALLEL_REQUESTS, deserialization_master(), deserialize_download_file(), deserialize_publish_file(), deserialize_search_file(), deserialize_unindex_file(), GNUNET_FS_Handle::flags, GNUNET_break, GNUNET_free, GNUNET_FS_FLAGS_PERSISTENCE, GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM, GNUNET_FS_OPTIONS_END, GNUNET_FS_OPTIONS_REQUEST_PARALLELISM, GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH, GNUNET_FS_SYNC_PATH_MASTER_SEARCH, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX, GNUNET_new, GNUNET_strdup, GNUNET_TIME_UNIT_MINUTES, GNUNET_VA_ARG_ENUM, GNUNET_FS_Handle::max_parallel_downloads, GNUNET_FS_Handle::max_parallel_requests, ret, GNUNET_FS_Handle::upcb, and GNUNET_FS_Handle::upcb_cls.

Referenced by download_connect_adapter(), publish_connect_adapter(), and run().

{
  struct GNUNET_FS_Handle *ret;
  enum GNUNET_FS_OPTIONS opt;
  va_list ap;

  ret = GNUNET_new (struct GNUNET_FS_Handle);
  ret->cfg = cfg;
  ret->client_name = GNUNET_strdup (client_name);
  ret->upcb = upcb;
  ret->upcb_cls = upcb_cls;
  ret->flags = flags;
  ret->max_parallel_downloads = DEFAULT_MAX_PARALLEL_DOWNLOADS;
  ret->max_parallel_requests = DEFAULT_MAX_PARALLEL_REQUESTS;
  ret->avg_block_latency = GNUNET_TIME_UNIT_MINUTES;    /* conservative starting point */
  va_start (ap, flags);
  while (GNUNET_FS_OPTIONS_END != (opt = GNUNET_VA_ARG_ENUM (ap,GNUNET_FS_OPTIONS)))
  {
    switch (opt)
    {
    case GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM:
      ret->max_parallel_downloads = va_arg (ap, unsigned int);

      break;
    case GNUNET_FS_OPTIONS_REQUEST_PARALLELISM:
      ret->max_parallel_requests = va_arg (ap, unsigned int);

      break;
    default:
      GNUNET_break (0);
      GNUNET_free (ret->client_name);
      GNUNET_free (ret);
      va_end (ap);
      return NULL;
    }
  }
  va_end (ap);
  if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & flags))
  {
    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
                            &deserialize_publish_file, ret);
    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
                            &deserialize_search_file, ret);
    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
                            &deserialize_download_file, ret);
    deserialization_master (GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
                            &deserialize_unindex_file, ret);
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_stop()

void GNUNET_FS_stop

(

struct GNUNET_FS_Handle *

h

)

Close our connection with the file-sharing service.

The callback given to GNUNET_FS_start() will no longer be called after this function returns. This function MUST NOT be called from within the callback itself.

Parameters

h	handle that was returned from GNUNET_FS_start()

Definition at line 3163 of file fs_api.c.

References GNUNET_FS_Handle::client_name, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_FS_Handle::queue_job, TopLevelActivity::ssf, TopLevelActivity::ssf_cls, and GNUNET_FS_Handle::top_head.

Referenced by clean_task(), cleanup_task(), do_stop_task(), fs_disconnect_adapter(), print_indexed(), run(), and shutdown_task().

{
  while (NULL != h->top_head)
    h->top_head->ssf (h->top_head->ssf_cls);
  if (NULL != h->queue_job)
    GNUNET_SCHEDULER_cancel (h->queue_job);
  GNUNET_free (h->client_name);
  GNUNET_free (h);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_file_information_get_id()

const char* GNUNET_FS_file_information_get_id

(

struct GNUNET_FS_FileInformation *

s

)

Obtain the name under which this file information structure is stored on disk.

Only works for top-level file information structures.

Parameters

s	structure to get the filename for

Returns

NULL on error, otherwise filename that can be used to read this fi-struct from disk.

Definition at line 45 of file fs_file_information.c.

References GNUNET_FS_FileInformation::dir, and GNUNET_FS_FileInformation::serialization.

{
  if (NULL != s->dir)
    return NULL;
  return s->serialization;
}

GNUNET_FS_file_information_get_filename()

const char* GNUNET_FS_file_information_get_filename

(

struct GNUNET_FS_FileInformation *

s

)

Obtain the filename from the file information structure.

Parameters

s	structure to get the filename for

Returns

"filename" field of the structure (can be NULL)

Definition at line 59 of file fs_file_information.c.

References GNUNET_FS_FileInformation::filename.

{
  return s->filename;
}

GNUNET_FS_file_information_set_filename()

void GNUNET_FS_file_information_set_filename	(	struct GNUNET_FS_FileInformation *	s,
		const char *	filename
	)

Set the filename in the file information structure.

If filename was already set, frees it before setting the new one. Makes a copy of the argument.

Parameters

s	structure to get the filename for
filename	filename to set

Definition at line 74 of file fs_file_information.c.

References GNUNET_FS_FileInformation::filename, GNUNET_free_non_null, and GNUNET_strdup.

{
  GNUNET_free_non_null (s->filename);
  if (filename)
    s->filename = GNUNET_strdup (filename);
  else
    s->filename = NULL;
}

GNUNET_FS_file_information_create_from_file()

struct GNUNET_FS_FileInformation* 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,
		const struct GNUNET_FS_BlockOptions *	bo
	)

Create an entry for a file in a publish-structure.

Parameters

h	handle to the file sharing subsystem
client_info	initial client-info value for this entry
filename	name of the file or directory to publish
keywords	under which keywords should this file be available directly; can be NULL
meta	metadata for the file
do_index	GNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
bo	block options

Returns

publish structure entry for the file

Parameters

h	handle to the file sharing subsystem
client_info	initial value for the client-info value for this entry
filename	name of the file or directory to publish
keywords	under which keywords should this file be available directly; can be NULL
meta	metadata for the file
do_index	GNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
bo	block options

Returns

publish structure entry for the file

Definition at line 100 of file fs_file_information.c.

References DIR_SEPARATOR_STR, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METAFORMAT_UTF8, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, filename, GNUNET_FS_FileInformation::filename, fn, GNUNET_break, GNUNET_CONTAINER_meta_data_insert(), GNUNET_DISK_file_size(), GNUNET_ERROR_TYPE_WARNING, GNUNET_FS_data_reader_file_(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_make_file_reader_context_(), GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_YES, h, GNUNET_FS_FileInformation::h, GNUNET_FS_FileInformation::meta, plibc_conv_to_win_path(), and ret.

Referenced by get_file_information(), and publish_fs_connect_complete_cb().

{
  struct FileInfo *fi;
  uint64_t fsize;
  struct GNUNET_FS_FileInformation *ret;
  const char *fn;
  const char *ss;

#if WINDOWS
  char fn_conv[MAX_PATH];
#endif

  /* FIXME: should include_symbolic_links be GNUNET_NO or GNUNET_YES here? */
  if (GNUNET_OK != GNUNET_DISK_file_size (filename, &fsize, GNUNET_NO, GNUNET_YES))
  {
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "stat", filename);
    return NULL;
  }
  fi = GNUNET_FS_make_file_reader_context_ (filename);
  if (NULL == fi)
  {
    GNUNET_break (0);
    return NULL;
  }
  ret =
      GNUNET_FS_file_information_create_from_reader (h, client_info,
                                                     fsize,
                                                     &GNUNET_FS_data_reader_file_,
                                                     fi, keywords, meta,
                                                     do_index, bo);
  if (ret == NULL)
    return NULL;
  ret->h = h;
  ret->filename = GNUNET_strdup (filename);
#if !WINDOWS
  fn = filename;
#else
  plibc_conv_to_win_path (filename, fn_conv);
  fn = fn_conv;
#endif
  while (NULL != (ss = strstr (fn, DIR_SEPARATOR_STR)))
    fn = ss + 1;
/* FIXME: If we assume that on other platforms CRT is UTF-8-aware, then
 * this should be changed to EXTRACTOR_METAFORMAT_UTF8
 */
#if !WINDOWS
  GNUNET_CONTAINER_meta_data_insert (ret->meta, "<gnunet>",
                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
                                     EXTRACTOR_METAFORMAT_C_STRING,
                                     "text/plain", fn, strlen (fn) + 1);
#else
  GNUNET_CONTAINER_meta_data_insert (ret->meta, "<gnunet>",
                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
                                     EXTRACTOR_METAFORMAT_UTF8,
                                     "text/plain", fn, strlen (fn) + 1);
#endif
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_file_information_create_from_data()

struct GNUNET_FS_FileInformation* 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,
		const struct GNUNET_FS_BlockOptions *	bo
	)

Create an entry for a file in a publish-structure.

Parameters

h	handle to the file sharing subsystem
client_info	initial client-info value for this entry
length	length of the file
data	data for the file (should not be used afterwards by the caller; callee will "free")
keywords	under which keywords should this file be available directly; can be NULL
meta	metadata for the file
do_index	GNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
bo	block options

Returns

publish structure entry for the file

Parameters

h	handle to the file sharing subsystem
client_info	initial value for the client-info value for this entry
length	length of the file
data	data for the file (should not be used afterwards by the caller; callee will "free")
keywords	under which keywords should this file be available directly; can be NULL
meta	metadata for the file
do_index	GNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
bo	block options

Returns

publish structure entry for the file

Definition at line 186 of file fs_file_information.c.

References GNUNET_break, GNUNET_FS_data_reader_copy_(), GNUNET_FS_file_information_create_from_reader(), and GNUNET_YES.

Referenced by make_file().

{
  if (GNUNET_YES == do_index)
  {
    GNUNET_break (0);
    return NULL;
  }
  return GNUNET_FS_file_information_create_from_reader (h, client_info, length,
                                                        &GNUNET_FS_data_reader_copy_,
                                                        data, keywords, meta,
                                                        do_index, bo);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_file_information_create_from_reader()

struct GNUNET_FS_FileInformation* 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,
		const struct GNUNET_FS_BlockOptions *	bo
	)

Create an entry for a file in a publish-structure.

Parameters

h	handle to the file sharing subsystem
client_info	initial client-info value for this entry
length	length of the file
reader	function that can be used to obtain the data for the file
reader_cls	closure for reader
keywords	under which keywords should this file be available directly; can be NULL
meta	metadata for the file
do_index	GNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
bo	block options

Returns

publish structure entry for the file

Parameters

h	handle to the file sharing subsystem
client_info	initial value for the client-info value for this entry
length	length of the file
reader	function that can be used to obtain the data for the file
reader_cls	closure for "reader"
keywords	under which keywords should this file be available directly; can be NULL
meta	metadata for the file
do_index	GNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
bo	block options

Returns

publish structure entry for the file

Definition at line 226 of file fs_file_information.c.

References bo, GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::client_info, GNUNET_FS_FileInformation::data, GNUNET_FS_FileInformation::do_index, GNUNET_FS_FileInformation::file, GNUNET_break, GNUNET_CONTAINER_meta_data_create(), GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_FS_data_reader_file_(), GNUNET_FS_uri_dup(), GNUNET_new, GNUNET_YES, h, GNUNET_FS_FileInformation::h, GNUNET_FS_FileInformation::keywords, GNUNET_FS_FileInformation::meta, GNUNET_FS_FileInformation::reader, GNUNET_FS_FileInformation::reader_cls, and ret.

Referenced by GNUNET_FS_file_information_create_from_data(), GNUNET_FS_file_information_create_from_file(), and publish_fs_connect_complete_cb().

{
  struct GNUNET_FS_FileInformation *ret;

  if ((GNUNET_YES == do_index) && (reader != &GNUNET_FS_data_reader_file_))
  {
    GNUNET_break (0);
    return NULL;
  }
  ret = GNUNET_new (struct GNUNET_FS_FileInformation);
  ret->h = h;
  ret->client_info = client_info;
  ret->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
  if (ret->meta == NULL)
    ret->meta = GNUNET_CONTAINER_meta_data_create ();
  ret->keywords = (keywords == NULL) ? NULL : GNUNET_FS_uri_dup (keywords);
  ret->data.file.reader = reader;
  ret->data.file.reader_cls = reader_cls;
  ret->data.file.do_index = do_index;
  ret->data.file.file_size = length;
  ret->bo = *bo;
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_file_information_create_empty_directory()

struct GNUNET_FS_FileInformation* GNUNET_FS_file_information_create_empty_directory	(	struct GNUNET_FS_Handle *	h,
		void *	client_info,
		const struct GNUNET_FS_Uri *	keywords,
		const struct GNUNET_CONTAINER_MetaData *	meta,
		const struct GNUNET_FS_BlockOptions *	bo,
		const char *	filename
	)

Create an entry for an empty directory in a publish-structure.

Parameters

h	handle to the file sharing subsystem
client_info	initial client-info value for this entry
keywords	under which keywords should this directory be available directly; can be NULL
meta	metadata for the directory
bo	block options
filename	name of the directory; can be NULL

Returns

publish structure entry for the directory , NULL on error

Parameters

h	handle to the file sharing subsystem
client_info	initial value for the client-info value for this entry
meta	metadata for the directory
keywords	under which keywords should this directory be available directly; can be NULL
bo	block options
filename	name of the directory; can be NULL

Returns

publish structure entry for the directory , NULL on error

Definition at line 289 of file fs_file_information.c.

References bo, GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::client_info, GNUNET_FS_FileInformation::filename, GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_FS_uri_dup(), GNUNET_new, GNUNET_strdup, GNUNET_YES, h, GNUNET_FS_FileInformation::h, GNUNET_FS_FileInformation::is_directory, GNUNET_FS_FileInformation::keywords, GNUNET_FS_FileInformation::meta, and ret.

Referenced by get_file_information().

{
  struct GNUNET_FS_FileInformation *ret;

  ret = GNUNET_new (struct GNUNET_FS_FileInformation);
  ret->h = h;
  ret->client_info = client_info;
  ret->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
  ret->keywords = GNUNET_FS_uri_dup (keywords);
  ret->bo = *bo;
  ret->is_directory = GNUNET_YES;
  if (filename != NULL)
    ret->filename = GNUNET_strdup (filename);
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_file_information_is_directory()

int GNUNET_FS_file_information_is_directory

(

const struct GNUNET_FS_FileInformation *

ent

)

Test if a given entry represents a directory.

Parameters

ent	check if this FI represents a directory

Returns

GNUNET_YES if so, GNUNET_NO if not

Definition at line 269 of file fs_file_information.c.

References GNUNET_FS_FileInformation::is_directory.

{
  return ent->is_directory;
}

GNUNET_FS_file_information_add()

int GNUNET_FS_file_information_add	(	struct GNUNET_FS_FileInformation *	dir,
		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.

Parameters

dir	the directory
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

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Clients should never modify publish structures that were passed to GNUNET_FS_publish_start already.

Parameters

dir	the directory
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

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 327 of file fs_file_information.c.

References GNUNET_FS_FileInformation::data, dir, GNUNET_FS_FileInformation::dir, GNUNET_FS_FileInformation::dir_size, GNUNET_FS_FileInformation::entries, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, GNUNET_FS_FileInformation::is_directory, and GNUNET_FS_FileInformation::next.

Referenced by get_file_information().

{
  if ((ent->dir != NULL) || (ent->next != NULL) || (dir->is_directory != GNUNET_YES))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  ent->dir = dir;
  ent->next = dir->data.dir.entries;
  dir->data.dir.entries = ent;
  dir->data.dir.dir_size = 0;
  return GNUNET_OK;
}

Here is the caller graph for this function:

GNUNET_FS_file_information_inspect()

void GNUNET_FS_file_information_inspect	(	struct GNUNET_FS_FileInformation *	dir,
		GNUNET_FS_FileInformationProcessor	proc,
		void *	proc_cls
	)

Inspect a file or directory in a publish-structure.

Clients should never modify publish structures that were passed to GNUNET_FS_publish_start already. When called on a directory, this function will FIRST call proc with information about the directory itself and then for each of the files in the directory (but not for files in subdirectories). When called on a file, proc will be called exactly once (with information about the specific file).

Parameters

dir	the directory
proc	function to call on each entry
proc_cls	closure for proc

Definition at line 358 of file fs_file_information.c.

References GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::client_info, GNUNET_FS_FileInformation::data, GNUNET_FS_FileInformation::dir, GNUNET_FS_FileInformation::dir_size, GNUNET_FS_FileInformation::entries, GNUNET_FS_FileInformation::file, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_FS_FileInformation::is_directory, GNUNET_FS_FileInformation::keywords, GNUNET_FS_FileInformation::meta, and GNUNET_FS_FileInformation::next.

Referenced by deserialize_publish_file(), directory_trim_complete(), fip_signal_resume(), fip_signal_start(), fip_signal_stop(), fip_signal_suspend(), GNUNET_FS_publish_signal_suspend_(), GNUNET_FS_publish_start(), GNUNET_FS_publish_stop(), and publish_inspector().

{
  struct GNUNET_FS_FileInformation *pos;
  int no;

  no = GNUNET_NO;
  if (GNUNET_OK !=
      proc (proc_cls, dir,
            (dir->is_directory == GNUNET_YES) ? dir->data.dir.dir_size : dir->data.
            file.file_size,
            dir->meta, &dir->keywords, &dir->bo,
            (dir->is_directory == GNUNET_YES) ? &no : &dir->data.file.do_index,
            &dir->client_info))
    return;
  if (dir->is_directory != GNUNET_YES)
    return;
  pos = dir->data.dir.entries;
  while (pos != NULL)
  {
    no = GNUNET_NO;
    if (GNUNET_OK !=
        proc (proc_cls, pos,
              (pos->is_directory == GNUNET_YES) ? pos->data.dir.dir_size : pos->data.
              file.file_size, pos->meta, &pos->keywords, &pos->bo,
              (pos->is_directory == GNUNET_YES) ? &no : &pos->data.file.do_index,
              &pos->client_info))
      break;
    pos = pos->next;
  }
}

Here is the caller graph for this function:

GNUNET_FS_file_information_destroy()

void GNUNET_FS_file_information_destroy	(	struct GNUNET_FS_FileInformation *	fi,
		GNUNET_FS_FileInformationProcessor	cleaner,
		void *	cleaner_cls
	)

Destroy publish-structure.

Clients should never destroy publish structures that were passed to GNUNET_FS_publish_start already.

Parameters

fi	structure to destroy
cleaner	function to call on each entry in the structure (useful to clean up client_info); can be NULL; return values are ignored
cleaner_cls	closure for cleaner

Definition at line 403 of file fs_file_information.c.

References GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::chk_uri, GNUNET_FS_FileInformation::client_info, GNUNET_FS_FileInformation::data, GNUNET_FS_FileInformation::dir, GNUNET_FS_FileInformation::dir_data, GNUNET_FS_FileInformation::dir_size, GNUNET_FS_FileInformation::emsg, GNUNET_FS_FileInformation::entries, GNUNET_FS_FileInformation::file, GNUNET_FS_FileInformation::filename, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_FS_file_information_destroy(), GNUNET_FS_tree_encoder_finish(), GNUNET_FS_uri_destroy(), GNUNET_log_strerror_file, GNUNET_NO, GNUNET_YES, GNUNET_FS_FileInformation::is_directory, GNUNET_FS_FileInformation::keywords, GNUNET_FS_FileInformation::meta, GNUNET_FS_FileInformation::next, GNUNET_FS_FileInformation::serialization, GNUNET_FS_FileInformation::sks_uri, GNUNET_FS_FileInformation::te, and UNLINK.

Referenced by deserialize_fi_node(), deserialize_publish_file(), directory_trim_complete(), GNUNET_FS_file_information_destroy(), and publish_cleanup().

{
  struct GNUNET_FS_FileInformation *pos;
  int no;

  no = GNUNET_NO;
  if (GNUNET_YES == fi->is_directory)
  {
    /* clean up directory */
    while (NULL != (pos = fi->data.dir.entries))
    {
      fi->data.dir.entries = pos->next;
      GNUNET_FS_file_information_destroy (pos, cleaner, cleaner_cls);
    }
    /* clean up client-info */
    if (NULL != cleaner)
      cleaner (cleaner_cls, fi, fi->data.dir.dir_size, fi->meta, &fi->keywords,
               &fi->bo, &no, &fi->client_info);
    GNUNET_free_non_null (fi->data.dir.dir_data);
  }
  else
  {
    /* call clean-up function of the reader */
    if (NULL != fi->data.file.reader)
    {
      (void) fi->data.file.reader (fi->data.file.reader_cls, 0, 0, NULL, NULL);
      fi->data.file.reader = NULL;
    }
    /* clean up client-info */
    if (NULL != cleaner)
      cleaner (cleaner_cls, fi, fi->data.file.file_size, fi->meta,
               &fi->keywords, &fi->bo, &fi->data.file.do_index,
               &fi->client_info);
  }
  GNUNET_free_non_null (fi->filename);
  GNUNET_free_non_null (fi->emsg);
  if (NULL != fi->sks_uri)
      GNUNET_FS_uri_destroy (fi->sks_uri);
  if (NULL != fi->chk_uri)
      GNUNET_FS_uri_destroy (fi->chk_uri);
  /* clean up serialization */
  if ((NULL != fi->serialization) && (0 != UNLINK (fi->serialization)))
    GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink",
                              fi->serialization);
  if (NULL != fi->keywords)
    GNUNET_FS_uri_destroy (fi->keywords);
  if (NULL != fi->meta)
    GNUNET_CONTAINER_meta_data_destroy (fi->meta);
  GNUNET_free_non_null (fi->serialization);
  if (NULL != fi->te)
  {
    GNUNET_FS_tree_encoder_finish (fi->te, NULL);
    fi->te = NULL;
  }
  GNUNET_free (fi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_start()

struct GNUNET_FS_PublishContext* GNUNET_FS_publish_start	(	struct GNUNET_FS_Handle *	h,
		struct GNUNET_FS_FileInformation *	fi,
		const struct GNUNET_CRYPTO_EcdsaPrivateKey *	ns,
		const char *	nid,
		const char *	nuid,
		enum GNUNET_FS_PublishOptions	options
	)

Publish a file or directory.

Parameters

h	handle to the file sharing subsystem
fi	information about the file or directory structure to publish
ns	namespace to publish the file in, NULL for no namespace
nid	identifier to use for the publishd content in the namespace (can be NULL, must be NULL if namespace is NULL)
nuid	update-identifier that will be used for future updates (can be NULL, must be NULL if namespace or nid is NULL)
options	options for the publication

Returns

context that can be used to control the publish operation

Definition at line 1431 of file fs_publish.c.

References _, GNUNET_FS_Handle::cfg, compute_contents_size(), dsh, GNUNET_FS_PublishContext::dsh, GNUNET_FS_PublishContext::fi, GNUNET_FS_PublishContext::fi_pos, finish_reserve(), fip_signal_start(), GNUNET_assert, GNUNET_DATASTORE_connect(), GNUNET_DATASTORE_reserve(), GNUNET_ERROR_TYPE_INFO, GNUNET_FS_file_information_inspect(), GNUNET_FS_make_top(), GNUNET_FS_publish_main_(), GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY, GNUNET_FS_publish_signal_suspend_(), GNUNET_FS_publish_sync_(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_with_priority(), GNUNET_SCHEDULER_PRIORITY_BACKGROUND, GNUNET_strdup, h, GNUNET_FS_PublishContext::h, GNUNET_FS_PublishContext::nid, ns, GNUNET_FS_PublishContext::ns, GNUNET_FS_PublishContext::nuid, options, GNUNET_FS_PublishContext::options, GNUNET_FS_PublishContext::qre, GNUNET_FS_PublishContext::reserve_entries, GNUNET_FS_PublishContext::reserve_space, ret, GNUNET_FS_PublishContext::top, and GNUNET_FS_PublishContext::upload_task.

Referenced by directory_trim_complete(), publish_fs_connect_complete_cb(), and start_publish().

{
  struct GNUNET_FS_PublishContext *ret;
  struct GNUNET_DATASTORE_Handle *dsh;

  GNUNET_assert (NULL != h);
  compute_contents_size (fi);
  if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
  {
    dsh = GNUNET_DATASTORE_connect (h->cfg);
    if (NULL == dsh)
      return NULL;
  }
  else
  {
    dsh = NULL;
  }
  ret = GNUNET_new (struct GNUNET_FS_PublishContext);
  ret->dsh = dsh;
  ret->h = h;
  ret->fi = fi;
  if (NULL != ns)
  {
    ret->ns = GNUNET_new (struct GNUNET_CRYPTO_EcdsaPrivateKey);
    *ret->ns = *ns;
    GNUNET_assert (NULL != nid);
    ret->nid = GNUNET_strdup (nid);
    if (NULL != nuid)
      ret->nuid = GNUNET_strdup (nuid);
  }
  ret->options = options;
  /* signal start */
  GNUNET_FS_file_information_inspect (ret->fi, &fip_signal_start, ret);
  ret->fi_pos = ret->fi;
  ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_publish_signal_suspend_, ret);
  GNUNET_FS_publish_sync_ (ret);
  if (NULL != ret->dsh)
  {
    GNUNET_assert (NULL == ret->qre);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                _("Reserving space for %u entries and %llu bytes for publication\n"),
                (unsigned int) ret->reserve_entries,
                (unsigned long long) ret->reserve_space);
    ret->qre =
        GNUNET_DATASTORE_reserve (ret->dsh, ret->reserve_space,
                                  ret->reserve_entries,
                                  &finish_reserve,
                                  ret);
  }
  else
  {
    GNUNET_assert (NULL == ret->upload_task);
    ret->upload_task =
        GNUNET_SCHEDULER_add_with_priority
        (GNUNET_SCHEDULER_PRIORITY_BACKGROUND, &GNUNET_FS_publish_main_, ret);
  }
  return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_stop()

void GNUNET_FS_publish_stop

(

struct GNUNET_FS_PublishContext *

pc

)

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!

Parameters

pc	context for the publication to stop

Stop a publication.

Will abort incomplete uploads (but not remove blocks that have already been publishd) or simply clean up the state for completed uploads. Must NOT be called from within the event callback!

Parameters

pc	context for the upload to stop

Definition at line 1558 of file fs_publish.c.

References GNUNET_FS_Uri::chk, GNUNET_FS_FileInformation::chk_uri, GNUNET_FS_Uri::data, GNUNET_FS_PublishContext::fi, FileIdentifier::file_length, fip_signal_stop(), GNUNET_break, GNUNET_DATASTORE_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_FS_end_top(), GNUNET_FS_file_information_inspect(), GNUNET_FS_publish_ksk_cancel(), GNUNET_FS_publish_make_status_(), GNUNET_FS_publish_sks_cancel(), GNUNET_FS_remove_sync_file_(), GNUNET_FS_STATUS_PUBLISH_STOPPED, GNUNET_FS_SYNC_PATH_FILE_INFO, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH, GNUNET_log, GNUNET_ntohll(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_FS_PublishContext::h, GNUNET_FS_PublishContext::ksk_pc, publish_cleanup(), GNUNET_FS_PublishContext::qre, GNUNET_FS_FileInformation::serialization, GNUNET_FS_PublishContext::serialization, GNUNET_FS_PublishContext::skip_next_fi_callback, GNUNET_FS_PublishContext::sks_pc, GNUNET_FS_ProgressInfo::status, GNUNET_FS_PublishContext::top, and GNUNET_FS_PublishContext::upload_task.

Referenced by do_stop_task(), publish_stop_task(), publish_timeout(), report_uri(), and shutdown_task().

{
  struct GNUNET_FS_ProgressInfo pi;
  uint64_t off;

  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Publish stop called\n");
  GNUNET_FS_end_top (pc->h, pc->top);
  if (NULL != pc->ksk_pc)
  {
    GNUNET_FS_publish_ksk_cancel (pc->ksk_pc);
    pc->ksk_pc = NULL;
  }
  if (NULL != pc->sks_pc)
  {
    GNUNET_FS_publish_sks_cancel (pc->sks_pc);
    pc->sks_pc = NULL;
  }
  if (NULL != pc->upload_task)
  {
    GNUNET_SCHEDULER_cancel (pc->upload_task);
    pc->upload_task = NULL;
  }
  pc->skip_next_fi_callback = GNUNET_YES;
  GNUNET_FS_file_information_inspect (pc->fi, &fip_signal_stop, pc);

  if (NULL != pc->fi->serialization)
  {
    GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_FILE_INFO,
                                 pc->fi->serialization);
    GNUNET_free (pc->fi->serialization);
    pc->fi->serialization = NULL;
  }
  off = (NULL == pc->fi->chk_uri) ? 0 : GNUNET_ntohll (pc->fi->chk_uri->data.chk.file_length);

  if (NULL != pc->serialization)
  {
    GNUNET_FS_remove_sync_file_ (pc->h, GNUNET_FS_SYNC_PATH_MASTER_PUBLISH,
                                 pc->serialization);
    GNUNET_free (pc->serialization);
    pc->serialization = NULL;
  }
  if (NULL != pc->qre)
  {
    GNUNET_DATASTORE_cancel (pc->qre);
    pc->qre = NULL;
  }
  pi.status = GNUNET_FS_STATUS_PUBLISH_STOPPED;
  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi, off));
  publish_cleanup (pc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_ksk()

struct GNUNET_FS_PublishKskContext* GNUNET_FS_publish_ksk	(	struct GNUNET_FS_Handle *	h,
		const struct GNUNET_FS_Uri *	ksk_uri,
		const struct GNUNET_CONTAINER_MetaData *	meta,
		const struct GNUNET_FS_Uri *	uri,
		const struct GNUNET_FS_BlockOptions *	bo,
		enum GNUNET_FS_PublishOptions	options,
		GNUNET_FS_PublishContinuation	cont,
		void *	cont_cls
	)

Publish a KBlock on GNUnet.

Parameters

h	handle to the file sharing subsystem
ksk_uri	keywords to use
meta	metadata to use
uri	URI to refer to in the KBlock
bo	block options
options	publication options
cont	continuation
cont_cls	closure for cont

Returns

NULL on error (cont will still be called)

Publish a KBlock on GNUnet.

Parameters

h	handle to the file sharing subsystem
ksk_uri	keywords to use
meta	metadata to use
uri	URI to refer to in the KBlock
bo	per-block options
options	publication options
cont	continuation
cont_cls	closure for cont

Returns

NULL on error ('cont' will still be called)

Definition at line 195 of file fs_publish_ksk.c.

References _, GNUNET_FS_PublishKskContext::bo, GNUNET_FS_Handle::cfg, GNUNET_FS_PublishKskContext::cont, GNUNET_FS_PublishKskContext::cont_cls, GNUNET_FS_PublishKskContext::dsh, GNUNET_assert, GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_DATASTORE_connect(), GNUNET_free, GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY, GNUNET_FS_uri_dup(), GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_FS_PublishKskContext::h, GNUNET_FS_PublishKskContext::ksk_task, GNUNET_FS_PublishKskContext::ksk_uri, GNUNET_FS_PublishKskContext::meta, GNUNET_FS_PublishKskContext::options, publish_ksk_cont(), and GNUNET_FS_PublishKskContext::uri.

Referenced by identity_continuation(), and publish_kblocks().

{
  struct GNUNET_FS_PublishKskContext *pkc;

  GNUNET_assert (NULL != uri);
  pkc = GNUNET_new (struct GNUNET_FS_PublishKskContext);
  pkc->h = h;
  pkc->bo = *bo;
  pkc->options = options;
  pkc->cont = cont;
  pkc->cont_cls = cont_cls;
  pkc->meta = GNUNET_CONTAINER_meta_data_duplicate (meta);
  if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
  {
    pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
    if (NULL == pkc->dsh)
    {
      cont (cont_cls,
            NULL,
            _("Could not connect to datastore."));
      GNUNET_free (pkc);
      return NULL;
    }
  }
  pkc->uri = GNUNET_FS_uri_dup (uri);
  pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri);
  pkc->ksk_task = GNUNET_SCHEDULER_add_now (&publish_ksk_cont, pkc);
  return pkc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_ksk_cancel()

void GNUNET_FS_publish_ksk_cancel

(

struct GNUNET_FS_PublishKskContext *

pkc

)

Abort the KSK publishing operation.

Parameters

pkc	context of the operation to abort.

Definition at line 238 of file fs_publish_ksk.c.

References GNUNET_FS_PublishKskContext::dsh, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_DATASTORE_disconnect(), GNUNET_free, GNUNET_FS_publish_ublock_cancel_(), GNUNET_FS_uri_destroy(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_FS_PublishKskContext::ksk_task, GNUNET_FS_PublishKskContext::ksk_uri, GNUNET_FS_PublishKskContext::meta, GNUNET_FS_PublishKskContext::uc, and GNUNET_FS_PublishKskContext::uri.

Referenced by GNUNET_FS_publish_stop(), kb_put_cont(), publish_ksk_cont(), and suspend_operation().

{
  if (NULL != pkc->ksk_task)
  {
    GNUNET_SCHEDULER_cancel (pkc->ksk_task);
    pkc->ksk_task = NULL;
  }
  if (NULL != pkc->uc)
  {
    GNUNET_FS_publish_ublock_cancel_ (pkc->uc);
    pkc->uc = NULL;
  }
  if (NULL != pkc->dsh)
  {
    GNUNET_DATASTORE_disconnect (pkc->dsh, GNUNET_NO);
    pkc->dsh = NULL;
  }
  GNUNET_CONTAINER_meta_data_destroy (pkc->meta);
  GNUNET_FS_uri_destroy (pkc->ksk_uri);
  GNUNET_FS_uri_destroy (pkc->uri);
  GNUNET_free (pkc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_sks()

struct GNUNET_FS_PublishSksContext* GNUNET_FS_publish_sks	(	struct GNUNET_FS_Handle *	h,
		const struct GNUNET_CRYPTO_EcdsaPrivateKey *	ns,
		const char *	identifier,
		const char *	update,
		const struct GNUNET_CONTAINER_MetaData *	meta,
		const struct GNUNET_FS_Uri *	uri,
		const struct GNUNET_FS_BlockOptions *	bo,
		enum GNUNET_FS_PublishOptions	options,
		GNUNET_FS_PublishContinuation	cont,
		void *	cont_cls
	)

Publish an SBlock on GNUnet.

Parameters

h	handle to the file sharing subsystem
ns	namespace to publish in
identifier	identifier to use
update	update identifier to use
meta	metadata to use
uri	URI to refer to in the SBlock
bo	block options
options	publication options
cont	continuation
cont_cls	closure for cont

Returns

NULL on error (cont will still be called)

Parameters

h	handle to the file sharing subsystem
ns	namespace to publish in
identifier	identifier to use
update	update identifier to use
meta	metadata to use
uri	URI to refer to in the SBlock
bo	block options
options	publication options
cont	continuation
cont_cls	closure for cont

Returns

NULL on error ('cont' will still be called)

Definition at line 440 of file fs_namespace.c.

References _, GNUNET_FS_Handle::cfg, GNUNET_FS_PublishSksContext::cont, GNUNET_FS_PublishSksContext::cont_cls, GNUNET_FS_Uri::data, GNUNET_FS_PublishSksContext::dsh, GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_DATASTORE_connect(), GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY, GNUNET_FS_publish_ublock_(), GNUNET_FS_uri_dup(), GNUNET_FS_URI_SKS, GNUNET_new, GNUNET_strdup, h, GNUNET_FS_PublishSksContext::h, NamespaceUpdateNode::id, NamespaceUpdateNode::md, ns, GNUNET_FS_PublishSksContext::ns, GNUNET_FS_PublishSksContext::nsn, GNUNET_FS_Uri::sks, sks_publish_cont(), GNUNET_FS_Uri::type, GNUNET_FS_PublishSksContext::uc, NamespaceUpdateNode::update, NamespaceUpdateNode::uri, and GNUNET_FS_PublishSksContext::uri.

Referenced by publish_sblock(), and uri_ksk_continuation().

{
  struct GNUNET_FS_PublishSksContext *psc;
  struct GNUNET_FS_Uri *sks_uri;

  sks_uri = GNUNET_new (struct GNUNET_FS_Uri);
  sks_uri->type = GNUNET_FS_URI_SKS;
  sks_uri->data.sks.identifier = GNUNET_strdup (identifier);
  GNUNET_CRYPTO_ecdsa_key_get_public (ns,
                                    &sks_uri->data.sks.ns);

  psc = GNUNET_new (struct GNUNET_FS_PublishSksContext);
  psc->h = h;
  psc->uri = sks_uri;
  psc->cont = cont;
  psc->cont_cls = cont_cls;
  psc->ns = *ns;
  if (0 == (options & GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY))
  {
    psc->dsh = GNUNET_DATASTORE_connect (h->cfg);
    if (NULL == psc->dsh)
    {
      sks_publish_cont (psc,
                        _("Failed to connect to datastore."));
      return NULL;
    }
  }
  if (NULL != update)
  {
    psc->nsn = GNUNET_new (struct NamespaceUpdateNode);
    psc->nsn->id = GNUNET_strdup (identifier);
    psc->nsn->update = GNUNET_strdup (update);
    psc->nsn->md = GNUNET_CONTAINER_meta_data_duplicate (meta);
    psc->nsn->uri = GNUNET_FS_uri_dup (uri);
  }
  psc->uc = GNUNET_FS_publish_ublock_ (h,
                                       psc->dsh,
                                       identifier,
                                       update,
                                       ns,
                                       meta,
                                       uri,
                                       bo,
                                       options,
                                       &sks_publish_cont,
                                       psc);
  return psc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_publish_sks_cancel()

void GNUNET_FS_publish_sks_cancel

(

struct GNUNET_FS_PublishSksContext *

psc

)

Abort the SKS publishing operation.

Parameters

psc	context of the operation to abort.

Definition at line 503 of file fs_namespace.c.

References GNUNET_FS_PublishSksContext::dsh, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_DATASTORE_disconnect(), GNUNET_free, GNUNET_FS_publish_ublock_cancel_(), GNUNET_FS_uri_destroy(), GNUNET_NO, NamespaceUpdateNode::id, NamespaceUpdateNode::md, GNUNET_FS_PublishSksContext::nsn, GNUNET_FS_PublishSksContext::uc, NamespaceUpdateNode::update, NamespaceUpdateNode::uri, and GNUNET_FS_PublishSksContext::uri.

Referenced by GNUNET_FS_publish_stop(), sks_publish_cont(), and suspend_operation().

{
  if (NULL != psc->uc)
  {
    GNUNET_FS_publish_ublock_cancel_ (psc->uc);
    psc->uc = NULL;
  }
  if (NULL != psc->dsh)
  {
    GNUNET_DATASTORE_disconnect (psc->dsh, GNUNET_NO);
    psc->dsh = NULL;
  }
  GNUNET_FS_uri_destroy (psc->uri);
  if (NULL != psc->nsn)
  {
    GNUNET_CONTAINER_meta_data_destroy (psc->nsn->md);
    GNUNET_FS_uri_destroy (psc->nsn->uri);
    GNUNET_free (psc->nsn->id);
    GNUNET_free (psc->nsn->update);
    GNUNET_free (psc->nsn);
  }
  GNUNET_free (psc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_get_indexed_files()

struct GNUNET_FS_GetIndexedContext* GNUNET_FS_get_indexed_files	(	struct GNUNET_FS_Handle *	h,
		GNUNET_FS_IndexedFileProcessor	iterator,
		void *	iterator_cls
	)

Iterate over all indexed files.

Parameters

h	handle to the file sharing subsystem
iterator	function to call on each indexed file
iterator_cls	closure for iterator

Returns

NULL on error (iterator is not called)

Parameters

h	handle to the file sharing subsystem
iterator	function to call on each indexed file
iterator_cls	closure for iterator

Returns

NULL on error ('iter' is not called)

Definition at line 168 of file fs_list_indexed.c.

References _, GNUNET_FS_Handle::cfg, env, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_new, GNUNET_FS_GetIndexedContext::iterator, GNUNET_FS_GetIndexedContext::iterator_cls, GNUNET_FS_GetIndexedContext::mq, mq_error_handler(), and msg.

Referenced by run().

{
  struct GNUNET_FS_GetIndexedContext *gic
    = GNUNET_new (struct GNUNET_FS_GetIndexedContext);
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (index_info_end,
                             GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END,
                             struct GNUNET_MessageHeader,
                             gic),
    GNUNET_MQ_hd_var_size (index_info,
                           GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY,
                           struct IndexInfoMessage,
                           gic),
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;

  gic->mq = GNUNET_CLIENT_connect (h->cfg,
                                   "fs",
                                   handlers,
                                   &mq_error_handler,
                                   h);
  if (NULL == gic->mq)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _("Failed to not connect to `%s' service.\n"),
                "fs");
    GNUNET_free (gic);
    return NULL;
  }
  gic->iterator = iterator;
  gic->iterator_cls = iterator_cls;
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET);
  GNUNET_MQ_send (gic->mq,
                  env);
  return gic;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_get_indexed_files_cancel()

void GNUNET_FS_get_indexed_files_cancel

(

struct GNUNET_FS_GetIndexedContext *

gic

)

Cancel iteration over all indexed files.

Parameters

gic	operation to cancel

Definition at line 217 of file fs_list_indexed.c.

References GNUNET_free, GNUNET_MQ_destroy(), and GNUNET_FS_GetIndexedContext::mq.

Referenced by handle_index_info(), handle_index_info_end(), and mq_error_handler().

{
  GNUNET_MQ_destroy (gic->mq);
  GNUNET_free (gic);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_unindex_start()

struct GNUNET_FS_UnindexContext* GNUNET_FS_unindex_start	(	struct GNUNET_FS_Handle *	h,
		const char *	filename,
		void *	cctx
	)

Unindex a file.

Parameters

h	handle to the file sharing subsystem
filename	file to unindex
cctx	initial value for the client context

Returns

NULL on error, otherwise handle

Definition at line 791 of file fs_unindex.c.

References GNUNET_FS_ProgressInfo::cctx, GNUNET_FS_UnindexContext::client_info, GNUNET_FS_UnindexContext::fhc, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_size(), GNUNET_FS_make_top(), GNUNET_FS_STATUS_UNINDEX_START, GNUNET_FS_unindex_make_status_(), GNUNET_FS_unindex_process_hash_(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_sync_(), GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_strdup, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, h, GNUNET_FS_UnindexContext::h, HASHING_BLOCKSIZE, size, GNUNET_FS_UnindexContext::start_time, GNUNET_FS_ProgressInfo::status, GNUNET_FS_UnindexContext::top, uc, GNUNET_FS_ProgressInfo::unindex, and GNUNET_FS_ProgressInfo::value.

Referenced by ds_put_cont(), run(), and signal_publish_error().

{
  struct GNUNET_FS_UnindexContext *uc;
  struct GNUNET_FS_ProgressInfo pi;
  uint64_t size;

  if (GNUNET_OK !=
      GNUNET_DISK_file_size (filename,
                             &size,
                             GNUNET_YES,
                             GNUNET_YES))
    return NULL;
  uc = GNUNET_new (struct GNUNET_FS_UnindexContext);
  uc->h = h;
  uc->filename = GNUNET_strdup (filename);
  uc->start_time = GNUNET_TIME_absolute_get ();
  uc->file_size = size;
  uc->client_info = cctx;
  GNUNET_FS_unindex_sync_ (uc);
  pi.status = GNUNET_FS_STATUS_UNINDEX_START;
  pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
  GNUNET_FS_unindex_make_status_ (&pi, uc, 0);
  uc->fhc =
      GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
                               filename,
                               HASHING_BLOCKSIZE,
                               &GNUNET_FS_unindex_process_hash_, uc);
  uc->top = GNUNET_FS_make_top (h,
                                &GNUNET_FS_unindex_signal_suspend_,
                                uc);
  return uc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_unindex_stop()

void GNUNET_FS_unindex_stop

(

struct GNUNET_FS_UnindexContext *

uc

)

Clean up after completion of an unindex operation.

Parameters

uc

handle

Definition at line 833 of file fs_unindex.c.

References GNUNET_FS_UnindexContext::client_info, GNUNET_FS_UnindexContext::dqe, GNUNET_FS_UnindexContext::dscan, GNUNET_FS_UnindexContext::dsh, GNUNET_FS_UnindexContext::emsg, GNUNET_FS_UnindexContext::fh, GNUNET_FS_UnindexContext::fhc, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, GNUNET_break, GNUNET_CRYPTO_hash_file_cancel(), GNUNET_DATASTORE_cancel(), GNUNET_DATASTORE_disconnect(), GNUNET_DISK_file_close(), GNUNET_free, GNUNET_free_non_null, GNUNET_FS_directory_scan_abort(), GNUNET_FS_end_top(), GNUNET_FS_remove_sync_file_(), GNUNET_FS_STATUS_UNINDEX_STOPPED, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX, GNUNET_FS_tree_encoder_finish(), GNUNET_FS_unindex_make_status_(), GNUNET_FS_uri_destroy(), GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_TIME_UNIT_ZERO, GNUNET_FS_UnindexContext::h, GNUNET_FS_UnindexContext::ksk_uri, GNUNET_FS_UnindexContext::mq, GNUNET_FS_UnindexContext::serialization, GNUNET_FS_UnindexContext::state, GNUNET_FS_ProgressInfo::status, GNUNET_FS_UnindexContext::tc, GNUNET_FS_UnindexContext::top, GNUNET_FS_ProgressInfo::unindex, UNINDEX_STATE_COMPLETE, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_unindex_process_hash_(), progress_cb(), and shutdown_task().

{
  struct GNUNET_FS_ProgressInfo pi;

  if (NULL != uc->dscan)
  {
    GNUNET_FS_directory_scan_abort (uc->dscan);
    uc->dscan = NULL;
  }
  if (NULL != uc->dqe)
  {
    GNUNET_DATASTORE_cancel (uc->dqe);
    uc->dqe = NULL;
  }
  if (NULL != uc->fhc)
  {
    GNUNET_CRYPTO_hash_file_cancel (uc->fhc);
    uc->fhc = NULL;
  }
  if (NULL != uc->mq)
  {
    GNUNET_MQ_destroy (uc->mq);
    uc->mq = NULL;
  }
  if (NULL != uc->dsh)
  {
    GNUNET_DATASTORE_disconnect (uc->dsh, GNUNET_NO);
    uc->dsh = NULL;
  }
  if (NULL != uc->ksk_uri)
  {
    GNUNET_FS_uri_destroy (uc->ksk_uri);
    uc->ksk_uri = NULL;
  }
  if (NULL != uc->tc)
  {
    GNUNET_FS_tree_encoder_finish (uc->tc, NULL);
    uc->tc = NULL;
  }
  if (uc->fh != NULL)
  {
    GNUNET_DISK_file_close (uc->fh);
    uc->fh = NULL;
  }
  GNUNET_FS_end_top (uc->h, uc->top);
  if (uc->serialization != NULL)
  {
    GNUNET_FS_remove_sync_file_ (uc->h, GNUNET_FS_SYNC_PATH_MASTER_UNINDEX,
                                 uc->serialization);
    GNUNET_free (uc->serialization);
    uc->serialization = NULL;
  }
  pi.status = GNUNET_FS_STATUS_UNINDEX_STOPPED;
  pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
  GNUNET_FS_unindex_make_status_ (&pi, uc,
                                  (uc->state ==
                                   UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
  GNUNET_break (NULL == uc->client_info);
  GNUNET_free_non_null (uc->emsg);
  GNUNET_free (uc->filename);
  GNUNET_free (uc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_namespace_list_updateable()

void GNUNET_FS_namespace_list_updateable	(	struct GNUNET_FS_Handle *	h,
		const struct GNUNET_CRYPTO_EcdsaPrivateKey *	ns,
		const char *	next_id,
		GNUNET_FS_IdentifierProcessor	ip,
		void *	ip_cls
	)

List all of the identifiers in the namespace for which we could produce an update.

Namespace updates form a graph where each node has a name. Each node can have any number of URI/meta-data entries which can each be linked to other nodes. Cycles are possible.

Calling this function with next_id NULL will cause the library to call ip with a root for each strongly connected component of the graph (a root being a node from which all other nodes in the Scc are reachable).

Calling this function with next_id being the name of a node will cause the library to call ip with all children of the node. Note that cycles within an SCC are possible (including self-loops).

Parameters

h	fs handle to use
ns	namespace to inspect for