FS service

File sharing. More...

Collaboration diagram for FS service:

Modules
	Metadata
	Meta data processingGNU libextractor key-value pairs.

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	EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME   180
#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
	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(*	EXTRACTOR_MetaDataProcessor) (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format, const char *data_mime_type, const char *data, size_t data_len)
	Type of a function that libextractor calls for each meta data item found. More...
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_FS_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_FS_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_FS_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	EXTRACTOR_MetaType {   EXTRACTOR_METATYPE_RESERVED = 0 , EXTRACTOR_METATYPE_MIMETYPE = 1 , EXTRACTOR_METATYPE_FILENAME = 2 , EXTRACTOR_METATYPE_COMMENT = 3 ,   EXTRACTOR_METATYPE_TITLE = 4 , EXTRACTOR_METATYPE_BOOK_TITLE = 5 , EXTRACTOR_METATYPE_JOURNAL_NAME = 8 , EXTRACTOR_METATYPE_AUTHOR_NAME = 13 ,   EXTRACTOR_METATYPE_PUBLICATION_DATE = 24 , EXTRACTOR_METATYPE_URL = 29 , EXTRACTOR_METATYPE_URI = 30 , EXTRACTOR_METATYPE_ISRC = 31 ,   EXTRACTOR_METATYPE_UNKNOWN = 45 , EXTRACTOR_METATYPE_DESCRIPTION = 46 , EXTRACTOR_METATYPE_KEYWORDS = 49 , EXTRACTOR_METATYPE_SUBJECT = 52 ,   EXTRACTOR_METATYPE_PACKAGE_NAME = 69 , EXTRACTOR_METATYPE_THUMBNAIL = 114 , EXTRACTOR_METATYPE_ALBUM = 129 , EXTRACTOR_METATYPE_ARTIST = 130 ,   EXTRACTOR_METATYPE_ORIGINAL_TITLE = 162 , EXTRACTOR_METATYPE_GNUNET_FULL_DATA = 174 , EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME = 180 }
	Enumeration defining various sources of keywords. More...
enum	EXTRACTOR_MetaFormat { EXTRACTOR_METAFORMAT_UNKNOWN = 0 , EXTRACTOR_METAFORMAT_UTF8 = 1 , EXTRACTOR_METAFORMAT_BINARY = 2 , EXTRACTOR_METAFORMAT_C_STRING = 3 }
	Format in which the extracted meta data is presented. More...
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 = (UINT32_C(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...
const struct GNUNET_HashCode *	GNUNET_FS_uri_chk_get_file_hash (const struct GNUNET_FS_Uri *uri)
	What is the hash of the original file's content 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_FS_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_FS_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 (const 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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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_FS_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...
enum GNUNET_GenericReturnValue	GNUNET_FS_write_meta_data (struct GNUNET_BIO_WriteHandle *h, const char *what, const struct GNUNET_FS_MetaData *m)
	Write a metadata container. More...
struct GNUNET_BIO_ReadSpec	GNUNET_FS_read_spec_meta_data (const char *what, struct GNUNET_FS_MetaData **result)
	Create the specification to read a metadata container. More...
struct GNUNET_BIO_WriteSpec	GNUNET_FS_write_spec_meta_data (const char *what, const struct GNUNET_FS_MetaData *m)
	Create the specification to write a metadata container. More...
enum GNUNET_GenericReturnValue	GNUNET_FS_read_meta_data (struct GNUNET_BIO_ReadHandle *h, const char *what, struct GNUNET_FS_MetaData **result)
	Read a metadata container. 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 72 of file gnunet_fs_service.h.

EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME

#define EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME   180

Definition at line 171 of file gnunet_fs_service.h.

GNUNET_FS_URI_PREFIX

#define GNUNET_FS_URI_PREFIX   "gnunet://fs/"

Definition at line 177 of file gnunet_fs_service.h.

GNUNET_FS_URI_KSK_INFIX

#define GNUNET_FS_URI_KSK_INFIX   "ksk/"

Definition at line 178 of file gnunet_fs_service.h.

GNUNET_FS_URI_SKS_INFIX

#define GNUNET_FS_URI_SKS_INFIX   "sks/"

Definition at line 179 of file gnunet_fs_service.h.

GNUNET_FS_URI_CHK_INFIX

#define GNUNET_FS_URI_CHK_INFIX   "chk/"

Definition at line 180 of file gnunet_fs_service.h.

GNUNET_FS_URI_LOC_INFIX

#define GNUNET_FS_URI_LOC_INFIX   "loc/"

Definition at line 181 of file gnunet_fs_service.h.

GNUNET_FS_PROBE_UPDATE_FREQUENCY

#define GNUNET_FS_PROBE_UPDATE_FREQUENCY

Value:

    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 188 of file gnunet_fs_service.h.

GNUNET_FS_DIRECTORY_MIME

#define GNUNET_FS_DIRECTORY_MIME   "application/gnunet-directory"

Definition at line 2582 of file gnunet_fs_service.h.

GNUNET_FS_DIRECTORY_MAGIC

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

Definition at line 2583 of file gnunet_fs_service.h.

GNUNET_FS_DIRECTORY_EXT

#define GNUNET_FS_DIRECTORY_EXT   ".gnd"

Definition at line 2584 of file gnunet_fs_service.h.

Typedef Documentation

EXTRACTOR_MetaDataProcessor

typedef int(* EXTRACTOR_MetaDataProcessor) (void *cls, const char *plugin_name, enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format, const char *data_mime_type, const char *data, size_t data_len)

Type of a function that libextractor calls for each meta data item found.

Parameters

cls	closure (user-defined)
plugin_name	name of the plugin that produced this value; special values can be used (e.g. '<zlib>' for zlib being used in the main libextractor library and yielding meta data).
type	libextractor-type describing the meta data
format	basic format information about data
data_mime_type	mime-type of data (not of the original file); can be NULL (if mime-type is not known)
data	actual meta-data found
data_len	number of bytes in data

Returns

0 to continue extracting, 1 to abort

Definition at line 159 of file gnunet_fs_service.h.

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 211 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 1669 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_FS_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 1823 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 1948 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 2136 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 2230 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_FS_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 2297 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_FS_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 2634 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 2770 of file gnunet_fs_service.h.

Enumeration Type Documentation

EXTRACTOR_MetaType

enum EXTRACTOR_MetaType

Enumeration defining various sources of keywords.

See also http://dublincore.org/documents/1998/09/dces/

Enumerator
EXTRACTOR_METATYPE_RESERVED
EXTRACTOR_METATYPE_MIMETYPE
EXTRACTOR_METATYPE_FILENAME
EXTRACTOR_METATYPE_COMMENT
EXTRACTOR_METATYPE_TITLE
EXTRACTOR_METATYPE_BOOK_TITLE
EXTRACTOR_METATYPE_JOURNAL_NAME
EXTRACTOR_METATYPE_AUTHOR_NAME
EXTRACTOR_METATYPE_PUBLICATION_DATE
EXTRACTOR_METATYPE_URL
EXTRACTOR_METATYPE_URI
EXTRACTOR_METATYPE_ISRC
EXTRACTOR_METATYPE_UNKNOWN
EXTRACTOR_METATYPE_DESCRIPTION
EXTRACTOR_METATYPE_KEYWORDS
EXTRACTOR_METATYPE_SUBJECT
EXTRACTOR_METATYPE_PACKAGE_NAME
EXTRACTOR_METATYPE_THUMBNAIL
EXTRACTOR_METATYPE_ALBUM
EXTRACTOR_METATYPE_ARTIST
EXTRACTOR_METATYPE_ORIGINAL_TITLE
EXTRACTOR_METATYPE_GNUNET_FULL_DATA
EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME

Definition at line 86 of file gnunet_fs_service.h.

{
  EXTRACTOR_METATYPE_RESERVED = 0,
  EXTRACTOR_METATYPE_MIMETYPE = 1,
  EXTRACTOR_METATYPE_FILENAME = 2,
  EXTRACTOR_METATYPE_COMMENT = 3,
  EXTRACTOR_METATYPE_TITLE = 4,
  EXTRACTOR_METATYPE_BOOK_TITLE = 5,
  EXTRACTOR_METATYPE_JOURNAL_NAME = 8,
  EXTRACTOR_METATYPE_AUTHOR_NAME = 13,
  EXTRACTOR_METATYPE_PUBLICATION_DATE = 24,
  EXTRACTOR_METATYPE_URL = 29,
  EXTRACTOR_METATYPE_URI = 30,
  EXTRACTOR_METATYPE_ISRC = 31,
  EXTRACTOR_METATYPE_UNKNOWN = 45,
  EXTRACTOR_METATYPE_DESCRIPTION = 46,
  EXTRACTOR_METATYPE_KEYWORDS = 49,
  EXTRACTOR_METATYPE_SUBJECT = 52,
  EXTRACTOR_METATYPE_PACKAGE_NAME = 69,
  EXTRACTOR_METATYPE_THUMBNAIL = 114,
  EXTRACTOR_METATYPE_ALBUM = 129,
  EXTRACTOR_METATYPE_ARTIST = 130,
  EXTRACTOR_METATYPE_ORIGINAL_TITLE = 162,
  EXTRACTOR_METATYPE_GNUNET_FULL_DATA = 174,
  EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME = 180,
};

EXTRACTOR_MetaFormat

enum EXTRACTOR_MetaFormat

Format in which the extracted meta data is presented.

Enumerator
EXTRACTOR_METAFORMAT_UNKNOWN	Format is unknown.
EXTRACTOR_METAFORMAT_UTF8	0-terminated, UTF-8 encoded string. "data_len" is strlen(data)+1.
EXTRACTOR_METAFORMAT_BINARY	Some kind of binary format, see given Mime type.
EXTRACTOR_METAFORMAT_C_STRING	0-terminated string. The specific encoding is unknown. "data_len" is strlen (data)+1.

Definition at line 116 of file gnunet_fs_service.h.

{
  EXTRACTOR_METAFORMAT_UNKNOWN = 0,
 
  EXTRACTOR_METAFORMAT_UTF8 = 1,
 
  EXTRACTOR_METAFORMAT_BINARY = 2,
 
  EXTRACTOR_METAFORMAT_C_STRING = 3
};

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 further 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 629 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 1677 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 (individual downloads may go above this, but if we are above this threshold, we should not activate any additional downloads.

Definition at line 1702 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 2079 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 2341 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 2432 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 = (UINT32_C(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 2723 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	where to store the unique key

Returns

GNUNET_OK on success

Definition at line 96 of file fs_uri.c.

{
  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;
  }
}

References FileIdentifier::chk, GNUNET_FS_Uri::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::identifier, key, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::loc, ContentHashKey::query, GNUNET_FS_Uri::sks, GNUNET_FS_Uri::type, and uri.

Referenced by process_ksk_result(), and process_sks_result().

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 2034 of file fs_uri.c.

{
  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;
  }
}

References GNUNET_break, GNUNET_FS_URI_CHK, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC, GNUNET_FS_URI_SKS, GNUNET_FS_Uri::type, uri, 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(), print_search_result(), progress_cb(), run(), trigger_recursive_download(), and write_update_information_graph().

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 148 of file fs_uri.c.

{
  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;
}

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

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 752 of file fs_uri.c.

{
  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);
}

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

Referenced by get_file_information(), and migrate_and_drop_keywords().

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 780 of file fs_uri.c.

{
  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;
    }
  }
}

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

Referenced by remove_high_frequency_keywords().

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

FIXME: Do we want to log this?

Definition at line 637 of file fs_uri.c.

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

References _, GNUNET_break, GNUNET_free, GNUNET_strdup, msg, ret, uri, 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().

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 677 of file fs_uri.c.

{
  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);
}

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::identifier, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::sks, GNUNET_FS_Uri::type, and uri.

Referenced by deserialize_search_result(), do_stop_task(), 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(), run(), search_result_free(), search_result_suspend(), search_start(), and share_tree_trim().

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 711 of file fs_uri.c.

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

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

Referenced by fip_signal_start().

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

Definition at line 720 of file fs_uri.c.

{
  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;
}

References GNUNET_FS_Uri::data, GNUNET_FS_URI_KSK, GNUNET_OK, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::type, and uri.

Referenced by publish_inspector(), and share_tree_trim().

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 812 of file fs_uri.c.

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

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

Referenced by create_download_context(), and deserialize_download().

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 843 of file fs_uri.c.

{
  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;
}

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

Referenced by GNUNET_FS_directory_builder_add().

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 829 of file fs_uri.c.

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

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

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 869 of file fs_uri.c.

{
  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_CRYPTO_eddsa_sign (sign_key,
                            &ass,
                            &uri->data.loc.contentSignature);
  return uri;
}

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_CRYPTO_eddsa_key_get_public(), GNUNET_CRYPTO_eddsa_sign, GNUNET_FS_URI_CHK, GNUNET_FS_URI_LOC, GNUNET_new, 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().

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.

{
  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;
}

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::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, ret, and GNUNET_FS_Uri::type.

Referenced by publish_inspector().

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 987 of file fs_uri.c.

{
  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;
}

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::identifier, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, ret, GNUNET_FS_Uri::sks, and uri.

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_tree_encoder_get_uri(), GNUNET_FS_uri_ksk_merge(), process_ksk_result(), process_sks_result(), publish_sblocks_cont(), search_start(), share_tree_trim(), and unindex_directory_scan_cb().

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 1049 of file fs_uri.c.

{
  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;
}

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

Referenced by make_keywords().

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 1144 of file fs_uri.c.

{
  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 (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;
}

References GNUNET_FS_Uri::data, GNUNET_asprintf(), GNUNET_free, GNUNET_FS_URI_KSK, GNUNET_FS_uri_parse(), GNUNET_FS_URI_PREFIX, GNUNET_new, GNUNET_new_array, GNUNET_strdup, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, 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().

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 1201 of file fs_uri.c.

{
  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;
  }
}

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::identifier, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::loc, GNUNET_FS_Uri::ns, ret, GNUNET_FS_Uri::sks, and GNUNET_FS_Uri::type.

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

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 1271 of file fs_uri.c.

{
  return uri->type == GNUNET_FS_URI_SKS;
}

References GNUNET_FS_URI_SKS, GNUNET_FS_Uri::type, and uri.

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(), run(), and schedule_transmit_search_request().

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.

{
  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;
}

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

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 1286 of file fs_uri.c.

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

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

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 1306 of file fs_uri.c.

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

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

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 1324 of file fs_uri.c.

{
#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;
}

References GNUNET_FS_Uri::data, GNUNET_assert, GNUNET_FS_URI_KSK, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::keywords, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::type, and uri.

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_(), run(), and schedule_transmit_search_request().

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 1346 of file fs_uri.c.

{
  return uri->type == GNUNET_FS_URI_CHK;
}

References GNUNET_FS_URI_CHK, GNUNET_FS_Uri::type, and uri.

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

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 1360 of file fs_uri.c.

{
  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 */
}

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, GNUNET_FS_Uri::type, and uri.

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_(), match_full_data(), print_search_result(), progress_cb(), run(), trigger_recursive_download(), and try_top_down_reconstruction().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_uri_chk_get_file_hash()

const struct GNUNET_HashCode * GNUNET_FS_uri_chk_get_file_hash

(

const struct GNUNET_FS_Uri *

uri

)

What is the hash of the original file's content that this URI refers to?

Parameters

uri	the CHK URI to inspect

Returns

hash of the file as specified in the CHK URI

Definition at line 1385 of file fs_uri.c.

{
  if (GNUNET_FS_URI_CHK != uri->type)
    GNUNET_assert (0);
 
  return &(uri->data.chk.chk.key);
}

References FileIdentifier::chk, GNUNET_FS_Uri::chk, GNUNET_FS_Uri::data, GNUNET_assert, GNUNET_FS_URI_CHK, ContentHashKey::key, GNUNET_FS_Uri::type, and uri.

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 1401 of file fs_uri.c.

{
  return uri->type == GNUNET_FS_URI_LOC;
}

References GNUNET_FS_URI_LOC, GNUNET_FS_Uri::type, and uri.

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

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_FS_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 1788 of file fs_uri.c.

{
  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_FS_meta_data_iterate (md, NULL, NULL);
  if (ent > 0)
  {
    full_name = GNUNET_FS_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_FS_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 (full_name);
  return ret;
}

References DIR_SEPARATOR_STR, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, filename, gather_uri_data(), get_keywords_from_parens(), get_keywords_from_tokens(), GNUNET_free, GNUNET_FS_meta_data_get_first_by_types(), GNUNET_FS_meta_data_iterate(), GNUNET_FS_URI_KSK, GNUNET_new, GNUNET_new_array, and ret.

Referenced by process_helper_msgs().

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.

{
  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;
}

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

Referenced by main().

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_FS_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]	meta	metadata set to the desired value
	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 250 of file fs_getopt.c.

{
  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;
}

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

Referenced by main().

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_FS_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 3264 of file fs_api.c.

{
  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 = ((enum GNUNET_FS_OPTIONS) va_arg (ap, int))))
  {
    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;
}

References 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, ret, GNUNET_FS_Handle::upcb, and GNUNET_FS_Handle::upcb_cls.

Referenced by run().

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 3330 of file fs_api.c.

{
  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);
}

References GNUNET_free, GNUNET_SCHEDULER_cancel(), and h.

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

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.

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

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

GNUNET_FS_file_information_get_filename()

const char * GNUNET_FS_file_information_get_filename

(

const 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 60 of file fs_file_information.c.

{
  return s->filename;
}

References GNUNET_FS_FileInformation::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 76 of file fs_file_information.c.

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

References filename, GNUNET_FS_FileInformation::filename, GNUNET_free, and GNUNET_strdup.

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_FS_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

Definition at line 88 of file fs_file_information.c.

{
  struct FileInfo *fi;
  uint64_t fsize;
  struct GNUNET_FS_FileInformation *ret;
  const char *fn;
  const char *ss;
 
  /* 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);
  fn = filename;
  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
 */
  GNUNET_FS_meta_data_insert (ret->meta,
                              "<gnunet>",
                              EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME,
                              EXTRACTOR_METAFORMAT_C_STRING,
                              "text/plain",
                              fn,
                              strlen (fn) + 1);
  return ret;
}

References bo, GNUNET_FS_FileInformation::client_info, DIR_SEPARATOR_STR, GNUNET_FS_FileInformation::do_index, EXTRACTOR_METAFORMAT_C_STRING, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, filename, GNUNET_break, 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_FS_meta_data_insert(), GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_YES, h, GNUNET_FS_FileInformation::keywords, meta, and ret.

Referenced by get_file_information().

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_FS_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

Definition at line 148 of file fs_file_information.c.

{
  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);
}

References bo, GNUNET_FS_FileInformation::client_info, data, GNUNET_FS_FileInformation::do_index, GNUNET_break, GNUNET_FS_data_reader_copy_(), GNUNET_FS_file_information_create_from_reader(), GNUNET_YES, h, GNUNET_FS_FileInformation::keywords, and meta.

Referenced by make_file().

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_FS_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

Definition at line 177 of file fs_file_information.c.

{
  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_FS_meta_data_duplicate (meta);
  if (ret->meta == NULL)
    ret->meta = GNUNET_FS_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;
}

References bo, GNUNET_FS_FileInformation::client_info, GNUNET_FS_FileInformation::do_index, GNUNET_break, GNUNET_FS_data_reader_file_(), GNUNET_FS_meta_data_create(), GNUNET_FS_meta_data_duplicate(), GNUNET_FS_uri_dup(), GNUNET_new, GNUNET_YES, h, GNUNET_FS_FileInformation::keywords, meta, GNUNET_FS_FileInformation::reader, GNUNET_FS_FileInformation::reader_cls, and ret.

Referenced by GNUNET_FS_file_information_create_from_data(), and GNUNET_FS_file_information_create_from_file().

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_FS_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

Definition at line 226 of file fs_file_information.c.

{
  struct GNUNET_FS_FileInformation *ret;
 
  ret = GNUNET_new (struct GNUNET_FS_FileInformation);
  ret->h = h;
  ret->client_info = client_info;
  ret->meta = GNUNET_FS_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;
}

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

Referenced by get_file_information().

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 218 of file fs_file_information.c.

{
  return ent->is_directory;
}

References GNUNET_FS_FileInformation::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

Definition at line 250 of file fs_file_information.c.

{
  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;
}

References dir, GNUNET_FS_FileInformation::dir, GNUNET_break, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, and GNUNET_FS_FileInformation::next.

Referenced by get_file_information().

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 282 of file fs_file_information.c.

{
  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;
  }
}

References GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::client_info, GNUNET_FS_FileInformation::data, dir, GNUNET_FS_FileInformation::dir, GNUNET_FS_FileInformation::dir_size, GNUNET_FS_FileInformation::do_index, GNUNET_FS_FileInformation::file, GNUNET_FS_FileInformation::file_size, 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().

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 335 of file fs_file_information.c.

{
  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 (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 (fi->filename);
  GNUNET_free (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_FS_meta_data_destroy (fi->meta);
  GNUNET_free (fi->serialization);
  if (NULL != fi->te)
  {
    GNUNET_FS_tree_encoder_finish (fi->te, NULL);
    fi->te = NULL;
  }
  GNUNET_free (fi);
}

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::do_index, GNUNET_FS_FileInformation::emsg, GNUNET_FS_FileInformation::entries, GNUNET_FS_FileInformation::file, GNUNET_FS_FileInformation::file_size, GNUNET_FS_FileInformation::filename, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_FS_file_information_destroy(), GNUNET_FS_meta_data_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::reader, GNUNET_FS_FileInformation::reader_cls, GNUNET_FS_FileInformation::serialization, GNUNET_FS_FileInformation::sks_uri, and GNUNET_FS_FileInformation::te.

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

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 published 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 1443 of file fs_publish.c.

{
  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;
}

References _, GNUNET_ARM_Handle::cfg, compute_contents_size(), dsh, 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, ns, options, and ret.

Referenced by directory_trim_complete(), and start_publish().

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 published) 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 1571 of file fs_publish.c.

{
  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);
}

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, 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(), and shutdown_task().

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_FS_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 188 of file fs_publish_ksk.c.

{
  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_FS_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;
}

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

Referenced by identity_continuation(), and publish_kblocks().

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 231 of file fs_publish_ksk.c.

{
  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_FS_meta_data_destroy (pkc->meta);
  GNUNET_FS_uri_destroy (pkc->ksk_uri);
  GNUNET_FS_uri_destroy (pkc->uri);
  GNUNET_free (pkc);
}

References GNUNET_FS_PublishKskContext::dsh, GNUNET_DATASTORE_disconnect(), GNUNET_free, GNUNET_FS_meta_data_destroy(), 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().

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

Definition at line 432 of file fs_namespace.c.

{
  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_FS_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;
}

References _, bo, GNUNET_ARM_Handle::cfg, GNUNET_FS_PublishSksContext::cont, GNUNET_FS_PublishSksContext::cont_cls, GNUNET_FS_Uri::data, GNUNET_FS_PublishSksContext::dsh, GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_DATASTORE_connect(), GNUNET_FS_meta_data_duplicate(), 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, GNUNET_FS_Uri::identifier, NamespaceUpdateNode::md, meta, ns, GNUNET_FS_Uri::ns, GNUNET_FS_PublishSksContext::ns, GNUNET_FS_PublishSksContext::nsn, options, GNUNET_FS_Uri::sks, sks_publish_cont(), GNUNET_FS_Uri::type, GNUNET_FS_PublishSksContext::uc, NamespaceUpdateNode::update, uri, NamespaceUpdateNode::uri, and GNUNET_FS_PublishSksContext::uri.

Referenced by publish_sblock(), and uri_ksk_continuation().

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 495 of file fs_namespace.c.

{
  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_FS_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);
}

References GNUNET_FS_PublishSksContext::dsh, GNUNET_DATASTORE_disconnect(), GNUNET_free, GNUNET_FS_meta_data_destroy(), 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().

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)

Definition at line 163 of file fs_list_indexed.c.

{
  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;
}

References _, GNUNET_ARM_Handle::cfg, env, gic, 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, h, handlers, GNUNET_FS_GetIndexedContext::iterator, GNUNET_FS_GetIndexedContext::iterator_cls, GNUNET_FS_GetIndexedContext::mq, mq_error_handler(), and msg.

Referenced by run().

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 212 of file fs_list_indexed.c.

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

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

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

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 796 of file fs_unindex.c.

{
  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;
}

References GNUNET_FS_ProgressInfo::cctx, GNUNET_FS_UnindexContext::client_info, GNUNET_FS_UnindexContext::fhc, GNUNET_FS_UnindexContext::file_size, filename, 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().

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 838 of file fs_unindex.c.

{
  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 (uc->emsg);
  GNUNET_free (uc->filename);
  GNUNET_free (uc);
}

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_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, uc, GNUNET_FS_ProgressInfo::unindex, UNINDEX_STATE_COMPLETE, and GNUNET_FS_ProgressInfo::value.

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

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 updateable content
next_id	ID to look for; use NULL to look for SCC roots
ip	function to call on each updateable identifier
ip_cls	closure for ip

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 Tree 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 the final tree are possible (including self-loops). I know, odd definition of a tree, but the GUI will display an actual tree (GtkTreeView), so that's what counts for the term here.

Parameters

h	fs handle to use
ns	namespace to inspect for updateable content
next_id	ID to look for; use NULL to look for tree roots
ip	function to call on each updateable identifier
ip_cls	closure for ip

Definition at line 671 of file fs_namespace.c.

{
  unsigned int i;
  unsigned int nug;
  struct GNUNET_HashCode hc;
  struct NamespaceUpdateNode *nsn;
  struct ProcessUpdateClosure pc;
  struct FindTreeClosure fc;
  struct GNUNET_FS_UpdateInformationGraph *uig;
 
  uig = read_update_information_graph (h, ns);
  if (NULL == uig->update_nodes)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No updateable nodes found for ID `%s'\n",
                next_id);
    free_update_information_graph (uig);
    return;   /* no nodes */
  }
  uig->update_map =
    GNUNET_CONTAINER_multihashmap_create (2 + 3 * uig->update_node_count / 4,
                                          GNUNET_NO);
  for (i = 0; i < uig->update_node_count; i++)
  {
    nsn = uig->update_nodes[i];
    GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
    GNUNET_CONTAINER_multihashmap_put (
      uig->update_map,
      &hc,
      nsn,
      GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  }
  if (NULL != next_id)
  {
    GNUNET_CRYPTO_hash (next_id, strlen (next_id), &hc);
    pc.ip = ip;
    pc.ip_cls = ip_cls;
    GNUNET_CONTAINER_multihashmap_get_multiple (uig->update_map,
                                                &hc,
                                                &process_update_node,
                                                &pc);
    free_update_information_graph (uig);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Calculating TREEs to find roots of update trees\n");
  /* Find heads of TREEs in update graph */
  nug = ++uig->nug_gen;
  fc.tree_array = NULL;
  fc.tree_array_size = 0;
 
  for (i = 0; i < uig->update_node_count; i++)
  {
    nsn = uig->update_nodes[i];
    if (nsn->nug == nug)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "TREE of node `%s' is %u\n",
                  nsn->id,
                  nsn->nug);
      continue;     /* already placed in TREE */
    }
    GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
    nsn->nug = nug;
    nsn->tree_id = UINT_MAX;
    fc.id = UINT_MAX;
    fc.nug = nug;
    fc.uig = uig;
    GNUNET_CONTAINER_multihashmap_get_multiple (uig->update_map,
                                                &hc,
                                                &find_trees,
                                                &fc);
    if (UINT_MAX == fc.id)
    {
      /* start new TREE */
      for (fc.id = 0; fc.id < fc.tree_array_size; fc.id++)
      {
        if (NULL == fc.tree_array[fc.id])
        {
          fc.tree_array[fc.id] = nsn;
          nsn->tree_id = fc.id;
          break;
        }
      }
      if (fc.id == fc.tree_array_size)
      {
        GNUNET_array_append (fc.tree_array, fc.tree_array_size, nsn);
        nsn->tree_id = fc.id;
      }
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Starting new TREE %u with node `%s'\n",
                  nsn->tree_id,
                  nsn->id);
      /* put all nodes with same identifier into this TREE */
      GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
      fc.id = nsn->tree_id;
      fc.nug = nug;
      fc.uig = uig;
      GNUNET_CONTAINER_multihashmap_get_multiple (uig->update_map,
                                                  &hc,
                                                  &find_trees,
                                                  &fc);
    }
    else
    {
      /* make head of TREE "id" */
      fc.tree_array[fc.id] = nsn;
      nsn->tree_id = fc.id;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "TREE of node `%s' is %u\n",
                nsn->id,
                fc.id);
  }
  for (i = 0; i < fc.tree_array_size; i++)
  {
    nsn = fc.tree_array[i];
    if (NULL != nsn)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Root of TREE %u is node `%s'\n",
                  i,
                  nsn->id);
      ip (ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
    }
  }
  GNUNET_array_grow (fc.tree_array, fc.tree_array_size, 0);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done processing TREEs\n");
  free_update_information_graph (uig);
}

References find_trees(), free_update_information_graph(), GNUNET_array_append, GNUNET_array_grow, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, h, NamespaceUpdateNode::id, FindTreeClosure::id, NamespaceUpdateNode::md, next_id, ns, NamespaceUpdateNode::nug, FindTreeClosure::nug, GNUNET_FS_UpdateInformationGraph::nug_gen, pc, process_update_node(), read_update_information_graph(), FindTreeClosure::tree_array, FindTreeClosure::tree_array_size, NamespaceUpdateNode::tree_id, FindTreeClosure::uig, NamespaceUpdateNode::update, GNUNET_FS_UpdateInformationGraph::update_map, GNUNET_FS_UpdateInformationGraph::update_node_count, GNUNET_FS_UpdateInformationGraph::update_nodes, and NamespaceUpdateNode::uri.

Here is the call graph for this function:

GNUNET_FS_search_start()

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.

Parameters

h	handle to the file sharing subsystem
uri	specifies the search parameters; can be a KSK URI or an SKS URI.
anonymity	desired level of anonymity
options	options for the search
cctx	initial value for the client context

Returns

context that can be used to control the search

Definition at line 1607 of file fs_search.c.

{
  struct GNUNET_FS_SearchContext *ret;
 
  ret = search_start (h, uri, anonymity, options, cctx, NULL);
  if (NULL == ret)
    return NULL;
  ret->top = GNUNET_FS_make_top (h, &GNUNET_FS_search_signal_suspend_, ret);
  return ret;
}

References anonymity, GNUNET_FS_make_top(), GNUNET_FS_search_signal_suspend_(), h, options, ret, search_start(), and uri.

Referenced by run(), and start_download().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_pause()

void GNUNET_FS_search_pause

(

struct GNUNET_FS_SearchContext *

sc

)

Pause search.

Parameters

sc	context for the search that should be paused

Definition at line 1627 of file fs_search.c.

{
  struct GNUNET_FS_ProgressInfo pi;
 
  if (NULL != sc->task)
  {
    GNUNET_SCHEDULER_cancel (sc->task);
    sc->task = NULL;
  }
  if (NULL != sc->mq)
  {
    GNUNET_MQ_destroy (sc->mq);
    sc->mq = NULL;
  }
  GNUNET_FS_search_sync_ (sc);
  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                         &search_result_freeze_probes,
                                         sc);
  pi.status = GNUNET_FS_STATUS_SEARCH_PAUSED;
  sc->client_info = GNUNET_FS_search_make_status_ (&pi,
                                                   sc->h,
                                                   sc);
}

References GNUNET_FS_SearchContext::client_info, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_FS_search_make_status_(), GNUNET_FS_search_sync_(), GNUNET_FS_STATUS_SEARCH_PAUSED, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_FS_SearchContext::h, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, sc, search_result_freeze_probes(), GNUNET_FS_ProgressInfo::status, and GNUNET_FS_SearchContext::task.

Referenced by search_result_freeze_probes().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_continue()

void GNUNET_FS_search_continue

(

struct GNUNET_FS_SearchContext *

sc

)

Continue paused search.

Parameters

sc	context for the search that should be resumed

Definition at line 1658 of file fs_search.c.

{
  struct GNUNET_FS_ProgressInfo pi;
 
  GNUNET_assert (NULL == sc->mq);
  GNUNET_assert (NULL == sc->task);
  do_reconnect (sc);
  GNUNET_FS_search_sync_ (sc);
  pi.status = GNUNET_FS_STATUS_SEARCH_CONTINUED;
  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                         &search_result_resume_probes, sc);
}

References GNUNET_FS_SearchContext::client_info, do_reconnect(), GNUNET_assert, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_FS_search_make_status_(), GNUNET_FS_search_sync_(), GNUNET_FS_STATUS_SEARCH_CONTINUED, GNUNET_FS_SearchContext::h, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, sc, search_result_resume_probes(), GNUNET_FS_ProgressInfo::status, and GNUNET_FS_SearchContext::task.

Referenced by search_result_resume_probes().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_search_stop()

void GNUNET_FS_search_stop

(

struct GNUNET_FS_SearchContext *

sc

)

Stop search for content.

Parameters

sc	context for the search that should be stopped

Definition at line 1766 of file fs_search.c.

{
  struct GNUNET_FS_ProgressInfo pi;
  unsigned int i;
 
  if (NULL != sc->top)
    GNUNET_FS_end_top (sc->h, sc->top);
  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                         &search_result_stop,
                                         sc);
  if (NULL != sc->psearch_result)
    sc->psearch_result->update_search = NULL;
  if (NULL != sc->serialization)
  {
    GNUNET_FS_remove_sync_file_ (sc->h,
                                 (NULL != sc->psearch_result)
                                 ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH
                                 : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
                                 sc->serialization);
    GNUNET_FS_remove_sync_dir_ (sc->h,
                                (NULL != sc->psearch_result)
                                ? GNUNET_FS_SYNC_PATH_CHILD_SEARCH
                                : GNUNET_FS_SYNC_PATH_MASTER_SEARCH,
                                sc->serialization);
    GNUNET_free (sc->serialization);
  }
  pi.status = GNUNET_FS_STATUS_SEARCH_STOPPED;
  sc->client_info = GNUNET_FS_search_make_status_ (&pi,
                                                   sc->h,
                                                   sc);
  GNUNET_break (NULL == sc->client_info);
  if (NULL != sc->task)
  {
    GNUNET_SCHEDULER_cancel (sc->task);
    sc->task = NULL;
  }
  if (NULL != sc->mq)
  {
    GNUNET_MQ_destroy (sc->mq);
    sc->mq = NULL;
  }
  GNUNET_CONTAINER_multihashmap_iterate (sc->master_result_map,
                                         &search_result_free, sc);
  GNUNET_CONTAINER_multihashmap_destroy (sc->master_result_map);
  if (NULL != sc->requests)
  {
    GNUNET_assert (GNUNET_FS_uri_test_ksk (sc->uri));
    for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
    {
      GNUNET_CONTAINER_multihashmap_destroy (sc->requests[i].results);
      GNUNET_free (sc->requests[i].keyword);
    }
  }
  GNUNET_free (sc->requests);
  GNUNET_free (sc->emsg);
  GNUNET_FS_uri_destroy (sc->uri);
  GNUNET_free (sc);
}

References GNUNET_FS_SearchContext::client_info, GNUNET_FS_Uri::data, GNUNET_FS_SearchContext::emsg, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_free, GNUNET_FS_end_top(), GNUNET_FS_remove_sync_dir_(), GNUNET_FS_remove_sync_file_(), GNUNET_FS_search_make_status_(), GNUNET_FS_STATUS_SEARCH_STOPPED, GNUNET_FS_SYNC_PATH_CHILD_SEARCH, GNUNET_FS_SYNC_PATH_MASTER_SEARCH, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_test_ksk(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_FS_SearchContext::h, SearchRequestEntry::keyword, GNUNET_FS_Uri::keywordCount, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::psearch_result, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, search_result_free(), search_result_stop(), GNUNET_FS_SearchContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchContext::task, GNUNET_FS_SearchContext::top, GNUNET_FS_SearchResult::update_search, and GNUNET_FS_SearchContext::uri.

Referenced by search_result_free(), search_stop_task(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_probe()

struct GNUNET_FS_SearchResult * GNUNET_FS_probe	(	struct GNUNET_FS_Handle *	h,
		const struct GNUNET_FS_Uri *	uri,
		const struct GNUNET_FS_MetaData *	meta,
		void *	client_info,
		uint32_t	anonymity
	)

Start download probes for the given search result.

Parameters

h	file-sharing handle to use for the operation
uri	URI to probe
meta	meta data associated with the URI
client_info	client info pointer to use for associated events
anonymity	anonymity level to use for the probes

Returns

the search result handle to access the probe activity

Definition at line 489 of file fs_search.c.

{
  struct GNUNET_FS_SearchResult *sr;
 
  GNUNET_assert (NULL != h);
  GNUNET_assert (NULL != uri);
  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
  sr->h = h;
  sr->uri = GNUNET_FS_uri_dup (uri);
  sr->meta = GNUNET_FS_meta_data_duplicate (meta);
  sr->client_info = client_info;
  sr->anonymity = anonymity;
  GNUNET_FS_search_start_probe_ (sr);
  return sr;
}

References anonymity, GNUNET_FS_SearchResult::anonymity, GNUNET_FS_SearchResult::client_info, GNUNET_assert, GNUNET_FS_meta_data_duplicate(), GNUNET_FS_search_start_probe_(), GNUNET_FS_uri_dup(), GNUNET_new, h, GNUNET_FS_SearchResult::h, meta, GNUNET_FS_SearchResult::meta, uri, and GNUNET_FS_SearchResult::uri.

Here is the call graph for this function:

GNUNET_FS_probe_stop()

void * GNUNET_FS_probe_stop

(

struct GNUNET_FS_SearchResult *

sr

)

Stop probe activity.

Must ONLY be used on values returned from GNUNET_FS_probe.

Parameters

sr	search result to stop probing for (freed)

Returns

the value of the 'client_info' pointer

Definition at line 540 of file fs_search.c.

{
  void *client_info;
 
  GNUNET_assert (NULL == sr->sc);
  GNUNET_FS_search_stop_probe_ (sr);
  GNUNET_FS_uri_destroy (sr->uri);
  GNUNET_FS_meta_data_destroy (sr->meta);
  client_info = sr->client_info;
  GNUNET_free (sr);
  return client_info;
}

References GNUNET_FS_SearchResult::client_info, GNUNET_assert, GNUNET_free, GNUNET_FS_meta_data_destroy(), GNUNET_FS_search_stop_probe_(), GNUNET_FS_uri_destroy(), GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::sc, and GNUNET_FS_SearchResult::uri.

Here is the call graph for this function:

GNUNET_FS_download_start()

struct GNUNET_FS_DownloadContext * GNUNET_FS_download_start	(	struct GNUNET_FS_Handle *	h,
		const struct GNUNET_FS_Uri *	uri,
		const struct GNUNET_FS_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.

Note that this will store the blocks at the respective offset in the given file. Also, the download is still using the blocking of the underlying FS encoding. As a result, the download may write outside of the given boundaries (if offset and length do not match the 32k FS block boundaries).

The given range can be used to focus a download towards a particular portion of the file (optimization), not to strictly limit the download to exactly those bytes.

Parameters

h	handle to the file sharing subsystem
uri	the URI of the file (determines what to download); CHK or LOC URI
meta	known metadata for the file (can be NULL)
filename	where to store the file, maybe NULL (then no file is created on disk and data must be grabbed from the callbacks)
tempname	where to store temporary file data, not used if filename is non-NULL; can be NULL (in which case we will pick a name if needed); the temporary file may already exist, in which case we will try to use the data that is there and if it is not what is desired, will overwrite it
offset	at what offset should we start the download (typically 0)
length	how many bytes should be downloaded starting at offset
anonymity	anonymity level to use for the download
options	various download options
cctx	initial value for the client context for this download
parent	parent download to associate this download with (use NULL for top-level downloads; useful for manually-triggered recursive downloads)

Returns

context that can be used to control this download

Definition at line 2099 of file fs_download.c.

{
  struct GNUNET_FS_DownloadContext *dc;
 
  dc = create_download_context (h,
                                uri,
                                meta,
                                filename,
                                tempname,
                                offset,
                                length,
                                anonymity,
                                options,
                                cctx);
  if (NULL == dc)
    return NULL;
  dc->parent = parent;
  if (NULL != parent)
    GNUNET_CONTAINER_DLL_insert (parent->child_head, parent->child_tail, dc);
  else if (0 == (GNUNET_FS_DOWNLOAD_IS_PROBE & options))
    dc->top =
      GNUNET_FS_make_top (dc->h, &GNUNET_FS_download_signal_suspend_, dc);
  return dc;
}

References anonymity, GNUNET_FS_DownloadContext::child_head, GNUNET_FS_DownloadContext::child_tail, create_download_context(), dc, filename, GNUNET_CONTAINER_DLL_insert, GNUNET_FS_DOWNLOAD_IS_PROBE, GNUNET_FS_download_signal_suspend_(), GNUNET_FS_make_top(), h, GNUNET_FS_DownloadContext::h, GNUNET_FS_DownloadContext::length, meta, GNUNET_FS_DownloadContext::offset, options, GNUNET_FS_DownloadContext::parent, GNUNET_FS_DownloadContext::top, and uri.

Referenced by GNUNET_FS_search_start_probe_(), progress_cb(), run(), and trigger_recursive_download().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_download_start_from_search()

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.

The download will be associated with the search result (and the association will be preserved when serializing/deserializing the state). If the search is stopped, the download will not be aborted but be 'promoted' to a stand-alone download.

As with the other download function, this will store the blocks at the respective offset in the given file. Also, the download is still using the blocking of the underlying FS encoding. As a result, the download may write outside of the given boundaries (if offset and length do not match the 32k FS block boundaries).

The given range can be used to focus a download towards a particular portion of the file (optimization), not to strictly limit the download to exactly those bytes.

Parameters

h	handle to the file sharing subsystem
sr	the search result to use for the download (determines uri and meta data and associations)
filename	where to store the file, maybe NULL (then no file is created on disk and data must be grabbed from the callbacks)
tempname	where to store temporary file data, not used if filename is non-NULL; can be NULL (in which case we will pick a name if needed); the temporary file may already exist, in which case we will try to use the data that is there and if it is not what is desired, will overwrite it
offset	at what offset should we start the download (typically 0)
length	how many bytes should be downloaded starting at offset
anonymity	anonymity level to use for the download
options	various download options
cctx	initial value for the client context for this download

Returns

context that can be used to control this download

Definition at line 2136 of file fs_download.c.

{
  struct GNUNET_FS_DownloadContext *dc;
 
  if ((NULL == sr) || (NULL != sr->download))
  {
    GNUNET_break (0);
    return NULL;
  }
  dc = create_download_context (h,
                                sr->uri,
                                sr->meta,
                                filename,
                                tempname,
                                offset,
                                length,
                                anonymity,
                                options,
                                cctx);
  if (NULL == dc)
    return NULL;
  dc->search = sr;
  sr->download = dc;
  if (NULL != sr->probe_ctx)
  {
    GNUNET_FS_download_stop (sr->probe_ctx, GNUNET_YES);
    sr->probe_ctx = NULL;
    GNUNET_FS_stop_probe_ping_task_ (sr);
  }
  return dc;
}

References anonymity, create_download_context(), dc, GNUNET_FS_SearchResult::download, filename, GNUNET_break, GNUNET_FS_download_stop(), GNUNET_FS_stop_probe_ping_task_(), GNUNET_YES, h, GNUNET_FS_DownloadContext::length, GNUNET_FS_SearchResult::meta, GNUNET_FS_DownloadContext::offset, options, GNUNET_FS_SearchResult::probe_ctx, GNUNET_FS_DownloadContext::search, and GNUNET_FS_SearchResult::uri.

Here is the call graph for this function:

GNUNET_FS_download_stop()

void GNUNET_FS_download_stop	(	struct GNUNET_FS_DownloadContext *	dc,
		int	do_delete
	)

Stop a download (aborts if download is incomplete).

Parameters

dc	handle for the download
do_delete	delete files of incomplete downloads

Definition at line 2253 of file fs_download.c.

{
  struct GNUNET_FS_ProgressInfo pi;
  int have_children;
  int search_was_null;
 
  if (NULL != dc->top)
    GNUNET_FS_end_top (dc->h, dc->top);
  if (NULL != dc->task)
  {
    GNUNET_SCHEDULER_cancel (dc->task);
    dc->task = NULL;
  }
  search_was_null = (NULL == dc->search);
  if (NULL != dc->search)
  {
    dc->search->download = NULL;
    GNUNET_FS_search_result_sync_ (dc->search);
    dc->search = NULL;
  }
  if (NULL != dc->job_queue)
  {
    GNUNET_FS_dequeue_ (dc->job_queue);
    dc->job_queue = NULL;
  }
  if (NULL != dc->te)
  {
    GNUNET_FS_tree_encoder_finish (dc->te, NULL);
    dc->te = NULL;
  }
  have_children = (NULL != dc->child_head) ? GNUNET_YES : GNUNET_NO;
  while (NULL != dc->child_head)
    GNUNET_FS_download_stop (dc->child_head, do_delete);
  if (NULL != dc->parent)
    GNUNET_CONTAINER_DLL_remove (dc->parent->child_head,
                                 dc->parent->child_tail,
                                 dc);
  if (NULL != dc->serialization)
    GNUNET_FS_remove_sync_file_ (dc->h,
                                 ((NULL != dc->parent) || (! search_was_null))
                                 ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
                                 : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
                                 dc->serialization);
  if ((GNUNET_YES == have_children) && (NULL == dc->parent))
    GNUNET_FS_remove_sync_dir_ (dc->h,
                                (! search_was_null)
                                ? GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD
                                : GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD,
                                dc->serialization);
  pi.status = GNUNET_FS_STATUS_DOWNLOAD_STOPPED;
  GNUNET_FS_download_make_status_ (&pi, dc);
  GNUNET_FS_free_download_request_ (dc->top_request);
  dc->top_request = NULL;
  if (NULL != dc->active)
  {
    GNUNET_CONTAINER_multihashmap_destroy (dc->active);
    dc->active = NULL;
  }
  if (NULL != dc->filename)
  {
    if ((dc->completed != dc->length) && (GNUNET_YES == do_delete))
    {
      if ((0 != unlink (dc->filename)) && (ENOENT != errno))
        GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
                                  "unlink",
                                  dc->filename);
    }
    GNUNET_free (dc->filename);
  }
  GNUNET_FS_meta_data_destroy (dc->meta);
  GNUNET_FS_uri_destroy (dc->uri);
  if (NULL != dc->temp_filename)
  {
    if (0 != unlink (dc->temp_filename))
      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                "unlink",
                                dc->temp_filename);
    GNUNET_free (dc->temp_filename);
  }
  GNUNET_free (dc->serialization);
  GNUNET_assert (NULL == dc->job_queue);
  GNUNET_free (dc);
}

References GNUNET_FS_DownloadContext::active, GNUNET_FS_DownloadContext::child_head, GNUNET_FS_DownloadContext::child_tail, GNUNET_FS_DownloadContext::completed, dc, GNUNET_FS_SearchResult::download, GNUNET_FS_DownloadContext::filename, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_FS_dequeue_(), GNUNET_FS_download_make_status_(), GNUNET_FS_download_stop(), GNUNET_FS_end_top(), GNUNET_FS_free_download_request_(), GNUNET_FS_meta_data_destroy(), GNUNET_FS_remove_sync_dir_(), GNUNET_FS_remove_sync_file_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_STATUS_DOWNLOAD_STOPPED, GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD, GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD, GNUNET_FS_tree_encoder_finish(), GNUNET_FS_uri_destroy(), GNUNET_log_strerror_file, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_FS_DownloadContext::h, GNUNET_FS_DownloadContext::job_queue, GNUNET_FS_DownloadContext::length, GNUNET_FS_DownloadContext::meta, GNUNET_FS_DownloadContext::parent, GNUNET_FS_DownloadContext::search, GNUNET_FS_DownloadContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_DownloadContext::task, GNUNET_FS_DownloadContext::te, GNUNET_FS_DownloadContext::temp_filename, GNUNET_FS_DownloadContext::top, GNUNET_FS_DownloadContext::top_request, and GNUNET_FS_DownloadContext::uri.

Referenced by download_stop_task(), GNUNET_FS_download_start_from_search(), GNUNET_FS_download_stop(), GNUNET_FS_search_stop_probe_(), probe_failure_handler(), probe_success_handler(), search_result_freeze_probes(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_download_suspend()

void GNUNET_FS_download_suspend

(

struct GNUNET_FS_DownloadContext *

dc

)

Suspend a download.

Parameters

dc	handle for the download

Definition at line 2214 of file fs_download.c.

{
  deactivate_fs_download (dc);
}

References dc, and deactivate_fs_download().

Here is the call graph for this function:

GNUNET_FS_download_resume()

void GNUNET_FS_download_resume

(

struct GNUNET_FS_DownloadContext *

dc

)

Resume a suspended download.

Parameters

dc	handle for the download

Definition at line 2226 of file fs_download.c.

{
  struct GNUNET_FS_ProgressInfo pi;
 
  pi.status = GNUNET_FS_STATUS_DOWNLOAD_ACTIVE;
  GNUNET_FS_download_make_status_ (&pi, dc);
 
  GNUNET_assert (NULL == dc->task);
  dc->job_queue =
    GNUNET_FS_queue_ (dc->h,
                      &activate_fs_download,
                      &deactivate_fs_download,
                      dc,
                      (dc->length + DBLOCK_SIZE - 1) / DBLOCK_SIZE,
                      (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
                      ? GNUNET_FS_QUEUE_PRIORITY_NORMAL
                      : GNUNET_FS_QUEUE_PRIORITY_PROBE);
}

References activate_fs_download(), DBLOCK_SIZE, dc, deactivate_fs_download(), GNUNET_assert, GNUNET_FS_DOWNLOAD_IS_PROBE, GNUNET_FS_download_make_status_(), GNUNET_FS_queue_(), GNUNET_FS_QUEUE_PRIORITY_NORMAL, GNUNET_FS_QUEUE_PRIORITY_PROBE, GNUNET_FS_STATUS_DOWNLOAD_ACTIVE, GNUNET_FS_DownloadContext::h, GNUNET_FS_DownloadContext::job_queue, GNUNET_FS_DownloadContext::length, GNUNET_FS_DownloadContext::options, GNUNET_FS_ProgressInfo::status, and GNUNET_FS_DownloadContext::task.

Here is the call graph for this function:

GNUNET_FS_meta_data_test_for_directory()

int GNUNET_FS_meta_data_test_for_directory

(

const struct GNUNET_FS_MetaData *

md

)

Does the meta-data claim that this is a directory? Checks if the mime-type is that of a GNUnet directory.

Returns

GNUNET_YES if it is, GNUNET_NO if it is not, GNUNET_SYSERR if we have no mime-type information (treat as GNUNET_NO)

Definition at line 55 of file fs_directory.c.

{
  char *mime;
  int ret;
 
  if (NULL == md)
    return GNUNET_SYSERR;
  mime = GNUNET_FS_meta_data_get_by_type (md,
                                          EXTRACTOR_METATYPE_MIMETYPE);
  if (NULL == mime)
    return GNUNET_SYSERR;
  ret = (0 == strcasecmp (mime, GNUNET_FS_DIRECTORY_MIME)) ? GNUNET_YES :
        GNUNET_NO;
  GNUNET_free (mime);
  return ret;
}

References EXTRACTOR_METATYPE_MIMETYPE, GNUNET_free, GNUNET_FS_DIRECTORY_MIME, GNUNET_FS_meta_data_get_by_type(), GNUNET_NO, GNUNET_SYSERR, GNUNET_YES, and ret.

Referenced by fip_signal_resume(), fip_signal_stop(), fip_signal_suspend(), is_recursive_download(), progress_cb(), publish_inspector(), and trigger_recursive_download().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_make_directory()

void GNUNET_FS_meta_data_make_directory

(

struct GNUNET_FS_MetaData *

md

)

Set the MIMETYPE information for the given metadata to "application/gnunet-directory".

Parameters

md	metadata to add mimetype to

Definition at line 81 of file fs_directory.c.

{
  char *mime;
 
  mime =
    GNUNET_FS_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
  if (mime != NULL)
  {
    GNUNET_break (0 == strcmp (mime, GNUNET_FS_DIRECTORY_MIME));
    GNUNET_free (mime);
    return;
  }
  GNUNET_FS_meta_data_insert (md, "<gnunet>",
                                     EXTRACTOR_METATYPE_MIMETYPE,
                                     EXTRACTOR_METAFORMAT_UTF8, "text/plain",
                                     GNUNET_FS_DIRECTORY_MIME,
                                     strlen (GNUNET_FS_DIRECTORY_MIME) + 1);
}

References EXTRACTOR_METAFORMAT_UTF8, EXTRACTOR_METATYPE_MIMETYPE, GNUNET_break, GNUNET_free, GNUNET_FS_DIRECTORY_MIME, GNUNET_FS_meta_data_get_by_type(), and GNUNET_FS_meta_data_insert().

Referenced by get_file_information(), and GNUNET_FS_directory_builder_create().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_meta_data_suggest_filename()

char * GNUNET_FS_meta_data_suggest_filename

(

const struct GNUNET_FS_MetaData *

md

)

Suggest a filename based on given metadata.

Parameters

md	given meta data

Returns

NULL if meta data is useless for suggesting a filename

Definition at line 39 of file fs_misc.c.

{
  static const char *mimeMap[][2] = {
    { "application/bz2", ".bz2" },
    { "application/gnunet-directory", ".gnd" },
    { "application/java", ".class" },
    { "application/msword", ".doc" },
    { "application/nar", ".nar" },
    { "application/narinfo", ".narinfo" },
    { "application/ogg", ".ogg" },
    { "application/pdf", ".pdf" },
    { "application/pgp-keys", ".key" },
    { "application/pgp-signature", ".pgp" },
    { "application/postscript", ".ps" },
    { "application/rar", ".rar" },
    { "application/rtf", ".rtf" },
    { "application/xml", ".xml" },
    { "application/x-debian-package", ".deb" },
    { "application/x-dvi", ".dvi" },
    { "application/x-flac", ".flac" },
    { "application/x-gzip", ".gz" },
    { "application/x-java-archive", ".jar" },
    { "application/x-java-vm", ".class" },
    { "application/x-python-code", ".pyc" },
    { "application/x-redhat-package-manager", ".rpm" },
    { "application/x-rpm", ".rpm" },
    { "application/x-tar", ".tar" },
    { "application/x-tex-pk", ".pk" },
    { "application/x-texinfo", ".texinfo" },
    { "application/x-xcf", ".xcf" },
    { "application/x-xfig", ".xfig" },
    { "application/zip", ".zip" },
 
    { "audio/midi", ".midi" },
    { "audio/mpeg", ".mp3" },
    { "audio/real", ".rm" },
    { "audio/x-wav", ".wav" },
 
    { "image/gif", ".gif" },
    { "image/jpeg", ".jpg" },
    { "image/pcx", ".pcx" },
    { "image/png", ".png" },
    { "image/tiff", ".tiff" },
    { "image/x-ms-bmp", ".bmp" },
    { "image/x-xpixmap", ".xpm" },
 
    { "text/css", ".css" },
    { "text/html", ".html" },
    { "text/plain", ".txt" },
    { "text/rtf", ".rtf" },
    { "text/x-c++hdr", ".h++" },
    { "text/x-c++src", ".c++" },
    { "text/x-chdr", ".h" },
    { "text/x-csrc", ".c" },
    { "text/x-java", ".java" },
    { "text/x-moc", ".moc" },
    { "text/x-pascal", ".pas" },
    { "text/x-perl", ".pl" },
    { "text/x-python", ".py" },
    { "text/x-tex", ".tex" },
 
    { "video/avi", ".avi" },
    { "video/mpeg", ".mpeg" },
    { "video/quicktime", ".qt" },
    { "video/real", ".rm" },
    { "video/x-msvideo", ".avi" },
    { NULL, NULL },
  };
  char *ret;
  unsigned int i;
  char *mime;
  char *base;
  const char *ext;
 
  ret =
    GNUNET_FS_meta_data_get_by_type (md,
                                     EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
  if (ret != NULL)
    return ret;
  ext = NULL;
  mime =
    GNUNET_FS_meta_data_get_by_type (md, EXTRACTOR_METATYPE_MIMETYPE);
  if (mime != NULL)
  {
    i = 0;
    while ((mimeMap[i][0] != NULL) && (0 != strcmp (mime, mimeMap[i][0])))
      i++;
    if (mimeMap[i][1] == NULL)
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG | GNUNET_ERROR_TYPE_BULK,
                  _ ("Did not find mime type `%s' in extension list.\n"), mime);
    else
      ext = mimeMap[i][1];
    GNUNET_free (mime);
  }
  base =
    GNUNET_FS_meta_data_get_first_by_types (md,
                                            EXTRACTOR_METATYPE_TITLE,
                                            EXTRACTOR_METATYPE_BOOK_TITLE,
                                            EXTRACTOR_METATYPE_ORIGINAL_TITLE,
                                            EXTRACTOR_METATYPE_PACKAGE_NAME,
                                            EXTRACTOR_METATYPE_URL,
                                            EXTRACTOR_METATYPE_URI,
                                            EXTRACTOR_METATYPE_DESCRIPTION,
                                            EXTRACTOR_METATYPE_ISRC,
                                            EXTRACTOR_METATYPE_JOURNAL_NAME,
                                            EXTRACTOR_METATYPE_AUTHOR_NAME,
                                            EXTRACTOR_METATYPE_SUBJECT,
                                            EXTRACTOR_METATYPE_ALBUM,
                                            EXTRACTOR_METATYPE_ARTIST,
                                            EXTRACTOR_METATYPE_KEYWORDS,
                                            EXTRACTOR_METATYPE_COMMENT,
                                            EXTRACTOR_METATYPE_UNKNOWN,
                                            -1);
  if ((base == NULL) && (ext == NULL))
    return NULL;
  if (base == NULL)
    return GNUNET_strdup (ext);
  if (ext == NULL)
    return base;
  GNUNET_asprintf (&ret, "%s%s", base, ext);
  GNUNET_free (base);
  return ret;
}

References _, EXTRACTOR_METATYPE_ALBUM, EXTRACTOR_METATYPE_ARTIST, EXTRACTOR_METATYPE_AUTHOR_NAME, EXTRACTOR_METATYPE_BOOK_TITLE, EXTRACTOR_METATYPE_COMMENT, EXTRACTOR_METATYPE_DESCRIPTION, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, EXTRACTOR_METATYPE_ISRC, EXTRACTOR_METATYPE_JOURNAL_NAME, EXTRACTOR_METATYPE_KEYWORDS, EXTRACTOR_METATYPE_MIMETYPE, EXTRACTOR_METATYPE_ORIGINAL_TITLE, EXTRACTOR_METATYPE_PACKAGE_NAME, EXTRACTOR_METATYPE_SUBJECT, EXTRACTOR_METATYPE_TITLE, EXTRACTOR_METATYPE_UNKNOWN, EXTRACTOR_METATYPE_URI, EXTRACTOR_METATYPE_URL, GNUNET_asprintf(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_FS_meta_data_get_by_type(), GNUNET_FS_meta_data_get_first_by_types(), GNUNET_log, GNUNET_strdup, and ret.

Referenced by trigger_recursive_download().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_directory_list_contents()

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.

Note that directories are structured such that it is possible to iterate over the individual blocks as well as over the entire directory. Thus a client can call this function on the buffer in the GNUNET_FS_ProgressCallback. Also, directories can optionally include the contents of (small) files embedded in the directory itself; for those files, the processor may be given the contents of the file directly by this function.

Parameters

size	number of bytes in data
data	pointer to the beginning of the directory
offset	offset of data in the directory
dep	function to call on each entry
dep_cls	closure for dep

Returns

GNUNET_OK if this could be a block in a directory, GNUNET_NO if this could be part of a directory (but not 100% OK) GNUNET_SYSERR if 'data' does not represent a directory

Note that directories are structured such that it is possible to iterate over the individual blocks as well as over the entire directory. Thus a client can call this function on the buffer in the GNUNET_FS_ProgressCallback. Also, directories can optionally include the contents of (small) files embedded in the directory itself; for those files, the processor may be given the contents of the file directly by this function.

Note that this function maybe called on parts of directories. Thus parser errors should not be reported at all (with GNUNET_break). Still, if some entries can be recovered despite these parsing errors, the function should try to do this.

Parameters

size	number of bytes in data
data	pointer to the beginning of the directory
offset	offset of data in the directory
dep	function to call on each entry
dep_cls	closure for dep

Returns

GNUNET_OK if this could be a block in a directory, GNUNET_NO if this could be part of a directory (but not 100% OK) GNUNET_SYSERR if data does not represent a directory

Definition at line 182 of file fs_directory.c.

{
  struct GetFullDataClosure full_data;
  const char *cdata = data;
  char *emsg;
  uint64_t pos;
  uint64_t align;
  uint32_t mdSize;
  uint64_t epos;
  struct GNUNET_FS_Uri *uri;
  struct GNUNET_FS_MetaData *md;
  char *filename;
 
  if ((offset == 0) &&
      ((size < 8 + sizeof(uint32_t)) ||
       (0 != memcmp (cdata,
                     GNUNET_FS_DIRECTORY_MAGIC,
                     8))))
    return GNUNET_SYSERR;
  pos = offset;
  if (offset == 0)
  {
    GNUNET_memcpy (&mdSize,
                   &cdata[8],
                   sizeof(uint32_t));
    mdSize = ntohl (mdSize);
    if (mdSize > size - 8 - sizeof(uint32_t))
    {
      /* invalid size */
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ ("MAGIC mismatch.  This is not a GNUnet directory.\n"));
      return GNUNET_SYSERR;
    }
    md = GNUNET_FS_meta_data_deserialize (&cdata[8 + sizeof(uint32_t)],
                                          mdSize);
    if (md == NULL)
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;     /* malformed ! */
    }
    dep (dep_cls,
         NULL,
         NULL,
         md,
         0,
         NULL);
    GNUNET_FS_meta_data_destroy (md);
    pos = 8 + sizeof(uint32_t) + mdSize;
  }
  while (pos < size)
  {
    /* find end of URI */
    if (cdata[pos] == '\0')
    {
      /* URI is never empty, must be end of block,
       * skip to next alignment */
      align = ((pos / DBLOCK_SIZE) + 1) * DBLOCK_SIZE;
      if (align == pos)
      {
        /* if we were already aligned, still skip a block! */
        align += DBLOCK_SIZE;
      }
      pos = align;
      if (pos >= size)
      {
        /* malformed - or partial download... */
        break;
      }
    }
    epos = pos;
    while ((epos < size) && (cdata[epos] != '\0'))
      epos++;
    if (epos >= size)
      return GNUNET_NO;         /* malformed - or partial download */
 
    uri = GNUNET_FS_uri_parse (&cdata[pos], &emsg);
    pos = epos + 1;
    if (NULL == uri)
    {
      GNUNET_free (emsg);
      pos--;                    /* go back to '\0' to force going to next alignment */
      continue;
    }
    if (GNUNET_FS_uri_test_ksk (uri))
    {
      GNUNET_FS_uri_destroy (uri);
      GNUNET_break (0);
      return GNUNET_NO;         /* illegal in directory! */
    }
 
    GNUNET_memcpy (&mdSize,
                   &cdata[pos],
                   sizeof(uint32_t));
    mdSize = ntohl (mdSize);
    pos += sizeof(uint32_t);
    if (pos + mdSize > size)
    {
      GNUNET_FS_uri_destroy (uri);
      return GNUNET_NO;         /* malformed - or partial download */
    }
 
    md = GNUNET_FS_meta_data_deserialize (&cdata[pos],
                                                 mdSize);
    if (NULL == md)
    {
      GNUNET_FS_uri_destroy (uri);
      GNUNET_break (0);
      return GNUNET_NO;         /* malformed ! */
    }
    pos += mdSize;
    filename =
      GNUNET_FS_meta_data_get_by_type (md,
                                              EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
    full_data.size = 0;
    full_data.data = NULL;
    GNUNET_FS_meta_data_iterate (md,
                                        &find_full_data,
                                        &full_data);
    if (NULL != dep)
    {
      dep (dep_cls,
           filename,
           uri,
           md,
           full_data.size,
           full_data.data);
    }
    GNUNET_free (full_data.data);
    GNUNET_free (filename);
    GNUNET_FS_meta_data_destroy (md);
    GNUNET_FS_uri_destroy (uri);
  }
  return GNUNET_OK;
}

References _, data, GetFullDataClosure::data, DBLOCK_SIZE, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, filename, find_full_data(), GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_FS_DIRECTORY_MAGIC, GNUNET_FS_meta_data_deserialize(), GNUNET_FS_meta_data_destroy(), GNUNET_FS_meta_data_get_by_type(), GNUNET_FS_meta_data_iterate(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_parse(), GNUNET_FS_uri_test_ksk(), GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, size, GetFullDataClosure::size, and uri.

Referenced by full_recursive_download(), process_result_with_request(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_directory_builder_create()

struct GNUNET_FS_DirectoryBuilder * GNUNET_FS_directory_builder_create

(

const struct GNUNET_FS_MetaData *

mdir

)

Create a directory builder.

Parameters

mdir	metadata for the directory

Definition at line 366 of file fs_directory.c.

{
  struct GNUNET_FS_DirectoryBuilder *ret;
 
  ret = GNUNET_new (struct GNUNET_FS_DirectoryBuilder);
  if (mdir != NULL)
    ret->meta = GNUNET_FS_meta_data_duplicate (mdir);
  else
    ret->meta = GNUNET_FS_meta_data_create ();
  GNUNET_FS_meta_data_make_directory (ret->meta);
  return ret;
}

References GNUNET_FS_meta_data_create(), GNUNET_FS_meta_data_duplicate(), GNUNET_FS_meta_data_make_directory(), GNUNET_new, and ret.

Referenced by publish_content(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_directory_builder_add()

void GNUNET_FS_directory_builder_add	(	struct GNUNET_FS_DirectoryBuilder *	bld,
		const struct GNUNET_FS_Uri *	uri,
		const struct GNUNET_FS_MetaData *	md,
		const void *	data
	)

Add an entry to a directory.

Parameters

bld	directory to extend
uri	uri of the entry (must not be a KSK)
md	metadata of the entry
data	raw data of the entry, can be NULL, otherwise data must point to exactly the number of bytes specified by the uri
bld	directory to extend
uri	uri of the entry (must not be a KSK)
md	metadata of the entry
data	raw data of the entry, can be NULL, otherwise data must point to exactly the number of bytes specified by the uri which must be of type LOC or CHK

Definition at line 392 of file fs_directory.c.

{
  struct GNUNET_FS_Uri *curi;
  struct BuilderEntry *e;
  uint64_t fsize;
  uint32_t big;
  ssize_t ret;
  size_t mds;
  size_t mdxs;
  char *uris;
  char *serialized;
  char *sptr;
  size_t slen;
  struct GNUNET_FS_MetaData *meta;
  const struct GNUNET_FS_MetaData *meta_use;
 
  GNUNET_assert (! GNUNET_FS_uri_test_ksk (uri));
  if (NULL != data)
  {
    GNUNET_assert (! GNUNET_FS_uri_test_sks (uri));
    if (GNUNET_FS_uri_test_chk (uri))
    {
      fsize = GNUNET_FS_uri_chk_get_file_size (uri);
    }
    else
    {
      curi = GNUNET_FS_uri_loc_get_uri (uri);
      GNUNET_assert (NULL != curi);
      fsize = GNUNET_FS_uri_chk_get_file_size (curi);
      GNUNET_FS_uri_destroy (curi);
    }
  }
  else
  {
    fsize = 0;                  /* not given */
  }
  if (fsize > MAX_INLINE_SIZE)
    fsize = 0;                  /* too large */
  uris = GNUNET_FS_uri_to_string (uri);
  slen = strlen (uris) + 1;
  mds = GNUNET_FS_meta_data_get_serialized_size (md);
  meta_use = md;
  meta = NULL;
  if (fsize > 0)
  {
    meta = GNUNET_FS_meta_data_duplicate (md);
    GNUNET_FS_meta_data_insert (meta, "<gnunet>",
                                       EXTRACTOR_METATYPE_GNUNET_FULL_DATA,
                                       EXTRACTOR_METAFORMAT_BINARY, NULL, data,
                                       fsize);
    mdxs = GNUNET_FS_meta_data_get_serialized_size (meta);
    if ((slen + sizeof(uint32_t) + mdxs - 1) / DBLOCK_SIZE ==
        (slen + sizeof(uint32_t) + mds - 1) / DBLOCK_SIZE)
    {
      /* adding full data would not cause us to cross
       * additional blocks, so add it! */
      meta_use = meta;
      mds = mdxs;
    }
  }
 
  if (mds > GNUNET_MAX_MALLOC_CHECKED / 2)
    mds = GNUNET_MAX_MALLOC_CHECKED / 2;
  e = GNUNET_malloc (sizeof(struct BuilderEntry) + slen + mds
                     + sizeof(uint32_t));
  serialized = (char *) &e[1];
  GNUNET_memcpy (serialized, uris, slen);
  GNUNET_free (uris);
  sptr = &serialized[slen + sizeof(uint32_t)];
  ret =
    GNUNET_FS_meta_data_serialize (meta_use, &sptr, mds,
                                          GNUNET_FS_META_DATA_SERIALIZE_PART);
  if (NULL != meta)
    GNUNET_FS_meta_data_destroy (meta);
  if (ret == -1)
    mds = 0;
  else
    mds = ret;
  big = htonl (mds);
  GNUNET_memcpy (&serialized[slen], &big, sizeof(uint32_t));
  e->len = slen + sizeof(uint32_t) + mds;
  e->next = bld->head;
  bld->head = e;
  bld->count++;
}

References GNUNET_FS_DirectoryBuilder::count, data, DBLOCK_SIZE, EXTRACTOR_METAFORMAT_BINARY, EXTRACTOR_METATYPE_GNUNET_FULL_DATA, GNUNET_assert, GNUNET_free, GNUNET_FS_meta_data_destroy(), GNUNET_FS_meta_data_duplicate(), GNUNET_FS_meta_data_get_serialized_size(), GNUNET_FS_meta_data_insert(), GNUNET_FS_meta_data_serialize(), GNUNET_FS_META_DATA_SERIALIZE_PART, GNUNET_FS_uri_chk_get_file_size(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_loc_get_uri(), GNUNET_FS_uri_test_chk(), GNUNET_FS_uri_test_ksk(), GNUNET_FS_uri_test_sks(), GNUNET_FS_uri_to_string(), GNUNET_malloc, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, GNUNET_FS_DirectoryBuilder::head, BuilderEntry::len, MAX_INLINE_SIZE, meta, BuilderEntry::next, ret, and uri.

Referenced by progress_cb(), and publish_content().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_directory_builder_finish()

int GNUNET_FS_directory_builder_finish	(	struct GNUNET_FS_DirectoryBuilder *	bld,
		size_t *	rsize,
		void **	rdata
	)

Finish building the directory.

Frees the builder context and returns the directory in-memory.

Parameters

bld	directory to finish
rsize	set to the number of bytes needed
rdata	set to the encoded directory

Returns

GNUNET_OK on success

Definition at line 578 of file fs_directory.c.

{
  char *data;
  char *sptr;
  size_t *sizes;
  unsigned int *perm;
  unsigned int i;
  unsigned int j;
  struct BuilderEntry *pos;
  struct BuilderEntry **bes;
  size_t size;
  size_t psize;
  size_t off;
  ssize_t ret;
  uint32_t big;
 
  size = strlen (GNUNET_DIRECTORY_MAGIC) + sizeof(uint32_t);
  size += GNUNET_FS_meta_data_get_serialized_size (bld->meta);
  sizes = NULL;
  perm = NULL;
  bes = NULL;
  if (0 < bld->count)
  {
    sizes = GNUNET_new_array (bld->count,
                              size_t);
    perm = GNUNET_new_array (bld->count,
                             unsigned int);
    bes = GNUNET_new_array (bld->count,
                            struct BuilderEntry *);
    pos = bld->head;
    for (i = 0; i < bld->count; i++)
    {
      perm[i] = i;
      bes[i] = pos;
      sizes[i] = pos->len;
      pos = pos->next;
    }
    block_align (size, bld->count, sizes, perm);
    /* compute final size with alignment */
    for (i = 0; i < bld->count; i++)
    {
      psize = size;
      size += sizes[perm[i]];
      size = do_align (psize, size);
    }
  }
  *rsize = size;
  data = GNUNET_malloc_large (size);
  if (data == NULL)
  {
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
                         "malloc");
    *rsize = 0;
    *rdata = NULL;
    GNUNET_free (sizes);
    GNUNET_free (perm);
    GNUNET_free (bes);
    return GNUNET_SYSERR;
  }
  *rdata = data;
  GNUNET_memcpy (data,
                 GNUNET_DIRECTORY_MAGIC,
                 strlen (GNUNET_DIRECTORY_MAGIC));
  off = strlen (GNUNET_DIRECTORY_MAGIC);
 
  sptr = &data[off + sizeof(uint32_t)];
  ret =
    GNUNET_FS_meta_data_serialize (bld->meta,
                                          &sptr,
                                          size - off - sizeof(uint32_t),
                                          GNUNET_FS_META_DATA_SERIALIZE_FULL);
  GNUNET_assert (ret != -1);
  big = htonl (ret);
  GNUNET_memcpy (&data[off],
                 &big,
                 sizeof(uint32_t));
  off += sizeof(uint32_t) + ret;
  for (j = 0; j < bld->count; j++)
  {
    i = perm[j];
    psize = off;
    off += sizes[i];
    off = do_align (psize, off);
    GNUNET_memcpy (&data[off - sizes[i]], &(bes[i])[1], sizes[i]);
    GNUNET_free (bes[i]);
  }
  GNUNET_free (sizes);
  GNUNET_free (perm);
  GNUNET_free (bes);
  GNUNET_assert (off == size);
  GNUNET_FS_meta_data_destroy (bld->meta);
  GNUNET_free (bld);
  return GNUNET_OK;
}

References block_align(), GNUNET_FS_DirectoryBuilder::count, data, do_align(), GNUNET_assert, GNUNET_DIRECTORY_MAGIC, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_meta_data_destroy(), GNUNET_FS_meta_data_get_serialized_size(), GNUNET_FS_meta_data_serialize(), GNUNET_FS_META_DATA_SERIALIZE_FULL, GNUNET_log_strerror, GNUNET_malloc_large, GNUNET_memcpy, GNUNET_new_array, GNUNET_OK, GNUNET_SYSERR, GNUNET_FS_DirectoryBuilder::head, BuilderEntry::len, GNUNET_FS_DirectoryBuilder::meta, BuilderEntry::next, ret, and size.

Referenced by clean_task(), and publish_content().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_directory_scan_start()

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.

Parameters

filename	name of the directory to scan
disable_extractor	GNUNET_YES to not run libextractor on files (only build a tree)
ex	if not NULL, must be a list of extra plugins for extractor
cb	the callback to call when there are scanning progress messages
cb_cls	closure for cb

Returns

directory scanner object to be used for controlling the scanner

Start a directory scanner.

Parameters

filename	name of the directory to scan
disable_extractor	GNUNET_YES to not run libextractor on files (only build a tree)
ex	if not NULL, must be a list of extra plugins for extractor
cb	the callback to call when there are scanning progress messages
cb_cls	closure for 'cb'

Returns

directory scanner object to be used for controlling the scanner

Definition at line 450 of file fs_dirmetascan.c.

{
  struct stat sbuf;
  char *filename_expanded;
  struct GNUNET_FS_DirScanner *ds;
 
  if (0 != stat (filename, &sbuf))
    return NULL;
  filename_expanded = GNUNET_STRINGS_filename_expand (filename);
  if (NULL == filename_expanded)
    return NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting to scan directory `%s'\n",
              filename_expanded);
  ds = GNUNET_new (struct GNUNET_FS_DirScanner);
  ds->progress_callback = cb;
  ds->progress_callback_cls = cb_cls;
  ds->filename_expanded = filename_expanded;
  if (disable_extractor)
    ds->ex_arg = GNUNET_strdup ("-");
  else
    ds->ex_arg = (NULL != ex) ? GNUNET_strdup (ex) : NULL;
  ds->args[0] = (char*) "gnunet-helper-fs-publish";
  ds->args[1] = ds->filename_expanded;
  ds->args[2] = ds->ex_arg;
  ds->args[3] = NULL;
  ds->helper = GNUNET_HELPER_start (GNUNET_OS_project_data_gnunet (),
                                    GNUNET_NO,
                                    "gnunet-helper-fs-publish",
                                    ds->args,
                                    &process_helper_msgs,
                                    &helper_died_cb,
                                    ds);
  if (NULL == ds->helper)
  {
    GNUNET_free (filename_expanded);
    GNUNET_free (ds);
    return NULL;
  }
  return ds;
}

References GNUNET_FS_DirScanner::args, disable_extractor, ds, GNUNET_FS_DirScanner::ex_arg, filename, GNUNET_FS_DirScanner::filename_expanded, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELPER_start(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OS_project_data_gnunet(), GNUNET_strdup, GNUNET_STRINGS_filename_expand(), GNUNET_FS_DirScanner::helper, helper_died_cb(), process_helper_msgs(), GNUNET_FS_DirScanner::progress_callback, and GNUNET_FS_DirScanner::progress_callback_cls.

Referenced by GNUNET_FS_unindex_do_extract_keywords_(), and identity_continuation().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_directory_scan_abort()

void GNUNET_FS_directory_scan_abort

(

struct GNUNET_FS_DirScanner *

ds

)

Abort the scan.

Must not be called from within the progress_callback function.

Parameters

ds	directory scanner structure

Definition at line 99 of file fs_dirmetascan.c.

{
  /* terminate helper */
  if (NULL != ds->helper)
    GNUNET_HELPER_stop (ds->helper, GNUNET_NO);
 
  /* free resources */
  if (NULL != ds->toplevel)
    GNUNET_FS_share_tree_free (ds->toplevel);
  if (NULL != ds->stop_task)
    GNUNET_SCHEDULER_cancel (ds->stop_task);
  GNUNET_free (ds->ex_arg);
  GNUNET_free (ds->filename_expanded);
  GNUNET_free (ds);
}

References ds, GNUNET_FS_DirScanner::ex_arg, GNUNET_FS_DirScanner::filename_expanded, GNUNET_free, GNUNET_FS_share_tree_free(), GNUNET_HELPER_stop(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_FS_DirScanner::helper, GNUNET_FS_DirScanner::stop_task, and GNUNET_FS_DirScanner::toplevel.

Referenced by do_stop_task(), GNUNET_FS_directory_scan_get_result(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_stop(), and unindex_directory_scan_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_directory_scan_get_result()

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.

Must not be called prior to completion. The ds is freed as part of this call.

Parameters

ds	directory scanner structure

Returns

the results of the scan (a directory tree)

Definition at line 117 of file fs_dirmetascan.c.

{
  struct GNUNET_FS_ShareTreeItem *result;
 
  /* check that we're actually done */
  GNUNET_assert (NULL == ds->helper);
  /* preserve result */
  result = ds->toplevel;
  ds->toplevel = NULL;
  GNUNET_FS_directory_scan_abort (ds);
  return result;
}

References ds, GNUNET_assert, GNUNET_FS_directory_scan_abort(), GNUNET_FS_DirScanner::helper, result, and GNUNET_FS_DirScanner::toplevel.

Referenced by directory_scan_cb(), and unindex_directory_scan_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_share_tree_trim()

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.

Parameters

toplevel

toplevel directory in the tree, returned by the scanner

Definition at line 417 of file fs_sharetree.c.

{
  struct TrimContext tc;
 
  if (toplevel == NULL)
    return;
  tc.keywordcounter = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
  tc.metacounter = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
  share_tree_trim (&tc, toplevel);
  GNUNET_CONTAINER_multihashmap_destroy (tc.keywordcounter);
  GNUNET_CONTAINER_multihashmap_destroy (tc.metacounter);
}

References GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_NO, share_tree_trim(), and tc.

Referenced by directory_scan_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_share_tree_free()

void GNUNET_FS_share_tree_free

(

struct GNUNET_FS_ShareTreeItem *

toplevel

)

Release memory of a share item tree.

Parameters

toplevel

toplevel of the tree to be freed

Definition at line 437 of file fs_sharetree.c.

{
  struct GNUNET_FS_ShareTreeItem *pos;
 
  while (NULL != (pos = toplevel->children_head))
    GNUNET_FS_share_tree_free (pos);
  if (NULL != toplevel->parent)
    GNUNET_CONTAINER_DLL_remove (toplevel->parent->children_head,
                                 toplevel->parent->children_tail,
                                 toplevel);
  if (NULL != toplevel->meta)
    GNUNET_FS_meta_data_destroy (toplevel->meta);
  if (NULL != toplevel->ksk_uri)
    GNUNET_FS_uri_destroy (toplevel->ksk_uri);
  GNUNET_free (toplevel->filename);
  GNUNET_free (toplevel->short_filename);
  GNUNET_free (toplevel);
}

References GNUNET_FS_ShareTreeItem::children_head, GNUNET_FS_ShareTreeItem::children_tail, GNUNET_FS_ShareTreeItem::filename, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_FS_meta_data_destroy(), GNUNET_FS_share_tree_free(), GNUNET_FS_uri_destroy(), GNUNET_FS_ShareTreeItem::ksk_uri, GNUNET_FS_ShareTreeItem::meta, GNUNET_FS_ShareTreeItem::parent, and GNUNET_FS_ShareTreeItem::short_filename.

Referenced by directory_trim_complete(), GNUNET_FS_directory_scan_abort(), GNUNET_FS_share_tree_free(), and unindex_directory_scan_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_write_meta_data()

enum GNUNET_GenericReturnValue GNUNET_FS_write_meta_data	(	struct GNUNET_BIO_WriteHandle *	h,
		const char *	what,
		const struct GNUNET_FS_MetaData *	m
	)

Write a metadata container.

Parameters

h	the IO handle to write to
what	what is being written (for error message creation)
m	metadata to write

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1110 of file meta_data.c.

{
  ssize_t size;
  char *buf;
 
  if (m == NULL)
    return GNUNET_BIO_write_int32 (h, _ ("metadata length"), 0);
  buf = NULL;
  size = GNUNET_FS_meta_data_serialize (m,
                                        &buf,
                                        MAX_META_DATA,
                                        GNUNET_FS_META_DATA_SERIALIZE_PART);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Serialized %lld bytes of metadata",
              (long long) size);
 
  if (-1 == size)
  {
    GNUNET_free (buf);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to serialize metadata `%s'",
                what);
    return GNUNET_SYSERR;
  }
  if ( (GNUNET_OK !=
        GNUNET_BIO_write_int32 (h,
                                "metadata length",
                                (uint32_t) size)) ||
       (GNUNET_OK !=
        GNUNET_BIO_write (h,
                          what,
                          buf,
                          size)) )
  {
    GNUNET_free (buf);
    return GNUNET_SYSERR;
  }
  GNUNET_free (buf);
  return GNUNET_OK;
}

References _, GNUNET_BIO_write(), GNUNET_BIO_write_int32(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_FS_meta_data_serialize(), GNUNET_FS_META_DATA_SERIALIZE_PART, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, h, m, MAX_META_DATA, and size.

Referenced by write_spec_handler_meta_data().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_read_spec_meta_data()

struct GNUNET_BIO_ReadSpec GNUNET_FS_read_spec_meta_data	(	const char *	what,
		struct GNUNET_FS_MetaData **	result
	)

Create the specification to read a metadata container.

Parameters

what	describes what is being read (for error message creation)
result	the buffer to store a pointer to the (allocated) metadata

Returns

the read spec

Definition at line 1185 of file meta_data.c.

{
  struct GNUNET_BIO_ReadSpec rs = {
    .rh = &read_spec_handler_meta_data,
    .cls = NULL,
    .target = result,
    .size = 0,
  };
 
  return rs;
}

References read_spec_handler_meta_data(), result, and GNUNET_BIO_ReadSpec::rh.

Referenced by deserialize_download(), and read_update_information_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_write_spec_meta_data()

struct GNUNET_BIO_WriteSpec GNUNET_FS_write_spec_meta_data	(	const char *	what,
		const struct GNUNET_FS_MetaData *	m
	)

Create the specification to write a metadata container.

Parameters

what	what is being written (for error message creation)
m	metadata to write

Returns

the write spec

Definition at line 1223 of file meta_data.c.

{
  struct GNUNET_BIO_WriteSpec ws = {
    .wh = &write_spec_handler_meta_data,
    .cls = NULL,
    .what = what,
    .source = (void *) m,
    .source_size = 0,
  };
 
  return ws;
}

References m, GNUNET_BIO_WriteSpec::source_size, GNUNET_BIO_WriteSpec::wh, GNUNET_BIO_WriteSpec::what, and write_spec_handler_meta_data().

Referenced by GNUNET_FS_download_sync_(), GNUNET_FS_file_information_sync_(), GNUNET_FS_search_result_sync_(), and write_update_information_graph().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FS_read_meta_data()

enum GNUNET_GenericReturnValue GNUNET_FS_read_meta_data	(	struct GNUNET_BIO_ReadHandle *	h,
		const char *	what,
		struct GNUNET_FS_MetaData **	result
	)

Read a metadata container.

Parameters

h	handle to an open file
what	describes what is being read (for error message creation)
result	the buffer to store a pointer to the (allocated) metadata

Returns

GNUNET_OK on success, GNUNET_SYSERR on failure

Definition at line 1051 of file meta_data.c.

{
  uint32_t size;
  char *buf;
  char *emsg;
  struct GNUNET_FS_MetaData *meta;
 
  if (GNUNET_OK != GNUNET_BIO_read_int32 (h,
                                          _ ("metadata length"),
                                          (int32_t *) &size))
    return GNUNET_SYSERR;
  if (0 == size)
  {
    *result = NULL;
    return GNUNET_OK;
  }
  if (MAX_META_DATA < size)
  {
    GNUNET_asprintf (&emsg,
                     _ (
                       "Serialized metadata `%s' larger than allowed (%u > %u)\n"),
                     what,
                     size,
                     MAX_META_DATA);
    GNUNET_BIO_read_set_error (h, emsg);
    GNUNET_free (emsg);
    return GNUNET_SYSERR;
  }
  buf = GNUNET_malloc (size);
  if (GNUNET_OK != GNUNET_BIO_read (h, what, buf, size))
  {
    GNUNET_free (buf);
    return GNUNET_SYSERR;
  }
  meta = GNUNET_FS_meta_data_deserialize (buf, size);
  if (NULL == meta)
  {
    GNUNET_free (buf);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to deserialize metadata `%s'"), what);
    return GNUNET_SYSERR;
  }
  GNUNET_free (buf);
  *result = meta;
  return GNUNET_OK;
}

References _, GNUNET_asprintf(), GNUNET_BIO_read(), GNUNET_BIO_read_int32(), GNUNET_BIO_read_set_error(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_FS_meta_data_deserialize(), GNUNET_log, GNUNET_malloc, GNUNET_OK, GNUNET_SYSERR, h, MAX_META_DATA, meta, result, and size.

Referenced by deserialize_fi_node(), deserialize_search_result(), and read_spec_handler_meta_data().

Here is the call graph for this function:

Here is the caller graph for this function: