GNUnet  0.18.1

File sharing. More...

Collaboration diagram for FS service:

Data Structures

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

Macros

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

Typedefs

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

Enumerations

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

Functions

int GNUNET_FS_uri_to_key (const struct GNUNET_FS_Uri *uri, struct GNUNET_HashCode *key)
 Get a unique key from a URI. More...
 
char * GNUNET_FS_uri_to_string (const struct GNUNET_FS_Uri *uri)
 Convert a URI to a UTF-8 String. More...
 
char * GNUNET_FS_uri_ksk_to_string_fancy (const struct GNUNET_FS_Uri *uri)
 Convert keyword URI to a human readable format (i.e. More...
 
void GNUNET_FS_uri_ksk_add_keyword (struct GNUNET_FS_Uri *uri, const char *keyword, int is_mandatory)
 Add the given keyword to the set of keywords represented by the URI. More...
 
void GNUNET_FS_uri_ksk_remove_keyword (struct GNUNET_FS_Uri *uri, const char *keyword)
 Remove the given keyword from the set of keywords represented by the URI. More...
 
struct GNUNET_FS_UriGNUNET_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_UriGNUNET_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_UriGNUNET_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_UriGNUNET_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_UriGNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri)
 Duplicate URI. More...
 
struct GNUNET_FS_UriGNUNET_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_UriGNUNET_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_UriGNUNET_FS_uri_sks_create (const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *id)
 Create an SKS URI from a namespace ID and an identifier. More...
 
int GNUNET_FS_uri_sks_get_namespace (const struct GNUNET_FS_Uri *uri, struct GNUNET_CRYPTO_EcdsaPublicKey *pseudonym)
 Get the public key of a namespace from the given namespace URI. More...
 
char * GNUNET_FS_uri_sks_get_content_id (const struct GNUNET_FS_Uri *uri)
 Get the content identifier of an SKS URI. More...
 
int GNUNET_FS_uri_test_ksk (const struct GNUNET_FS_Uri *uri)
 Is this a keyword URI? More...
 
int GNUNET_FS_uri_test_chk (const struct GNUNET_FS_Uri *uri)
 Is this a file (or directory) URI? More...
 
uint64_t GNUNET_FS_uri_chk_get_file_size (const struct GNUNET_FS_Uri *uri)
 What is the size of the file that this URI refers to? More...
 
int GNUNET_FS_uri_test_loc (const struct GNUNET_FS_Uri *uri)
 Is this a location URI? More...
 
struct GNUNET_FS_UriGNUNET_FS_uri_ksk_create_from_meta_data (const struct GNUNET_CONTAINER_MetaData *md)
 Construct a keyword-URI from meta-data (take all entries in the meta-data and construct one large keyword URI that lists all keywords that can be found in the meta-data). More...
 
struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_KEYWORDS (char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_FS_Uri **topKeywords)
 Allow user to specify keywords. More...
 
struct GNUNET_GETOPT_CommandLineOption GNUNET_FS_GETOPT_METADATA (char shortName, const char *name, const char *argumentHelp, const char *description, struct GNUNET_CONTAINER_MetaData **meta)
 Allow user to specify metadata. More...
 
int GNUNET_FS_getopt_set_metadata (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx, void *scls, const char *option, const char *value)
 Command-line option parser function that allows the user to specify one or more '-m' options with metadata. More...
 
struct GNUNET_FS_HandleGNUNET_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_FileInformationGNUNET_FS_file_information_create_from_file (struct GNUNET_FS_Handle *h, void *client_info, const char *filename, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
 Create an entry for a file in a publish-structure. More...
 
struct GNUNET_FS_FileInformationGNUNET_FS_file_information_create_from_data (struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, void *data, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
 Create an entry for a file in a publish-structure. More...
 
struct GNUNET_FS_FileInformationGNUNET_FS_file_information_create_from_reader (struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, GNUNET_FS_DataReader reader, void *reader_cls, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
 Create an entry for a file in a publish-structure. More...
 
struct GNUNET_FS_FileInformationGNUNET_FS_file_information_create_empty_directory (struct GNUNET_FS_Handle *h, void *client_info, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_BlockOptions *bo, const char *filename)
 Create an entry for an empty directory in a publish-structure. More...
 
int GNUNET_FS_file_information_is_directory (const struct GNUNET_FS_FileInformation *ent)
 Test if a given entry represents a directory. More...
 
int GNUNET_FS_file_information_add (struct GNUNET_FS_FileInformation *dir, struct GNUNET_FS_FileInformation *ent)
 Add an entry to a directory in a publish-structure. More...
 
void GNUNET_FS_file_information_inspect (struct GNUNET_FS_FileInformation *dir, GNUNET_FS_FileInformationProcessor proc, void *proc_cls)
 Inspect a file or directory in a publish-structure. More...
 
void GNUNET_FS_file_information_destroy (struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
 Destroy publish-structure. More...
 
struct GNUNET_FS_PublishContextGNUNET_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_PublishKskContextGNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *ksk_uri, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
 Publish a KBlock on GNUnet. More...
 
void GNUNET_FS_publish_ksk_cancel (struct GNUNET_FS_PublishKskContext *pkc)
 Abort the KSK publishing operation. More...
 
struct GNUNET_FS_PublishSksContextGNUNET_FS_publish_sks (struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const char *identifier, const char *update, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_PublishContinuation cont, void *cont_cls)
 Publish an SBlock on GNUnet. More...
 
void GNUNET_FS_publish_sks_cancel (struct GNUNET_FS_PublishSksContext *psc)
 Abort the SKS publishing operation. More...
 
struct GNUNET_FS_GetIndexedContextGNUNET_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_UnindexContextGNUNET_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_SearchContextGNUNET_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_SearchResultGNUNET_FS_probe (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, void *client_info, uint32_t anonymity)
 Start download probes for the given search result. More...
 
void * GNUNET_FS_probe_stop (struct GNUNET_FS_SearchResult *sr)
 Stop probe activity. More...
 
struct GNUNET_FS_DownloadContextGNUNET_FS_download_start (struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx, struct GNUNET_FS_DownloadContext *parent)
 Download parts of a file. More...
 
struct GNUNET_FS_DownloadContextGNUNET_FS_download_start_from_search (struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchResult *sr, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx)
 Download parts of a file based on a search result. More...
 
void GNUNET_FS_download_stop (struct GNUNET_FS_DownloadContext *dc, int do_delete)
 Stop a download (aborts if download is incomplete). More...
 
void GNUNET_FS_download_suspend (struct GNUNET_FS_DownloadContext *dc)
 Suspend a download. More...
 
void GNUNET_FS_download_resume (struct GNUNET_FS_DownloadContext *dc)
 Resume a suspended download. More...
 
int GNUNET_FS_meta_data_test_for_directory (const struct GNUNET_CONTAINER_MetaData *md)
 Does the meta-data claim that this is a directory? Checks if the mime-type is that of a GNUnet directory. More...
 
void GNUNET_FS_meta_data_make_directory (struct GNUNET_CONTAINER_MetaData *md)
 Set the MIMETYPE information for the given metadata to "application/gnunet-directory". More...
 
char * GNUNET_FS_meta_data_suggest_filename (const struct GNUNET_CONTAINER_MetaData *md)
 Suggest a filename based on given metadata. More...
 
int GNUNET_FS_directory_list_contents (size_t size, const void *data, uint64_t offset, GNUNET_FS_DirectoryEntryProcessor dep, void *dep_cls)
 Iterate over all entries in a directory. More...
 
struct GNUNET_FS_DirectoryBuilderGNUNET_FS_directory_builder_create (const struct GNUNET_CONTAINER_MetaData *mdir)
 Create a directory builder. More...
 
void GNUNET_FS_directory_builder_add (struct GNUNET_FS_DirectoryBuilder *bld, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *md, const void *data)
 Add an entry to a directory. More...
 
int GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld, size_t *rsize, void **rdata)
 Finish building the directory. More...
 
struct GNUNET_FS_DirScannerGNUNET_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_ShareTreeItemGNUNET_FS_directory_scan_get_result (struct GNUNET_FS_DirScanner *ds)
 Obtain the result of the scan after the scan has signalled completion. More...
 
void GNUNET_FS_share_tree_trim (struct GNUNET_FS_ShareTreeItem *toplevel)
 Process a share item tree, moving frequent keywords up and copying frequent metadata up. More...
 
void GNUNET_FS_share_tree_free (struct GNUNET_FS_ShareTreeItem *toplevel)
 Release memory of a share item tree. More...
 

Detailed Description

File sharing.

See also
Documentation

Macro Definition Documentation

◆ GNUNET_FS_VERSION

#define GNUNET_FS_VERSION   0x00090300

Version number of the implementation.

History:

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

Definition at line 70 of file gnunet_fs_service.h.

◆ GNUNET_FS_URI_PREFIX

#define GNUNET_FS_URI_PREFIX   "gnunet://fs/"

Definition at line 75 of file gnunet_fs_service.h.

◆ GNUNET_FS_URI_KSK_INFIX

#define GNUNET_FS_URI_KSK_INFIX   "ksk/"

Definition at line 76 of file gnunet_fs_service.h.

◆ GNUNET_FS_URI_SKS_INFIX

#define GNUNET_FS_URI_SKS_INFIX   "sks/"

Definition at line 77 of file gnunet_fs_service.h.

◆ GNUNET_FS_URI_CHK_INFIX

#define GNUNET_FS_URI_CHK_INFIX   "chk/"

Definition at line 78 of file gnunet_fs_service.h.

◆ GNUNET_FS_URI_LOC_INFIX

#define GNUNET_FS_URI_LOC_INFIX   "loc/"

Definition at line 79 of file gnunet_fs_service.h.

◆ GNUNET_FS_PROBE_UPDATE_FREQUENCY

#define GNUNET_FS_PROBE_UPDATE_FREQUENCY
Value:
#define GNUNET_TIME_UNIT_MILLISECONDS
One millisecond.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:483

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

Definition at line 86 of file gnunet_fs_service.h.

◆ GNUNET_FS_DIRECTORY_MIME

#define GNUNET_FS_DIRECTORY_MIME   "application/gnunet-directory"

Definition at line 2463 of file gnunet_fs_service.h.

◆ GNUNET_FS_DIRECTORY_MAGIC

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

Definition at line 2464 of file gnunet_fs_service.h.

◆ GNUNET_FS_DIRECTORY_EXT

#define GNUNET_FS_DIRECTORY_EXT   ".gnd"

Definition at line 2465 of file gnunet_fs_service.h.

Typedef Documentation

◆ GNUNET_FS_KeywordIterator

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

Iterator over keywords.

Parameters
clsclosure
keywordthe keyword
is_mandatoryis the keyword mandatory (in a search)
Returns
GNUNET_OK to continue to iterate, GNUNET_SYSERR to abort

Definition at line 103 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
clsclosure
infodetails 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 1550 of file gnunet_fs_service.h.

◆ GNUNET_FS_FileInformationProcessor

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

Function called on entries in a struct GNUNET_FS_FileInformation iteration.

Parameters
clsclosure
fithe entry in the publish-structure
lengthlength of the file or directory
metametadata for the file or directory (can be modified)
uripointer to the keywords that will be used for this entry (can be modified)
boblock options (can be modified)
do_indexshould we index (can be modified)
client_infopointer 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 1704 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
clsclosure
offsetoffset 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
maxmaximum 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
bufwhere the reader should write the data
emsglocation for the reader to store an error message
Returns
number of bytes written, usually max, 0 on error

Definition at line 1829 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
clsclosure
uriURI under which the block is now available, NULL on error
emsgerror message, NULL on success

Definition at line 2017 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
clsclosure
filenamethe name of the file, NULL for end of list
file_idhash of the contents of the indexed file
Returns
GNUNET_OK to continue iteration, GNUNET_SYSERR to abort

Definition at line 2111 of file gnunet_fs_service.h.

◆ GNUNET_FS_IdentifierProcessor

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

Function called on updateable identifiers.

Parameters
clsclosure
last_idlast identifier
last_uriuri used for the content published under the last_id
last_metametadata associated with last_uri
next_ididentifier that should be used for updates

Definition at line 2178 of file gnunet_fs_service.h.

◆ GNUNET_FS_DirectoryEntryProcessor

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

Function used to process entries in a directory.

Parameters
clsclosure
filenamename of the file in the directory
uriURI of the file
metadatametadata for the file; metadata for the directory if everything else is NULL/zero
lengthlength 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).
datadata available for the file (length bytes)

Definition at line 2515 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
clsclosure
filenamewhich file we are making progress on
is_directoryGNUNET_YES if this is a directory, GNUNET_NO if this is a file GNUNET_SYSERR if it is neither (or unknown)
reasonkind of progress we are making

Definition at line 2651 of file gnunet_fs_service.h.

Enumeration Type Documentation

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

511 {
516 
521 
526 
531 
538 
545 
552 
557 
562 
567 
572 
577 
584 
590 
596 
602 
610 
617 
624 
630 
637 
642 
647 
653 
658 
663 
668 
674 
680 
687 
692 
697 
702 
707 
713 
719 
725 
730 };
@ GNUNET_FS_STATUS_UNINDEX_PROGRESS
Notification that we made progress unindexing a file.
@ GNUNET_FS_STATUS_SEARCH_UPDATE
We have additional data about the quality or availability of a search result.
@ GNUNET_FS_STATUS_DOWNLOAD_INACTIVE
Notification that this download is no longer actively being pursued (back in the queue).
@ GNUNET_FS_STATUS_SEARCH_RESULT_NAMESPACE
We have discovered a new namespace.
@ GNUNET_FS_STATUS_UNINDEX_RESUME
Notification that we resumed unindexing of a file.
@ GNUNET_FS_STATUS_DOWNLOAD_ERROR
Notification that this download encountered an error.
@ GNUNET_FS_STATUS_SEARCH_ERROR
Signals a problem with this search.
@ GNUNET_FS_STATUS_DOWNLOAD_COMPLETED
Notification that this download completed.
@ GNUNET_FS_STATUS_DOWNLOAD_RESUME
Notification that this download is being resumed.
@ GNUNET_FS_STATUS_SEARCH_RESULT_STOPPED
Event generated for each search result when the respective search is stopped.
@ GNUNET_FS_STATUS_UNINDEX_START
Notification that we started to unindex a file.
@ GNUNET_FS_STATUS_SEARCH_SUSPEND
Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generat...
@ GNUNET_FS_STATUS_SEARCH_RESUME
Last event when a search is being resumed; note that "GNUNET_FS_SEARCH_START" will not be generated i...
@ GNUNET_FS_STATUS_SEARCH_RESUME_RESULT
Event generated for each search result when the respective search is resumed.
@ GNUNET_FS_STATUS_PUBLISH_STOPPED
Notification that we have stopped the process of uploading a file structure; no further events will b...
@ GNUNET_FS_STATUS_PUBLISH_ERROR
Notification that an error was encountered sharing a file structure.
@ GNUNET_FS_STATUS_UNINDEX_STOPPED
Notification that the unindexing of this file was stopped (final event for this action).
@ GNUNET_FS_STATUS_DOWNLOAD_SUSPEND
Notification that this download was suspended.
@ GNUNET_FS_STATUS_SEARCH_RESULT
This search has yielded a result.
@ GNUNET_FS_STATUS_PUBLISH_SUSPEND
Notification that we have suspended sharing a file structure.
@ GNUNET_FS_STATUS_SEARCH_CONTINUED
Signals that this search was continued (unpaused).
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS
Notification that we are making progress sharing a file structure.
@ GNUNET_FS_STATUS_DOWNLOAD_START
Notification that we have started this download.
@ GNUNET_FS_STATUS_UNINDEX_COMPLETED
Notification that the unindexing of this file was completed.
@ GNUNET_FS_STATUS_SEARCH_PAUSED
Signals that this search was paused.
@ GNUNET_FS_STATUS_DOWNLOAD_PROGRESS
Notification about progress with this download.
@ GNUNET_FS_STATUS_DOWNLOAD_LOST_PARENT
Notification that this download is no longer part of a recursive download or search but now a 'stand-...
@ GNUNET_FS_STATUS_UNINDEX_SUSPEND
Notification that we suspended unindexing a file.
@ GNUNET_FS_STATUS_UNINDEX_ERROR
Notification that we encountered an error unindexing a file.
@ GNUNET_FS_STATUS_PUBLISH_PROGRESS_DIRECTORY
Notification that we are making progress sharing a directory.
@ GNUNET_FS_STATUS_PUBLISH_START
Notification that we have started to publish a file structure.
@ GNUNET_FS_STATUS_PUBLISH_COMPLETED
Notification that we completed sharing a file structure.
@ GNUNET_FS_STATUS_PUBLISH_RESUME
Notification that we have resumed sharing a file structure.
@ GNUNET_FS_STATUS_SEARCH_START
First event generated when a client requests a search to begin or when a namespace result automatical...
@ GNUNET_FS_STATUS_SEARCH_RESULT_SUSPEND
Event generated for each search result when the respective search is suspended.
@ 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_STOPPED
Notification that this download was stopped (final event with respect to this action).
@ GNUNET_FS_STATUS_SEARCH_STOPPED
Last message from a search; this signals that there will be no further events associated with this se...

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

1559 {
1564 
1570 
1577 };
@ 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?...
@ GNUNET_FS_FLAGS_NONE
No special flags set.

◆ GNUNET_FS_OPTIONS

Options specified in the VARARGs portion of GNUNET_FS_start.

Enumerator
GNUNET_FS_OPTIONS_END 

Last option in the VARARG list.

GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM 

Select the desired amount of parallelism (this option should be followed by an "unsigned int" giving the desired maximum number of parallel downloads).

GNUNET_FS_OPTIONS_REQUEST_PARALLELISM 

Maximum number of requests that should be pending at a given point in time (invidivual downloads may go above this, but if we are above this threshold, we should not activate any additional downloads.

Definition at line 1583 of file gnunet_fs_service.h.

1584 {
1589 
1596 
1604 };
@ GNUNET_FS_OPTIONS_DOWNLOAD_PARALLELISM
Select the desired amount of parallelism (this option should be followed by an "unsigned int" giving ...
@ GNUNET_FS_OPTIONS_END
Last option in the VARARG list.
@ GNUNET_FS_OPTIONS_REQUEST_PARALLELISM
Maximum number of requests that should be pending at a given point in time (invidivual downloads may ...

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

1961 {
1966 
1972 };
@ GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY
Simulate publishing.
@ GNUNET_FS_PUBLISH_OPTION_NONE
No options (use defaults for everything).

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

2223 {
2228 
2233 };
@ GNUNET_FS_SEARCH_OPTION_LOOPBACK_ONLY
Only search the local host, do not search remote systems (no P2P)
@ GNUNET_FS_SEARCH_OPTION_NONE
No options (use defaults for everything).

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

2314 {
2319 
2324 
2330 
2336 
2344  GNUNET_FS_DOWNLOAD_IS_PROBE = (1 << 31)
2345 };
@ GNUNET_FS_DOWNLOAD_OPTION_NONE
No options (use defaults for everything).
@ GNUNET_FS_DOWNLOAD_IS_PROBE
Internal option used to flag this download as a 'probe' for a search result.
@ GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE
Do a recursive download (that is, automatically trigger the download of files in directories).
@ GNUNET_FS_DOWNLOAD_OPTION_LOOPBACK_ONLY
Only download from the local host, do not access remote systems (no P2P)
@ GNUNET_FS_DOWNLOAD_NO_TEMPORARIES
Do not append temporary data to the target file (for the IBlocks).

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

2605 {
2610 
2616 
2621 
2626 
2632 
2637 };
@ GNUNET_FS_DIRSCANNER_INTERNAL_ERROR
There was an internal error.
@ GNUNET_FS_DIRSCANNER_FILE_IGNORED
We're having trouble accessing a file (soft-error); it will be ignored.
@ GNUNET_FS_DIRSCANNER_FINISHED
Last call to the progress function: we have finished scanning the directory.
@ GNUNET_FS_DIRSCANNER_EXTRACT_FINISHED
We've finished extracting meta data from a file.
@ GNUNET_FS_DIRSCANNER_ALL_COUNTED
We've found all files (in the pre-pass).
@ GNUNET_FS_DIRSCANNER_FILE_START
We've started processing a file or directory.

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
uriuri to convert to a unique key
keywhere to store the unique key
Returns
GNUNET_OK on success

Definition at line 95 of file fs_uri.c.

97 {
98  switch (uri->type)
99  {
100  case GNUNET_FS_URI_CHK:
101  *key = uri->data.chk.chk.query;
102  return GNUNET_OK;
103 
104  case GNUNET_FS_URI_SKS:
105  GNUNET_CRYPTO_hash (uri->data.sks.identifier,
106  strlen (uri->data.sks.identifier),
107  key);
108  return GNUNET_OK;
109 
110  case GNUNET_FS_URI_KSK:
111  if (uri->data.ksk.keywordCount > 0)
112  {
113  GNUNET_CRYPTO_hash (uri->data.ksk.keywords[0],
114  strlen (uri->data.ksk.keywords[0]),
115  key);
116  return GNUNET_OK;
117  }
118  else
119  {
120  memset (key, 0, sizeof(struct GNUNET_HashCode));
121  return GNUNET_SYSERR;
122  }
123  break;
124 
125  case GNUNET_FS_URI_LOC:
127  sizeof(struct FileIdentifier)
128  + sizeof(struct GNUNET_PeerIdentity),
129  key);
130  return GNUNET_OK;
131 
132  default:
133  memset (key, 0, sizeof(struct GNUNET_HashCode));
134  return GNUNET_SYSERR;
135  }
136 }
@ GNUNET_FS_URI_LOC
Location (chk with identity of hosting peer).
Definition: fs_api.h:158
@ GNUNET_FS_URI_CHK
Content-hash-key (simple file).
Definition: fs_api.h:143
@ GNUNET_FS_URI_SKS
Signed key space (file in namespace).
Definition: fs_api.h:148
@ GNUNET_FS_URI_KSK
Keyword search key (query with keywords).
Definition: fs_api.h:153
struct GNUNET_HashCode key
The key used in the DHT.
static struct GNUNET_FS_Uri * uri
Value of URI provided on command-line (when not publishing a file but just creating UBlocks to refer ...
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
@ GNUNET_OK
Definition: gnunet_common.h:99
@ GNUNET_SYSERR
Definition: gnunet_common.h:97
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:63
complete information needed to download a file.
Definition: fs_api.h:94
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:103
struct GNUNET_FS_Uri::@13::@14 ksk
union GNUNET_FS_Uri::@13 data
struct GNUNET_FS_Uri::@13::@15 sks
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:170
struct Location loc
Information needed to retrieve a file including signed location (identity of a peer) of the content.
Definition: fs_api.h:217
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:211
A 512-bit hashcode.
The identity of the host (wraps the signing key of the peer).
struct FileIdentifier fi
Information about the shared file.
Definition: fs_api.h:116

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, key, 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
uriuri to convert to a string
Returns
the UTF-8 string

Definition at line 2016 of file fs_uri.c.

2017 {
2018  if (uri == NULL)
2019  {
2020  GNUNET_break (0);
2021  return NULL;
2022  }
2023  switch (uri->type)
2024  {
2025  case GNUNET_FS_URI_KSK:
2026  return uri_ksk_to_string (uri);
2027 
2028  case GNUNET_FS_URI_SKS:
2029  return uri_sks_to_string (uri);
2030 
2031  case GNUNET_FS_URI_CHK:
2032  return uri_chk_to_string (uri);
2033 
2034  case GNUNET_FS_URI_LOC:
2035  return uri_loc_to_string (uri);
2036 
2037  default:
2038  GNUNET_break (0);
2039  return NULL;
2040  }
2041 }
static char * uri_sks_to_string(const struct GNUNET_FS_Uri *uri)
Convert SKS URI to a string.
Definition: fs_uri.c:1911
static char * uri_ksk_to_string(const struct GNUNET_FS_Uri *uri)
Convert a KSK URI to a string.
Definition: fs_uri.c:1841
static char * uri_chk_to_string(const struct GNUNET_FS_Uri *uri)
Convert a CHK URI to a string.
Definition: fs_uri.c:1942
static char * uri_loc_to_string(const struct GNUNET_FS_Uri *uri)
Convert a LOC URI to a string.
Definition: fs_uri.c:1973
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.

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 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
uriksk uri to convert to a string
Returns
string with the keywords

Definition at line 147 of file fs_uri.c.

148 {
149  size_t n;
150  char *ret;
151  unsigned int i;
152  const char *keyword;
153  char **keywords;
154  unsigned int keywordCount;
155 
156  if ((NULL == uri) || (GNUNET_FS_URI_KSK != uri->type))
157  {
158  GNUNET_break (0);
159  return NULL;
160  }
161  keywords = uri->data.ksk.keywords;
162  keywordCount = uri->data.ksk.keywordCount;
163  n = keywordCount + 1;
164  for (i = 0; i < keywordCount; i++)
165  {
166  keyword = keywords[i];
167  n += strlen (keyword) - 1;
168  if (NULL != strstr (&keyword[1], " "))
169  n += 2;
170  if (keyword[0] == '+')
171  n++;
172  }
173  ret = GNUNET_malloc (n);
174  strcpy (ret, "");
175  for (i = 0; i < keywordCount; i++)
176  {
177  keyword = keywords[i];
178  if (NULL != strstr (&keyword[1], " "))
179  {
180  strcat (ret, "\"");
181  if (keyword[0] == '+')
182  strcat (ret, keyword);
183  else
184  strcat (ret, &keyword[1]);
185  strcat (ret, "\"");
186  }
187  else
188  {
189  if (keyword[0] == '+')
190  strcat (ret, keyword);
191  else
192  strcat (ret, &keyword[1]);
193  }
194  strcat (ret, " ");
195  }
196  return ret;
197 }
static int ret
Return value of the commandline.
Definition: gnunet-abd.c:81
#define GNUNET_malloc(size)
Wrapper around malloc.

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_FS_URI_KSK, GNUNET_malloc, 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
uriksk uri to modify
keywordkeyword to add
is_mandatoryis this keyword mandatory?

Definition at line 751 of file fs_uri.c.

754 {
755  unsigned int i;
756  const char *old;
757  char *n;
758 
760  for (i = 0; i < uri->data.ksk.keywordCount; i++)
761  {
762  old = uri->data.ksk.keywords[i];
763  if (0 == strcmp (&old[1], keyword))
764  return;
765  }
766  GNUNET_asprintf (&n, is_mandatory ? "+%s" : " %s", keyword);
767  GNUNET_array_append (uri->data.ksk.keywords, uri->data.ksk.keywordCount, n);
768 }
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_array_append(arr, len, element)
Append an element to an array (growing the array by one).

References GNUNET_FS_Uri::data, GNUNET_array_append, GNUNET_asprintf(), GNUNET_assert, GNUNET_FS_URI_KSK, 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
uriksk uri to modify
keywordkeyword to add

Definition at line 779 of file fs_uri.c.

781 {
782  unsigned int i;
783  char *old;
784 
786  for (i = 0; i < uri->data.ksk.keywordCount; i++)
787  {
788  old = uri->data.ksk.keywords[i];
789  if (0 == strcmp (&old[1], keyword))
790  {
791  uri->data.ksk.keywords[i] =
792  uri->data.ksk.keywords[uri->data.ksk.keywordCount - 1];
793  GNUNET_array_grow (uri->data.ksk.keywords,
794  uri->data.ksk.keywordCount,
795  uri->data.ksk.keywordCount - 1);
796  GNUNET_free (old);
797  return;
798  }
799  }
800 }
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
#define GNUNET_free(ptr)
Wrapper around free.

References GNUNET_FS_Uri::data, GNUNET_array_grow, GNUNET_assert, GNUNET_free, GNUNET_FS_URI_KSK, 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
uristring to parse
emsgwhere to store the parser error message (if any)
Returns
NULL on error

FIXME: Do we want to log this?

Definition at line 636 of file fs_uri.c.

637 {
638  struct GNUNET_FS_Uri *ret;
639  char *msg;
640 
641  if (NULL == uri)
642  {
643  GNUNET_break (0);
644  if (NULL != emsg)
645  *emsg = GNUNET_strdup (_ ("invalid argument"));
646  return NULL;
647  }
651  msg = NULL;
652  if (NULL != (ret = uri_chk_parse (uri, &msg)))
653  return ret;
654  GNUNET_free (msg);
655  if (NULL != (ret = uri_ksk_parse (uri, &msg)))
656  return ret;
657  GNUNET_free (msg);
658  if (NULL != (ret = uri_sks_parse (uri, &msg)))
659  return ret;
660  GNUNET_free (msg);
661  if (NULL != (ret = uri_loc_parse (uri, &msg)))
662  return ret;
663  GNUNET_free (msg);
664  if (NULL != emsg)
665  *emsg = GNUNET_strdup (_ ("Unrecognized URI type"));
666  return NULL;
667 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
static struct GNUNET_FS_Uri * uri_chk_parse(const char *s, char **emsg)
Parse a CHK URI.
Definition: fs_uri.c:405
static struct GNUNET_FS_Uri * uri_loc_parse(const char *s, char **emsg)
Parse a LOC URI.
Definition: fs_uri.c:495
static struct GNUNET_FS_Uri * uri_ksk_parse(const char *s, char **emsg)
Parse a KSK URI.
Definition: fs_uri.c:271
static struct GNUNET_FS_Uri * uri_sks_parse(const char *s, char **emsg)
Parse an SKS URI.
Definition: fs_uri.c:365
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:166

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
uriuri to free

Definition at line 676 of file fs_uri.c.

677 {
678  unsigned int i;
679 
680  switch (uri->type)
681  {
682  case GNUNET_FS_URI_KSK:
683  for (i = 0; i < uri->data.ksk.keywordCount; i++)
684  GNUNET_free (uri->data.ksk.keywords[i]);
685  GNUNET_array_grow (uri->data.ksk.keywords, uri->data.ksk.keywordCount, 0);
686  break;
687 
688  case GNUNET_FS_URI_SKS:
689  GNUNET_free (uri->data.sks.identifier);
690  break;
691 
692  case GNUNET_FS_URI_LOC:
693  break;
694 
695  default:
696  /* do nothing */
697  break;
698  }
699  GNUNET_free (uri);
700 }

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

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

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
uriksk uri to get the number of keywords from
Returns
0 if this is not a keyword URI

Definition at line 710 of file fs_uri.c.

711 {
712  if (uri->type != GNUNET_FS_URI_KSK)
713  return 0;
714  return uri->data.ksk.keywordCount;
715 }

References GNUNET_FS_Uri::data, GNUNET_FS_URI_KSK, 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
uriksk uri to get the keywords from
iteratorfunction to call on each keyword
iterator_clsclosure for iterator
Returns
-1 if this is not a keyword URI, otherwise number of keywords iterated over until iterator aborted

Definition at line 719 of file fs_uri.c.

722 {
723  unsigned int i;
724  char *keyword;
725 
726  if (uri->type != GNUNET_FS_URI_KSK)
727  return -1;
728  if (NULL == iterator)
729  return uri->data.ksk.keywordCount;
730  for (i = 0; i < uri->data.ksk.keywordCount; i++)
731  {
732  keyword = uri->data.ksk.keywords[i];
733  /* first character of keyword indicates
734  * if it is mandatory or not */
735  if (GNUNET_OK != iterator (iterator_cls, &keyword[1],(keyword[0] == '+') ))
736  return i;
737  }
738  return i;
739 }
static int iterator(void *cls, const struct GNUNET_PeerIdentity *key, void *value)
Iterator over hash map entries.

References GNUNET_FS_Uri::data, GNUNET_FS_URI_KSK, GNUNET_OK, iterator(), GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::type, and uri.

Referenced by publish_inspector(), and share_tree_trim().

Here is the call graph for this function:
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
urithe location URI to inspect
peerwhere 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 811 of file fs_uri.c.

813 {
814  if (uri->type != GNUNET_FS_URI_LOC)
815  return GNUNET_SYSERR;
816  *peer = uri->data.loc.peer;
817  return GNUNET_OK;
818 }
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs_api.h:121
struct GNUNET_TESTBED_Peer * peer
The peer associated with this model.

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
urilocation URI to get the content URI from
Returns
NULL if argument is not a location URI

Definition at line 842 of file fs_uri.c.

843 {
844  struct GNUNET_FS_Uri *ret;
845 
846  if (uri->type != GNUNET_FS_URI_LOC)
847  return NULL;
848  ret = GNUNET_new (struct GNUNET_FS_Uri);
849  ret->type = GNUNET_FS_URI_CHK;
850  ret->data.chk = uri->data.loc.fi;
851  return ret;
852 }
#define GNUNET_new(type)
Allocate a struct or union of the given type.

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
urilocation URI to get the expiration from
Returns
expiration time of the URI

Definition at line 811 of file fs_uri.c.

829 {
831  return uri->data.loc.expirationTime;
832 }
struct GNUNET_TIME_Absolute expirationTime
Time when this location URI expires.
Definition: fs_api.h:126

References GNUNET_FS_Uri::data, GNUNET_FS_URI_LOC, GNUNET_OK, GNUNET_SYSERR, GNUNET_FS_Uri::loc, Location::peer, peer, 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_uricontent offered by the sender
sign_keyprivate key of the peer
expiration_timehow long will the content be offered?
Returns
the location URI, NULL on error

Definition at line 868 of file fs_uri.c.

871 {
872  struct GNUNET_FS_Uri *uri;
873  struct GNUNET_CRYPTO_EddsaPublicKey my_public_key;
874  struct LocUriAssembly ass;
875  struct GNUNET_TIME_Absolute et;
876 
877  if (GNUNET_FS_URI_CHK != base_uri->type)
878  return NULL;
879  /* we round expiration time to full seconds for SKS URIs */
880  et.abs_value_us = (expiration_time.abs_value_us / 1000000LL) * 1000000LL;
881  GNUNET_CRYPTO_eddsa_key_get_public (sign_key, &my_public_key);
882  ass.purpose.size = htonl (sizeof(struct LocUriAssembly));
883  ass.purpose.purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
884  ass.exptime = GNUNET_TIME_absolute_hton (et);
885  ass.fi = base_uri->data.chk;
886  ass.peer.public_key = my_public_key;
887  uri = GNUNET_new (struct GNUNET_FS_Uri);
889  uri->data.loc.fi = base_uri->data.chk;
890  uri->data.loc.expirationTime = et;
891  uri->data.loc.peer.public_key = my_public_key;
892  GNUNET_CRYPTO_eddsa_sign (sign_key,
893  &ass,
895  return uri;
896 }
#define GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT
Signature by which a peer affirms that it is providing a certain bit of content for use in LOCation U...
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:197
#define GNUNET_CRYPTO_eddsa_sign(priv, ps, sig)
EdDSA sign a given block.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:637
Public ECC key (always for curve Ed25519) encoded in a format suitable for network transmission and E...
struct GNUNET_CRYPTO_EddsaPublicKey public_key
Time for absolute times used by GNUnet, in microseconds.
uint64_t abs_value_us
The actual value.
Structure that defines how the contents of a location URI must be assembled in memory to create or ve...
Definition: fs_uri.c:458
struct GNUNET_CRYPTO_EddsaSignature contentSignature
Signature over the GNUNET_EC_FileIdentifier, peer identity and expiration time.
Definition: fs_api.h:132

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, LocUriAssembly::purpose, GNUNET_CRYPTO_EccSignaturePurpose::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
u1first uri
u2second uri
Returns
merged URI, NULL on error

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

Parameters
u1first uri
u2second uri
Returns
merged URI, NULL on error

Definition at line 930 of file fs_uri.c.

932 {
933  struct GNUNET_FS_Uri *ret;
934  unsigned int kc;
935  unsigned int i;
936  unsigned int j;
937  int found;
938  const char *kp;
939  char **kl;
940 
941  if ((u1 == NULL) && (u2 == NULL))
942  return NULL;
943  if (u1 == NULL)
944  return GNUNET_FS_uri_dup (u2);
945  if (u2 == NULL)
946  return GNUNET_FS_uri_dup (u1);
947  if ((u1->type != GNUNET_FS_URI_KSK) || (u2->type != GNUNET_FS_URI_KSK))
948  {
949  GNUNET_break (0);
950  return NULL;
951  }
952  kc = u1->data.ksk.keywordCount;
953  kl = GNUNET_new_array (kc + u2->data.ksk.keywordCount, char *);
954  for (i = 0; i < u1->data.ksk.keywordCount; i++)
955  kl[i] = GNUNET_strdup (u1->data.ksk.keywords[i]);
956  for (i = 0; i < u2->data.ksk.keywordCount; i++)
957  {
958  kp = u2->data.ksk.keywords[i];
959  found = 0;
960  for (j = 0; j < u1->data.ksk.keywordCount; j++)
961  if (0 == strcmp (kp + 1, kl[j] + 1))
962  {
963  found = 1;
964  if (kp[0] == '+')
965  kl[j][0] = '+';
966  break;
967  }
968  if (0 == found)
969  kl[kc++] = GNUNET_strdup (kp);
970  }
971  ret = GNUNET_new (struct GNUNET_FS_Uri);
972  ret->type = GNUNET_FS_URI_KSK;
973  ret->data.ksk.keywordCount = kc;
974  ret->data.ksk.keywords = kl;
975  return ret;
976 }
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:986
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.

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

Referenced by publish_inspector().

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
urithe URI to duplicate
Returns
copy of the URI

Definition at line 986 of file fs_uri.c.

987 {
988  struct GNUNET_FS_Uri *ret;
989  unsigned int i;
990 
991  if (uri == NULL)
992  return NULL;
993  ret = GNUNET_new (struct GNUNET_FS_Uri);
994  GNUNET_memcpy (ret, uri, sizeof(struct GNUNET_FS_Uri));
995  switch (ret->type)
996  {
997  case GNUNET_FS_URI_KSK:
998  if (ret->data.ksk.keywordCount >=
999  GNUNET_MAX_MALLOC_CHECKED / sizeof(char *))
1000  {
1001  GNUNET_break (0);
1002  GNUNET_free (ret);
1003  return NULL;
1004  }
1005  if (ret->data.ksk.keywordCount > 0)
1006  {
1007  ret->data.ksk.keywords =
1008  GNUNET_new_array (ret->data.ksk.keywordCount, char *);
1009  for (i = 0; i < ret->data.ksk.keywordCount; i++)
1010  ret->data.ksk.keywords[i] = GNUNET_strdup (uri->data.ksk.keywords[i]);
1011  }
1012  else
1013  ret->data.ksk.keywords = NULL; /* just to be sure */
1014  break;
1015 
1016  case GNUNET_FS_URI_SKS:
1017  ret->data.sks.identifier = GNUNET_strdup (uri->data.sks.identifier);
1018  break;
1019 
1020  case GNUNET_FS_URI_LOC:
1021  break;
1022 
1023  default:
1024  break;
1025  }
1026  return ret;
1027 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MAX_MALLOC_CHECKED
Maximum allocation with GNUNET_malloc macro.

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_free, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC, GNUNET_FS_URI_SKS, GNUNET_MAX_MALLOC_CHECKED, GNUNET_memcpy, GNUNET_new, GNUNET_new_array, GNUNET_strdup, GNUNET_FS_Uri::ksk, ret, GNUNET_FS_Uri::sks, and 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_TEST_download(), GNUNET_FS_tree_encoder_get_uri(), GNUNET_FS_uri_ksk_merge(), process_ksk_result(), process_sks_result(), publish_progress_cb(), publish_sblocks_cont(), search_start(), share_tree_trim(), and unindex_directory_scan_cb().

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
keywordsthe keyword string
emsgwhere to store an error message
Returns
an FS URI for the given keywords, NULL if keywords is not legal (i.e. empty).

Definition at line 1048 of file fs_uri.c.

1049 {
1050  char **keywordarr;
1051  unsigned int num_Words;
1052  int inWord;
1053  char *pos;
1054  struct GNUNET_FS_Uri *uri;
1055  char *searchString;
1056  int saw_quote;
1057 
1058  if (keywords == NULL)
1059  {
1060  *emsg = GNUNET_strdup (_ ("No keywords specified!\n"));
1061  GNUNET_break (0);
1062  return NULL;
1063  }
1064  searchString = GNUNET_strdup (keywords);
1065  num_Words = 0;
1066  inWord = 0;
1067  saw_quote = 0;
1068  pos = searchString;
1069  while ('\0' != *pos)
1070  {
1071  if ((saw_quote == 0) && (isspace ((unsigned char) *pos)))
1072  {
1073  inWord = 0;
1074  }
1075  else if (0 == inWord)
1076  {
1077  inWord = 1;
1078  ++num_Words;
1079  }
1080  if ('"' == *pos)
1081  saw_quote = (saw_quote + 1) % 2;
1082  pos++;
1083  }
1084  if (num_Words == 0)
1085  {
1086  GNUNET_free (searchString);
1087  *emsg = GNUNET_strdup (_ ("No keywords specified!\n"));
1088  return NULL;
1089  }
1090  if (saw_quote != 0)
1091  {
1092  GNUNET_free (searchString);
1093  *emsg = GNUNET_strdup (_ ("Number of double-quotes not balanced!\n"));
1094  return NULL;
1095  }
1096  keywordarr = GNUNET_new_array (num_Words, char *);
1097  num_Words = 0;
1098  inWord = 0;
1099  pos = searchString;
1100  while ('\0' != *pos)
1101  {
1102  if ((saw_quote == 0) && (isspace ((unsigned char) *pos)))
1103  {
1104  inWord = 0;
1105  *pos = '\0';
1106  }
1107  else if (0 == inWord)
1108  {
1109  keywordarr[num_Words] = pos;
1110  inWord = 1;
1111  ++num_Words;
1112  }
1113  if ('"' == *pos)
1114  saw_quote = (saw_quote + 1) % 2;
1115  pos++;
1116  }
1117  uri =
1118  GNUNET_FS_uri_ksk_create_from_args (num_Words, (const char **) keywordarr);
1119  GNUNET_free (keywordarr);
1120  GNUNET_free (searchString);
1121  return uri;
1122 }
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.
Definition: fs_uri.c:1143
char ** keywords
Keywords start with a '+' if they are mandatory (in which case the '+' is NOT part of the keyword) an...
Definition: fs_api.h:185

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
argcnumber of keywords
argvkeywords (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 1143 of file fs_uri.c.

1144 {
1145  unsigned int i;
1146  struct GNUNET_FS_Uri *uri;
1147  const char *keyword;
1148  char *val;
1149  const char *r;
1150  char *w;
1151  char *emsg;
1152 
1153  if (argc == 0)
1154  return NULL;
1155  /* allow URI to be given as one and only keyword and
1156  * handle accordingly */
1157  emsg = NULL;
1158  if ((argc == 1) && (strlen (argv[0]) > strlen (GNUNET_FS_URI_PREFIX)) &&
1159  (0 == strncmp (argv[0],
1161  strlen (GNUNET_FS_URI_PREFIX))) &&
1162  (NULL != (uri = GNUNET_FS_uri_parse (argv[0], &emsg))))
1163  return uri;
1164  GNUNET_free (emsg);
1165  uri = GNUNET_new (struct GNUNET_FS_Uri);
1167  uri->data.ksk.keywordCount = argc;
1168  uri->data.ksk.keywords = GNUNET_new_array (argc, char *);
1169  for (i = 0; i < argc; i++)
1170  {
1171  keyword = argv[i];
1172  if (keyword[0] == '+')
1173  val = GNUNET_strdup (keyword);
1174  else
1175  GNUNET_asprintf (&val, " %s", keyword);
1176  r = val;
1177  w = val;
1178  while ('\0' != *r)
1179  {
1180  if ('"' == *r)
1181  r++;
1182  else
1183  *(w++) = *(r++);
1184  }
1185  *w = '\0';
1186  uri->data.ksk.keywords[i] = val;
1187  }
1188  return uri;
1189 }
struct GNUNET_FS_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:636
#define GNUNET_FS_URI_PREFIX

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::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
u1one of the URIs
u2the other URI
Returns
GNUNET_YES if the URIs are equal

Definition at line 1200 of file fs_uri.c.

1202 {
1203  int ret;
1204  unsigned int i;
1205  unsigned int j;
1206 
1207  GNUNET_assert (u1 != NULL);
1208  GNUNET_assert (u2 != NULL);
1209  if (u1->type != u2->type)
1210  return GNUNET_NO;
1211  switch (u1->type)
1212  {
1213  case GNUNET_FS_URI_CHK:
1214  if (0 ==
1215  memcmp (&u1->data.chk, &u2->data.chk, sizeof(struct FileIdentifier)))
1216  return GNUNET_YES;
1217  return GNUNET_NO;
1218 
1219  case GNUNET_FS_URI_SKS:
1220  if ((0 == memcmp (&u1->data.sks.ns,
1221  &u2->data.sks.ns,
1222  sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey))) &&
1223  (0 == strcmp (u1->data.sks.identifier, u2->data.sks.identifier)))
1224 
1225  return GNUNET_YES;
1226  return GNUNET_NO;
1227 
1228  case GNUNET_FS_URI_KSK:
1229  if (u1->data.ksk.keywordCount != u2->data.ksk.keywordCount)
1230  return GNUNET_NO;
1231  for (i = 0; i < u1->data.ksk.keywordCount; i++)
1232  {
1233  ret = GNUNET_NO;
1234  for (j = 0; j < u2->data.ksk.keywordCount; j++)
1235  {
1236  if (0 == strcmp (u1->data.ksk.keywords[i], u2->data.ksk.keywords[j]))
1237  {
1238  ret = GNUNET_YES;
1239  break;
1240  }
1241  }
1242  if (ret == GNUNET_NO)
1243  return GNUNET_NO;
1244  }
1245  return GNUNET_YES;
1246 
1247  case GNUNET_FS_URI_LOC:
1248  if (memcmp (&u1->data.loc,
1249  &u2->data.loc,
1250  sizeof(struct FileIdentifier)
1251  + sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey)
1252  + sizeof(struct GNUNET_TIME_Absolute)
1253  + sizeof(unsigned short) + sizeof(unsigned short)) != 0)
1254  return GNUNET_NO;
1255  return GNUNET_YES;
1256 
1257  default:
1258  return GNUNET_NO;
1259  }
1260 }
@ GNUNET_YES
@ GNUNET_NO
Definition: gnunet_common.h:98
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...

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

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

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
urithe uri to check
Returns
GNUNET_YES if this is an SKS uri

Definition at line 1270 of file fs_uri.c.

1271 {
1272  return uri->type == GNUNET_FS_URI_SKS;
1273 }

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
nspseudonym to use
ididentifier
Returns
an FS URI for the given namespace and identifier
Parameters
nsnamespace ID
ididentifier
Returns
an FS URI for the given namespace and identifier

Definition at line 907 of file fs_uri.c.

909 {
910  struct GNUNET_FS_Uri *ns_uri;
911 
912  ns_uri = GNUNET_new (struct GNUNET_FS_Uri);
913  ns_uri->type = GNUNET_FS_URI_SKS;
914  ns_uri->data.sks.ns = *ns;
915  ns_uri->data.sks.identifier = GNUNET_strdup (id);
916  return ns_uri;
917 }
static struct GNUNET_NAMESTORE_Handle * ns
Handle to the namestore.
Definition: gnunet-abd.c:41

References GNUNET_FS_Uri::data, GNUNET_FS_URI_SKS, GNUNET_new, GNUNET_strdup, 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
urithe uri to get the namespace ID from
pseudonymwhere 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
urithe uri to get the namespace ID from
pseudonymwhere to store the ID of the namespace
Returns
GNUNET_OK on success

Definition at line 1285 of file fs_uri.c.

1287 {
1288  if (! GNUNET_FS_uri_test_sks (uri))
1289  {
1290  GNUNET_break (0);
1291  return GNUNET_SYSERR;
1292  }
1293  *pseudonym = uri->data.sks.ns;
1294  return GNUNET_OK;
1295 }
static char * pseudonym
Command-line option identifying the pseudonym to use for the publication.
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1270

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_FS_uri_test_sks(), GNUNET_OK, GNUNET_SYSERR, 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
urithe sks uri
Returns
NULL on error (not a valid SKS URI)

Definition at line 1305 of file fs_uri.c.

1306 {
1307  if (! GNUNET_FS_uri_test_sks (uri))
1308  {
1309  GNUNET_break (0);
1310  return NULL;
1311  }
1312  return GNUNET_strdup (uri->data.sks.identifier);
1313 }

References GNUNET_FS_Uri::data, GNUNET_break, GNUNET_FS_uri_test_sks(), GNUNET_strdup, 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
urithe uri
Returns
GNUNET_YES if this is a KSK uri

Definition at line 1323 of file fs_uri.c.

1324 {
1325 #if EXTRA_CHECKS
1326  unsigned int i;
1327 
1328  if (uri->type == GNUNET_FS_URI_KSK)
1329  {
1330  for (i = 0; i < uri->data.ksk.keywordCount; i++)
1331  GNUNET_assert (uri->data.ksk.keywords[i] != NULL);
1332  }
1333 #endif
1334  return uri->type == GNUNET_FS_URI_KSK;
1335 }

References GNUNET_FS_Uri::data, GNUNET_assert, GNUNET_FS_URI_KSK, 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
urithe uri to check
Returns
GNUNET_YES if this is a CHK uri

Definition at line 1345 of file fs_uri.c.

1346 {
1347  return uri->type == GNUNET_FS_URI_CHK;
1348 }

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
urithe CHK (or LOC) URI to inspect
Returns
size of the file as specified in the CHK URI
Parameters
urithe CHK URI to inspect
Returns
size of the file as specified in the CHK URI

Definition at line 1359 of file fs_uri.c.

1360 {
1361  switch (uri->type)
1362  {
1363  case GNUNET_FS_URI_CHK:
1364  return GNUNET_ntohll (uri->data.chk.file_length);
1365 
1366  case GNUNET_FS_URI_LOC:
1367  return GNUNET_ntohll (uri->data.loc.fi.file_length);
1368 
1369  default:
1370  GNUNET_assert (0);
1371  }
1372  return 0; /* unreachable */
1373 }
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:53
uint64_t file_length
Total size of the file in bytes.
Definition: fs_api.h:98

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_(), GNUNET_FS_TEST_download(), 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_test_loc()

int GNUNET_FS_uri_test_loc ( const struct GNUNET_FS_Uri uri)

Is this a location URI?

Parameters
urithe uri to check
Returns
GNUNET_YES if this is a LOC uri

Definition at line 1383 of file fs_uri.c.

1384 {
1385  return uri->type == GNUNET_FS_URI_LOC;
1386 }

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_CONTAINER_MetaData md)

Construct a keyword-URI from meta-data (take all entries in the meta-data and construct one large keyword URI that lists all keywords that can be found in the meta-data).

Parameters
mdmetadata to use
Returns
NULL on error, otherwise a KSK URI

Definition at line 1770 of file fs_uri.c.

1772 {
1773  struct GNUNET_FS_Uri *ret;
1774  char *filename;
1775  char *full_name = NULL;
1776  char *ss;
1777  int ent;
1778  int tok_keywords = 0;
1779  int paren_keywords = 0;
1780 
1781  if (NULL == md)
1782  return NULL;
1783  ret = GNUNET_new (struct GNUNET_FS_Uri);
1784  ret->type = GNUNET_FS_URI_KSK;
1785  ent = GNUNET_CONTAINER_meta_data_iterate (md, NULL, NULL);
1786  if (ent > 0)
1787  {
1789  md,
1791  -1);
1792  if (NULL != full_name)
1793  {
1794  filename = full_name;
1795  while (NULL != (ss = strstr (filename, DIR_SEPARATOR_STR)))
1796  filename = ss + 1;
1797  tok_keywords = get_keywords_from_tokens (filename, NULL, 0);
1798  paren_keywords = get_keywords_from_parens (filename, NULL, 0);
1799  }
1800  /* x3 because there might be a normalized variant of every keyword,
1801  plus theoretically one more for mime... */
1802  ret->data.ksk.keywords =
1803  GNUNET_new_array ((ent + tok_keywords + paren_keywords) * 3, char *);
1805  }
1806  if (tok_keywords > 0)
1807  ret->data.ksk.keywordCount +=
1809  ret->data.ksk.keywords,
1810  ret->data.ksk.keywordCount);
1811  if (paren_keywords > 0)
1812  ret->data.ksk.keywordCount +=
1814  ret->data.ksk.keywords,
1815  ret->data.ksk.keywordCount);
1816  if (ent > 0)
1817  GNUNET_free (full_name);
1818  return ret;
1819 }
static int gather_uri_data(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)
Function called on each value in the meta data.
Definition: fs_uri.c:1695
static int get_keywords_from_parens(const char *s, char **array, int index)
Break the filename up by matching [], () and {} pairs to make keywords.
Definition: fs_uri.c:1522
static int get_keywords_from_tokens(const char *s, char **array, int index)
Break the filename up by TOKENS to make keywords.
Definition: fs_uri.c:1630
static char * filename
@ EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME
int GNUNET_CONTAINER_meta_data_iterate(const struct GNUNET_CONTAINER_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
Iterate over MD entries.
char * GNUNET_CONTAINER_meta_data_get_first_by_types(const struct GNUNET_CONTAINER_MetaData *md,...)
Get the first matching MD entry of the given types.
#define DIR_SEPARATOR_STR
Definition: platform.h:165

References DIR_SEPARATOR_STR, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, filename, gather_uri_data(), get_keywords_from_parens(), get_keywords_from_tokens(), GNUNET_CONTAINER_meta_data_get_first_by_types(), GNUNET_CONTAINER_meta_data_iterate(), GNUNET_free, 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
shortNameshort name of the option
namelong name of the option
argumentHelphelp text for the option argument
descriptionlong help text for the option
[out]topKeywordsset to the desired value

Definition at line 46 of file fs_getopt.c.

134 {
135  struct GNUNET_GETOPT_CommandLineOption clo = {
136  .shortName = shortName,
137  .name = name,
138  .argumentHelp = argumentHelp,
139  .description = description,
140  .require_argument = 1,
141  .processor = &getopt_set_keywords,
142  .scls = (void *) topKeywords
143  };
144 
145  return clo;
146 }
static int getopt_set_keywords(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 '-k' options with key...
Definition: fs_getopt.c:46
static struct GNUNET_FS_Uri * topKeywords
Keywords provided via command-line option.
const char * name
Definition of a command line option.
const char * description
Help text for the option (description)
const char * argumentHelp
Name of the argument for the user in help text.
const char shortName
Short name of the option.

References GNUNET_FS_Uri::data, GNUNET_array_append, GNUNET_assert, GNUNET_FS_URI_KSK, GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, GNUNET_FS_Uri::ksk, GNUNET_FS_Uri::type, uri, and value.

Referenced by main().

Here is the caller graph for this function:

◆ GNUNET_FS_GETOPT_METADATA()

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

Allow user to specify metadata.

Parameters
shortNameshort name of the option
namelong name of the option
argumentHelphelp text for the option argument
descriptionlong help text for the option
[out]metametadata set to the desired value
shortNameshort name of the option
namelong name of the option
argumentHelphelp text for the option argument
descriptionlong help text for the option
[out]metadataset to the desired value

Definition at line 162 of file fs_getopt.c.

259 {
260  struct GNUNET_GETOPT_CommandLineOption clo = {
261  .shortName = shortName,
262  .name = name,
263  .argumentHelp = argumentHelp,
264  .description = description,
265  .require_argument = 1,
266  .processor = &getopt_set_metadata,
267  .scls = (void *) meta
268  };
269 
270  return clo;
271 }
static int 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 met...
Definition: fs_getopt.c:162
static struct GNUNET_CONTAINER_MetaData * meta
Meta-data provided via command-line option.

References _, dgettext, EXTRACTOR_METAFORMAT_UTF8, EXTRACTOR_METATYPE_UNKNOWN, GNUNET_CONTAINER_meta_data_create(), GNUNET_CONTAINER_meta_data_insert(), GNUNET_free, GNUNET_OK, GNUNET_strdup, LIBEXTRACTOR_GETTEXT_DOMAIN, meta, type, and value.

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
ctxcommand line processor context
sclsmust be of type struct GNUNET_CONTAINER_MetaData **
optionname of the option (typically 'k')
valuecommand 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
cfgconfiguration to use
client_nameunique identifier for this client
upcbfunction to call to notify about FS actions
upcb_clsclosure for upcb
flagsspecific attributes for fs-operations
...list of optional options, terminated with GNUNET_FS_OPTIONS_END
Returns
NULL on error

Definition at line 3243 of file fs_api.c.

3249 {
3250  struct GNUNET_FS_Handle *ret;
3251  enum GNUNET_FS_OPTIONS opt;
3252  va_list ap;
3253 
3254  ret = GNUNET_new (struct GNUNET_FS_Handle);
3255  ret->cfg = cfg;
3256  ret->client_name = GNUNET_strdup (client_name);
3257  ret->upcb = upcb;
3258  ret->upcb_cls = upcb_cls;
3259  ret->flags = flags;
3260  ret->max_parallel_downloads = DEFAULT_MAX_PARALLEL_DOWNLOADS;
3261  ret->max_parallel_requests = DEFAULT_MAX_PARALLEL_REQUESTS;
3262  ret->avg_block_latency =
3263  GNUNET_TIME_UNIT_MINUTES; /* conservative starting point */
3264  va_start (ap, flags);
3265  while (GNUNET_FS_OPTIONS_END !=
3266  (opt = GNUNET_VA_ARG_ENUM (ap, GNUNET_FS_OPTIONS)))
3267  {
3268  switch (opt)
3269  {
3271  ret->max_parallel_downloads = va_arg (ap, unsigned int);
3272 
3273  break;
3274 
3276  ret->max_parallel_requests = va_arg (ap, unsigned int);
3277 
3278  break;
3279 
3280  default:
3281  GNUNET_break (0);
3282  GNUNET_free (ret->client_name);
3283  GNUNET_free (ret);
3284  va_end (ap);
3285  return NULL;
3286  }
3287  }
3288  va_end (ap);
3289  if (0 != (GNUNET_FS_FLAGS_PERSISTENCE & flags))
3290  {
3293  ret);
3296  ret);
3299  ret);
3302  ret);
3303  }
3304  return ret;
3305 }
static int deserialize_download_file(void *cls, const char *filename)
Function called with a filename of serialized download operation to deserialize.
Definition: fs_api.c:3181
#define DEFAULT_MAX_PARALLEL_REQUESTS
How many block requests can we have outstanding in parallel at a time by default?
Definition: fs_api.c:36
static int deserialize_unindex_file(void *cls, const char *filename)
Function called with a filename of serialized unindexing operation to deserialize.
Definition: fs_api.c:2311
static int deserialize_search_file(void *cls, const char *filename)
Function called with a filename of serialized search operation to deserialize.
Definition: fs_api.c:3129
static void deserialization_master(const char *master_path, GNUNET_FileNameCallback proc, struct GNUNET_FS_Handle *h)
Deserialize information about pending operations.
Definition: fs_api.c:3223
#define DEFAULT_MAX_PARALLEL_DOWNLOADS
How many downloads can we have outstanding in parallel at a time by default?
Definition: fs_api.c:41
static int deserialize_publish_file(void *cls, const char *filename)
Function called with a filename of serialized publishing operation to deserialize.
Definition: fs_api.c:1611
#define GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD
Name of the directory with master downloads (not associated with search or part of another download).
Definition: fs_api.h:65
#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH
Name of the directory with top-level searches.
Definition: fs_api.h:54
#define GNUNET_FS_SYNC_PATH_MASTER_UNINDEX
Name of the directory with unindex operations.
Definition: fs_api.h:86
#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH
Name of the directory with publishing operations.
Definition: fs_api.h:76
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
GNUNET_FS_OPTIONS
Options specified in the VARARGs portion of GNUNET_FS_start.
#define GNUNET_VA_ARG_ENUM(va, X)
wrap va_arg for enums
#define GNUNET_TIME_UNIT_MINUTES
One minute.
Master context for most FS operations.
Definition: fs_api.h:1069
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1161
char * client_name
Name of our client.
Definition: fs_api.h:1078
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1088
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1083

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

Referenced by download_connect_adapter(), publish_connect_adapter(), and 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
hhandle that was returned from GNUNET_FS_start()

Definition at line 3309 of file fs_api.c.

3310 {
3311  while (NULL != h->top_head)
3312  h->top_head->ssf (h->top_head->ssf_cls);
3313  if (NULL != h->queue_job)
3314  GNUNET_SCHEDULER_cancel (h->queue_job);
3315  GNUNET_free (h->client_name);
3316  GNUNET_free (h);
3317 }
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:99
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:943

References GNUNET_free, GNUNET_SCHEDULER_cancel(), and h.

Referenced by clean_task(), cleanup_task(), do_shutdown(), do_stop_task(), fs_disconnect_adapter(), 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
sstructure 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.

46 {
47  if (NULL != s->dir)
48  return NULL;
49  return s->serialization;
50 }
char * serialization
Under what filename is this struct serialized (for operational persistence).
Definition: fs_api.h:286
struct GNUNET_FS_FileInformation * dir
If this is a file in a directory, "dir" refers to the directory; otherwise NULL.
Definition: fs_api.h:237

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
sstructure to get the filename for
Returns
"filename" field of the structure (can be NULL)

Definition at line 60 of file fs_file_information.c.

61 {
62  return s->filename;
63 }
char * filename
Name of the file or directory (must be an absolute path).
Definition: fs_api.h:301

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
sstructure to get the filename for
filenamefilename to set

Definition at line 75 of file fs_file_information.c.

77 {
78  GNUNET_free (s->filename);
79  if (filename)
81  else
82  s->filename = NULL;
83 }

References GNUNET_FS_FileInformation::filename, 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_CONTAINER_MetaData meta,
int  do_index,
const struct GNUNET_FS_BlockOptions bo 
)

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

Parameters
hhandle to the file sharing subsystem
client_infoinitial client-info value for this entry
filenamename of the file or directory to publish
keywordsunder which keywords should this file be available directly; can be NULL
metametadata for the file
do_indexGNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
boblock options
Returns
publish structure entry for the file

Definition at line 87 of file fs_file_information.c.

95 {
96  struct FileInfo *fi;
97  uint64_t fsize;
99  const char *fn;
100  const char *ss;
101 
102  /* FIXME: should include_symbolic_links be GNUNET_NO or GNUNET_YES here? */
103  if (GNUNET_OK !=
105  {
107  return NULL;
108  }
110  if (NULL == fi)
111  {
112  GNUNET_break (0);
113  return NULL;
114  }
115  ret =
117  client_info,
118  fsize,
120  fi,
121  keywords,
122  meta,
123  do_index,
124  bo);
125  if (ret == NULL)
126  return NULL;
127  ret->h = h;
128  ret->filename = GNUNET_strdup (filename);
129  fn = filename;
130  while (NULL != (ss = strstr (fn, DIR_SEPARATOR_STR)))
131  fn = ss + 1;
132 /* FIXME: If we assume that on other platforms CRT is UTF-8-aware, then
133  * this should be changed to EXTRACTOR_METAFORMAT_UTF8
134  */
136  "<gnunet>",
139  "text/plain",
140  fn,
141  strlen (fn) + 1);
142  return ret;
143 }
void * GNUNET_FS_make_file_reader_context_(const char *filename)
Create the closure for the GNUNET_FS_data_reader_file_() callback.
Definition: fs_api.c:508
size_t GNUNET_FS_data_reader_file_(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function that provides data by reading from a file.
Definition: fs_api.c:446
static struct GNUNET_FS_BlockOptions bo
Options we set for published blocks.
enum GNUNET_GenericReturnValue GNUNET_DISK_file_size(const char *filename, uint64_t *size, int include_symbolic_links, int single_file_mode)
Get the size of the file (or directory) of the given file (in bytes).
Definition: disk.c:222
struct GNUNET_FS_FileInformation * GNUNET_FS_file_information_create_from_reader(struct GNUNET_FS_Handle *h, void *client_info, uint64_t length, GNUNET_FS_DataReader reader, void *reader_cls, const struct GNUNET_FS_Uri *keywords, const struct GNUNET_CONTAINER_MetaData *meta, int do_index, const struct GNUNET_FS_BlockOptions *bo)
Create an entry for a file in a publish-structure.
@ EXTRACTOR_METAFORMAT_C_STRING
0-terminated string.
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level 'level' that indicates a failure of the command 'cmd' with the mess...
@ GNUNET_ERROR_TYPE_WARNING
int GNUNET_CONTAINER_meta_data_insert(struct GNUNET_CONTAINER_MetaData *md, const char *plugin_name, enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format, const char *data_mime_type, const char *data, size_t data_size)
Extend metadata.
Closure for GNUNET_FS_data_reader_file_().
Definition: fs_api.c:412
Information for a file or directory that is about to be published.
Definition: fs_api.h:227
struct GNUNET_FS_Uri * keywords
Keywords to use for KBlocks.
Definition: fs_api.h:257
void * client_info
Pointer kept for the client.
Definition: fs_api.h:247
int do_index
Should the file be indexed or inserted?
Definition: fs_api.h:338

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_CONTAINER_meta_data_insert(), GNUNET_DISK_file_size(), GNUNET_ERROR_TYPE_WARNING, GNUNET_FS_data_reader_file_(), GNUNET_FS_file_information_create_from_reader(), GNUNET_FS_make_file_reader_context_(), GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_YES, h, GNUNET_FS_FileInformation::keywords, meta, and ret.

Referenced by get_file_information(), and publish_fs_connect_complete_cb().

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_file_information_create_from_data()

struct GNUNET_FS_FileInformation* GNUNET_FS_file_information_create_from_data ( struct GNUNET_FS_Handle h,
void *  client_info,
uint64_t  length,
void *  data,
const struct GNUNET_FS_Uri keywords,
const struct GNUNET_CONTAINER_MetaData meta,
int  do_index,
const struct GNUNET_FS_BlockOptions bo 
)

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

Parameters
hhandle to the file sharing subsystem
client_infoinitial client-info value for this entry
lengthlength of the file
datadata for the file (should not be used afterwards by the caller; callee will "free")
keywordsunder which keywords should this file be available directly; can be NULL
metametadata for the file
do_indexGNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
boblock options
Returns
publish structure entry for the file

Definition at line 147 of file fs_file_information.c.

156 {
157  if (GNUNET_YES == do_index)
158  {
159  GNUNET_break (0);
160  return NULL;
161  }
163  client_info,
164  length,
165  &
167  data,
168  keywords,
169  meta,
170  do_index,
171  bo);
172 }
size_t GNUNET_FS_data_reader_copy_(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function that provides data by copying from a buffer.
Definition: fs_api.c:544
uint32_t data
The data value.

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_CONTAINER_MetaData meta,
int  do_index,
const struct GNUNET_FS_BlockOptions bo 
)

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

Parameters
hhandle to the file sharing subsystem
client_infoinitial client-info value for this entry
lengthlength of the file
readerfunction that can be used to obtain the data for the file
reader_clsclosure for reader
keywordsunder which keywords should this file be available directly; can be NULL
metametadata for the file
do_indexGNUNET_YES for index, GNUNET_NO for insertion, GNUNET_SYSERR for simulation
boblock options
Returns
publish structure entry for the file

Definition at line 176 of file fs_file_information.c.

186 {
188 
190  {
191  GNUNET_break (0);
192  return NULL;
193  }
195  ret->h = h;
196  ret->client_info = client_info;
198  if (ret->meta == NULL)
200  ret->keywords = (keywords == NULL) ? NULL : GNUNET_FS_uri_dup (keywords);
201  ret->data.file.reader = reader;
202  ret->data.file.reader_cls = reader_cls;
203  ret->data.file.do_index = do_index;
204  ret->data.file.file_size = length;
205  ret->bo = *bo;
206  return ret;
207 }
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_create(void)
Create a fresh meta data container.
struct GNUNET_CONTAINER_MetaData * GNUNET_CONTAINER_meta_data_duplicate(const struct GNUNET_CONTAINER_MetaData *md)
Duplicate a MetaData token.
GNUNET_FS_DataReader reader
Function that can be used to read the data for the file.
Definition: fs_api.h:316
void * reader_cls
Closure for reader.
Definition: fs_api.h:321

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_file_information_create_empty_directory()

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

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

Parameters
hhandle to the file sharing subsystem
client_infoinitial client-info value for this entry
keywordsunder which keywords should this directory be available directly; can be NULL
metametadata for the directory
boblock options
filenamename of the directory; can be NULL
Returns
publish structure entry for the directory , NULL on error

Definition at line 225 of file fs_file_information.c.

232 {
234 
236  ret->h = h;
237  ret->client_info = client_info;
239  ret->keywords = GNUNET_FS_uri_dup (keywords);
240  ret->bo = *bo;
241  ret->is_directory = GNUNET_YES;
242  if (filename != NULL)
243  ret->filename = GNUNET_strdup (filename);
244  return ret;
245 }

References bo, GNUNET_FS_FileInformation::client_info, filename, GNUNET_CONTAINER_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
entcheck if this FI represents a directory
Returns
GNUNET_YES if so, GNUNET_NO if not

Definition at line 217 of file fs_file_information.c.

219 {
220  return ent->is_directory;
221 }
int is_directory
Is this struct for a file or directory?
Definition: fs_api.h:390

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
dirthe directory
entthe 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 249 of file fs_file_information.c.

251 {
252  if ((ent->dir != NULL) || (ent->next != NULL) ||
253  (dir->is_directory != GNUNET_YES))
254  {
255  GNUNET_break (0);
256  return GNUNET_SYSERR;
257  }
258  ent->dir = dir;
259  ent->next = dir->data.dir.entries;
260  dir->data.dir.entries = ent;
261  dir->data.dir.dir_size = 0;
262  return GNUNET_OK;
263 }
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:89
struct GNUNET_FS_FileInformation * next
Files in a directory are kept as a linked list.
Definition: fs_api.h:231

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
dirthe directory
procfunction to call on each entry
proc_clsclosure for proc

Definition at line 281 of file fs_file_information.c.

284 {
285  struct GNUNET_FS_FileInformation *pos;
286  int no;
287 
288  no = GNUNET_NO;
289  if (GNUNET_OK !=
290  proc (proc_cls,
291  dir,
292  (dir->is_directory == GNUNET_YES) ? dir->data.dir.dir_size
293  : dir->data.file.file_size,
294  dir->meta,
295  &dir->keywords,
296  &dir->bo,
297  (dir->is_directory == GNUNET_YES) ? &no : &dir->data.file.do_index,
298  &dir->client_info))
299  return;
300  if (dir->is_directory != GNUNET_YES)
301  return;
302  pos = dir->data.dir.entries;
303  while (pos != NULL)
304  {
305  no = GNUNET_NO;
306  if (GNUNET_OK !=
307  proc (proc_cls,
308  pos,
309  (pos->is_directory == GNUNET_YES) ? pos->data.dir.dir_size
310  : pos->data.file.file_size,
311  pos->meta,
312  &pos->keywords,
313  &pos->bo,
314  (pos->is_directory == GNUNET_YES) ? &no
315  : &pos->data.file.do_index,
316  &pos->client_info))
317  break;
318  pos = pos->next;
319  }
320 }
size_t dir_size
Size of the directory itself (in bytes); 0 if the size has not yet been calculated.
Definition: fs_api.h:367
struct GNUNET_FS_FileInformation::@16::@17 file
Data for a file.
struct GNUNET_FS_BlockOptions bo
Block options for the file.
Definition: fs_api.h:274
struct GNUNET_CONTAINER_MetaData * meta
Metadata to use for the file.
Definition: fs_api.h:252
union GNUNET_FS_FileInformation::@16 data
Data describing either the file or the directory.

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::file, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_FS_FileInformation::is_directory, GNUNET_FS_FileInformation::keywords, GNUNET_FS_FileInformation::meta, and GNUNET_FS_FileInformation::next.

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

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
fistructure to destroy
cleanerfunction to call on each entry in the structure (useful to clean up client_info); can be NULL; return values are ignored
cleaner_clsclosure for cleaner

Definition at line 334 of file fs_file_information.c.

337 {
338  struct GNUNET_FS_FileInformation *pos;
339  int no;
340 
341  no = GNUNET_NO;
342  if (GNUNET_YES == fi->is_directory)
343  {
344  /* clean up directory */
345  while (NULL != (pos = fi->data.dir.entries))
346  {
347  fi->data.dir.entries = pos->next;
348  GNUNET_FS_file_information_destroy (pos, cleaner, cleaner_cls);
349  }
350  /* clean up client-info */
351  if (NULL != cleaner)
352  cleaner (cleaner_cls,
353  fi,
354  fi->data.dir.dir_size,
355  fi->meta,
356  &fi->keywords,
357  &fi->bo,
358  &no,
359  &fi->client_info);
361  }
362  else
363  {
364  /* call clean-up function of the reader */
365  if (NULL != fi->data.file.reader)
366  {
367  (void) fi->data.file.reader (fi->data.file.reader_cls, 0, 0, NULL, NULL);
368  fi->data.file.reader = NULL;
369  }
370  /* clean up client-info */
371  if (NULL != cleaner)
372  cleaner (cleaner_cls,
373  fi,
374  fi->data.file.file_size,
375  fi->meta,
376  &fi->keywords,
377  &fi->bo,
378  &fi->data.file.do_index,
379  &fi->client_info);
380  }
381  GNUNET_free (fi->filename);
382  GNUNET_free (fi->emsg);
383  if (NULL != fi->sks_uri)
385  if (NULL != fi->chk_uri)
387  /* clean up serialization */
388  if ((NULL != fi->serialization) && (0 != unlink (fi->serialization)))
390  "unlink",
391  fi->serialization);
392  if (NULL != fi->keywords)
394  if (NULL != fi->meta)
397  if (NULL != fi->te)
398  {
399  GNUNET_FS_tree_encoder_finish (fi->te, NULL);
400  fi->te = NULL;
401  }
402  GNUNET_free (fi);
403 }
void GNUNET_FS_tree_encoder_finish(struct GNUNET_FS_TreeEncoder *te, char **emsg)
Clean up a tree encoder and return information about possible errors.
Definition: fs_tree.c:432
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:676
void GNUNET_FS_file_information_destroy(struct GNUNET_FS_FileInformation *fi, GNUNET_FS_FileInformationProcessor cleaner, void *cleaner_cls)
Destroy publish-structure.
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
struct GNUNET_FS_TreeEncoder * te
Encoder being used to publish this file.
Definition: fs_api.h:291
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:296
struct GNUNET_FS_Uri * sks_uri
SKS URI for this file or directory.
Definition: fs_api.h:269
void * dir_data
Pointer to the data for the directory (or NULL if not available).
Definition: fs_api.h:373
struct GNUNET_FS_FileInformation * entries
Linked list of entries in the directory.
Definition: fs_api.h:361
struct GNUNET_FS_Uri * chk_uri
CHK for this file or directory.
Definition: fs_api.h:263

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

Referenced by deserialize_fi_node(), deserialize_publish_file(), directory_trim_complete(), 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
hhandle to the file sharing subsystem
fiinformation about the file or directory structure to publish
nsnamespace to publish the file in, NULL for no namespace
nididentifier to use for the published content in the namespace (can be NULL, must be NULL if namespace is NULL)
nuidupdate-identifier that will be used for future updates (can be NULL, must be NULL if namespace or nid is NULL)
optionsoptions for the publication
Returns
context that can be used to control the publish operation

Definition at line 1442 of file fs_publish.c.

1448 {
1449  struct GNUNET_FS_PublishContext *ret;
1450  struct GNUNET_DATASTORE_Handle *dsh;
1451 
1452  GNUNET_assert (NULL != h);
1453  compute_contents_size (fi);
1455  {
1457  if (NULL == dsh)
1458  return NULL;
1459  }
1460  else
1461  {
1462  dsh = NULL;
1463  }
1465  ret->dsh = dsh;
1466  ret->h = h;
1467  ret->fi = fi;
1468  if (NULL != ns)
1469  {
1471  *ret->ns = *ns;
1472  GNUNET_assert (NULL != nid);
1473  ret->nid = GNUNET_strdup (nid);
1474  if (NULL != nuid)
1475  ret->nuid = GNUNET_strdup (nuid);
1476  }
1477  ret->options = options;
1478  /* signal start */
1480  ret->fi_pos = ret->fi;
1483  if (NULL != ret->dsh)
1484  {
1485  GNUNET_assert (NULL == ret->qre);
1487  _ (
1488  "Reserving space for %u entries and %llu bytes for publication\n"),
1489  (unsigned int) ret->reserve_entries,
1490  (unsigned long long) ret->reserve_space);
1491  ret->qre =
1492  GNUNET_DATASTORE_reserve (ret->dsh, ret->reserve_space,
1493  ret->reserve_entries,
1494  &finish_reserve,
1495  ret);
1496  }
1497  else
1498  {
1499  GNUNET_assert (NULL == ret->upload_task);
1500  ret->upload_task =
1503  }
1504  return ret;
1505 }
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
struct TopLevelActivity * GNUNET_FS_make_top(struct GNUNET_FS_Handle *h, SuspendSignalFunction ssf, void *ssf_cls)
Create a top-level activity entry.
Definition: fs_api.c:380
void GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc)
Synchronize this publishing struct with its mirror on disk.
Definition: fs_api.c:1746
static int fip_signal_start(void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
Signal the FS's progress function that we are starting an upload.
Definition: fs_publish.c:1193
void GNUNET_FS_publish_signal_suspend_(void *cls)
Create SUSPEND event for the given publish operation and then clean up our state (without stop signal...
Definition: fs_publish.c:1354
static uint64_t compute_contents_size(struct GNUNET_FS_FileInformation *fi)
Calculate the total size of all of the files in the directory structure.
Definition: fs_publish.c:1415
static void finish_reserve(void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
We have gotten a reply for our space reservation request.
Definition: fs_publish.c:1382
void GNUNET_FS_publish_main_(void *cls)
Main function that performs the upload.
Definition: fs_publish.c:1062
static struct GNUNET_DATASTORE_Handle * dsh
Datastore handle.
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_reserve(struct GNUNET_DATASTORE_Handle *h, uint64_t amount, uint32_t entries, GNUNET_DATASTORE_ContinuationWithStatus cont, void *cont_cls)
Reserve space in the datastore.
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.
#define GNUNET_log(kind,...)
@ GNUNET_SCHEDULER_PRIORITY_BACKGROUND
Run as background job (higher than idle, lower than default).
@ GNUNET_ERROR_TYPE_INFO
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_with_priority(enum GNUNET_SCHEDULER_Priority prio, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified priority.
Definition: scheduler.c:1194
const struct GNUNET_CONFIGURATION_Handle * cfg
The configuration that we are using.
Definition: arm_api.c:112
Private ECC key encoded for transmission.
Handle to the datastore service.
Handle for controlling a publication process.
Definition: fs_api.h:1179

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(), publish_fs_connect_complete_cb(), 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
pccontext 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
pccontext for the upload to stop

Definition at line 1570 of file fs_publish.c.

1571 {
1572  struct GNUNET_FS_ProgressInfo pi;
1573  uint64_t off;
1574 
1576  "Publish stop called\n");
1577  GNUNET_FS_end_top (pc->h, pc->top);
1578  if (NULL != pc->ksk_pc)
1579  {
1581  pc->ksk_pc = NULL;
1582  }
1583  if (NULL != pc->sks_pc)
1584  {
1586  pc->sks_pc = NULL;
1587  }
1588  if (NULL != pc->upload_task)
1589  {
1591  pc->upload_task = NULL;
1592  }
1595 
1596  if (NULL != pc->fi->serialization)
1597  {
1599  pc->fi->serialization);
1601  pc->fi->serialization = NULL;
1602  }
1603  off = (NULL == pc->fi->chk_uri) ? 0 : GNUNET_ntohll (
1605 
1606  if (NULL != pc->serialization)
1607  {
1609  pc->serialization);
1611  pc->serialization = NULL;
1612  }
1613  if (NULL != pc->qre)
1614  {
1616  pc->qre = NULL;
1617  }
1619  GNUNET_break (NULL == GNUNET_FS_publish_make_status_ (&pi, pc, pc->fi, off));
1620  publish_cleanup (pc);
1621 }
void GNUNET_FS_remove_sync_file_(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Remove serialization/deserialization file from disk.
Definition: fs_api.c:727
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:401
#define GNUNET_FS_SYNC_PATH_FILE_INFO
Name of the directory with files that are being published.
Definition: fs_api.h:81
static void publish_cleanup(struct GNUNET_FS_PublishContext *pc)
Cleanup the publish context, we're done with it.
Definition: fs_publish.c:78
void * GNUNET_FS_publish_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_PublishContext *pc, const struct GNUNET_FS_FileInformation *p, uint64_t offset)
Fill in all of the generic fields for a publish event and call the callback.
Definition: fs_publish.c:47
static int fip_signal_stop(void *cls, struct GNUNET_FS_FileInformation *fi, uint64_t length, struct GNUNET_CONTAINER_MetaData *meta, struct GNUNET_FS_Uri **uri, struct GNUNET_FS_BlockOptions *bo, int *do_index, void **client_info)
Signal the FS's progress function that we are stopping an upload.
Definition: fs_publish.c:1523
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
void GNUNET_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
void GNUNET_FS_publish_ksk_cancel(struct GNUNET_FS_PublishKskContext *pkc)
Abort the KSK publishing operation.
void GNUNET_FS_publish_sks_cancel(struct GNUNET_FS_PublishSksContext *psc)
Abort the SKS publishing operation.
Definition: fs_namespace.c:490
@ GNUNET_ERROR_TYPE_DEBUG
Argument given to the progress callback with information about what is going on.
int skip_next_fi_callback
Flag set to GNUNET_YES if the next callback from GNUNET_FS_file_information_inspect should be skipped...
Definition: fs_api.h:1298
struct GNUNET_FS_PublishKskContext * ksk_pc
Context for KSK publishing operation that is part of this publishing operation (NULL if not active).
Definition: fs_api.h:1252
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1188
struct GNUNET_DATASTORE_QueueEntry * qre
Queue entry for reservation/unreservation.
Definition: fs_api.h:1240
struct GNUNET_FS_FileInformation * fi
File-structure that is being shared.
Definition: fs_api.h:1193
struct GNUNET_FS_Handle * h
Handle to the global fs context.
Definition: fs_api.h:1183
struct GNUNET_SCHEDULER_Task * upload_task
ID of the task performing the upload.
Definition: fs_api.h:1258
struct GNUNET_FS_PublishSksContext * sks_pc
Context for SKS publishing operation that is part of this publishing operation (NULL if not active).
Definition: fs_api.h:1246
char * serialization
Filename used for serializing information about this operation (should be determined using 'mktemp').
Definition: fs_api.h:1214

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, pi, 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_PublishContext::top, and GNUNET_FS_PublishContext::upload_task.

Referenced by do_stop_task(), publish_stop_task(), publish_timeout(), report_uri(), 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_CONTAINER_MetaData meta,
const struct GNUNET_FS_Uri uri,
const struct GNUNET_FS_BlockOptions bo,
enum GNUNET_FS_PublishOptions  options,
GNUNET_FS_PublishContinuation  cont,
void *  cont_cls 
)

Publish a KBlock on GNUnet.

Parameters
hhandle to the file sharing subsystem
ksk_urikeywords to use
metametadata to use
uriURI to refer to in the KBlock
boblock options
optionspublication options
contcontinuation
cont_clsclosure for cont
Returns
NULL on error (cont will still be called)

Publish a KBlock on GNUnet.

Parameters
hhandle to the file sharing subsystem
ksk_urikeywords to use
metametadata to use
uriURI to refer to in the KBlock
boper-block options
optionspublication options
contcontinuation
cont_clsclosure for cont
Returns
NULL on error ('cont' will still be called)

Definition at line 187 of file fs_publish_ksk.c.

194 {
195  struct GNUNET_FS_PublishKskContext *pkc;
196 
197  GNUNET_assert (NULL != uri);
199  pkc->h = h;
200  pkc->bo = *bo;
201  pkc->options = options;
202  pkc->cont = cont;
203  pkc->cont_cls = cont_cls;
206  {
207  pkc->dsh = GNUNET_DATASTORE_connect (h->cfg);
208  if (NULL == pkc->dsh)
209  {
210  cont (cont_cls,
211  NULL,
212  _ ("Could not connect to datastore."));
213  GNUNET_free (pkc);
214  return NULL;
215  }
216  }
217  pkc->uri = GNUNET_FS_uri_dup (uri);
220  return pkc;
221 }
static void publish_ksk_cont(void *cls)
Continuation of GNUNET_FS_publish_ksk() that performs the actual publishing operation (iterating over...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1267
Context for the KSK publication.
struct GNUNET_FS_Uri * uri
URI to publish.
struct GNUNET_FS_Uri * ksk_uri
Keywords to use.
struct GNUNET_DATASTORE_Handle * dsh
Handle to the datastore, NULL if we are just simulating.
struct GNUNET_CONTAINER_MetaData * meta
Metadata to use.
enum GNUNET_FS_PublishOptions options
Options to use.
struct GNUNET_SCHEDULER_Task * ksk_task
Current task.
struct GNUNET_FS_BlockOptions bo
When should the KBlocks expire?
void * cont_cls
Closure for cont.
struct GNUNET_FS_Handle * h
Global FS context.
GNUNET_FS_PublishContinuation cont
Function to call once we're done.

References _, GNUNET_FS_PublishKskContext::bo, bo, GNUNET_ARM_Handle::cfg, GNUNET_FS_PublishKskContext::cont, GNUNET_FS_PublishKskContext::cont_cls, GNUNET_FS_PublishKskContext::dsh, GNUNET_assert, GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_DATASTORE_connect(), GNUNET_free, GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY, GNUNET_FS_uri_dup(), GNUNET_new, GNUNET_SCHEDULER_add_now(), h, GNUNET_FS_PublishKskContext::h, GNUNET_FS_PublishKskContext::ksk_task, GNUNET_FS_PublishKskContext::ksk_uri, GNUNET_FS_PublishKskContext::meta, meta, options, GNUNET_FS_PublishKskContext::options, publish_ksk_cont(), GNUNET_FS_PublishKskContext::uri, and 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
pkccontext of the operation to abort.

Definition at line 230 of file fs_publish_ksk.c.

231 {
232  if (NULL != pkc->ksk_task)
233  {
235  pkc->ksk_task = NULL;
236  }
237  if (NULL != pkc->uc)
238  {
240  pkc->uc = NULL;
241  }
242  if (NULL != pkc->dsh)
243  {
245  pkc->dsh = NULL;
246  }
249  GNUNET_FS_uri_destroy (pkc->uri);
250  GNUNET_free (pkc);
251 }
void GNUNET_FS_publish_ublock_cancel_(struct GNUNET_FS_PublishUblockContext *uc)
Abort UBlock publishing operation.
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
struct GNUNET_FS_PublishUblockContext * uc
UBlock publishing operation that is active.

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

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

Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_publish_sks()

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

Publish an SBlock on GNUnet.

Parameters
hhandle to the file sharing subsystem
nsnamespace to publish in
identifieridentifier to use
updateupdate identifier to use
metametadata to use
uriURI to refer to in the SBlock
boblock options
optionspublication options
contcontinuation
cont_clsclosure for cont
Returns
NULL on error (cont will still be called)

Definition at line 427 of file fs_namespace.c.

437 {
438  struct GNUNET_FS_PublishSksContext *psc;
439  struct GNUNET_FS_Uri *sks_uri;
440 
441  sks_uri = GNUNET_new (struct GNUNET_FS_Uri);
442  sks_uri->type = GNUNET_FS_URI_SKS;
443  sks_uri->data.sks.identifier = GNUNET_strdup (identifier);
445 
447  psc->h = h;
448  psc->uri = sks_uri;
449  psc->cont = cont;
450  psc->cont_cls = cont_cls;
451  psc->ns = *ns;
453  {
454  psc->dsh = GNUNET_DATASTORE_connect (h->cfg);
455  if (NULL == psc->dsh)
456  {
457  sks_publish_cont (psc, _ ("Failed to connect to datastore."));
458  return NULL;
459  }
460  }
461  if (NULL != update)
462  {
463  psc->nsn = GNUNET_new (struct NamespaceUpdateNode);
464  psc->nsn->id = GNUNET_strdup (identifier);
465  psc->nsn->update = GNUNET_strdup (update);
467  psc->nsn->uri = GNUNET_FS_uri_dup (uri);
468  }
470  psc->dsh,
471  identifier,
472  update,
473  ns,
474  meta,
475  uri,
476  bo,
477  options,
479  psc);
480  return psc;
481 }
static void sks_publish_cont(void *cls, const char *msg)
Function called by the UBlock construction with the result from the PUT (UBlock) request.
Definition: fs_namespace.c:396
struct GNUNET_FS_PublishUblockContext * GNUNET_FS_publish_ublock_(struct GNUNET_FS_Handle *h, struct GNUNET_DATASTORE_Handle *dsh, const char *label, const char *ulabel, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns, const struct GNUNET_CONTAINER_MetaData *meta, const struct GNUNET_FS_Uri *uri, const struct GNUNET_FS_BlockOptions *bo, enum GNUNET_FS_PublishOptions options, GNUNET_FS_UBlockContinuation cont, void *cont_cls)
Publish a UBlock.
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:186
Context for the SKS publication.
Definition: fs_namespace.c:344
struct GNUNET_CRYPTO_EcdsaPrivateKey ns
Namespace we're publishing to.
Definition: fs_namespace.c:359
GNUNET_FS_PublishContinuation cont
Function to call once we're done.
Definition: fs_namespace.c:374
struct GNUNET_DATASTORE_Handle * dsh
Handle to the datastore.
Definition: fs_namespace.c:364
void * cont_cls
Closure for cont.
Definition: fs_namespace.c:379
struct NamespaceUpdateNode * nsn
Namespace update node to add to namespace on success (or to be deleted if publishing failed).
Definition: fs_namespace.c:354
struct GNUNET_FS_PublishUblockContext * uc
Handle for our UBlock operation request.
Definition: fs_namespace.c:384
struct GNUNET_FS_Handle * h
Handle to FS.
Definition: fs_namespace.c:369
struct GNUNET_FS_Uri * uri
URI of the new entry in the namespace.
Definition: fs_namespace.c:348
char * identifier
Human-readable identifier chosen for this entry in the namespace.
Definition: fs_api.h:204
Information about an (updateable) node in the namespace.
Definition: fs_namespace.c:41
struct GNUNET_FS_Uri * uri
URI of this entry in the namespace.
Definition: fs_namespace.c:60
char * update
Identifier of children of this node.
Definition: fs_namespace.c:50
char * id
Identifier for this node.
Definition: fs_namespace.c:45
struct GNUNET_CONTAINER_MetaData * md
Metadata for this entry.
Definition: fs_namespace.c:55

References _, bo, GNUNET_ARM_Handle::cfg, GNUNET_FS_PublishSksContext::cont, GNUNET_FS_PublishSksContext::cont_cls, GNUNET_FS_Uri::data, GNUNET_FS_PublishSksContext::dsh, GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_DATASTORE_connect(), GNUNET_FS_PUBLISH_OPTION_SIMULATE_ONLY, GNUNET_FS_publish_ublock_(), GNUNET_FS_uri_dup(), GNUNET_FS_URI_SKS, GNUNET_new, GNUNET_strdup, h, GNUNET_FS_PublishSksContext::h, NamespaceUpdateNode::id, GNUNET_FS_Uri::identifier, NamespaceUpdateNode::md, meta, 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, NamespaceUpdateNode::uri, GNUNET_FS_PublishSksContext::uri, and 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
psccontext of the operation to abort.

Definition at line 490 of file fs_namespace.c.

491 {
492  if (NULL != psc->uc)
493  {
495  psc->uc = NULL;
496  }
497  if (NULL != psc->dsh)
498  {
500  psc->dsh = NULL;
501  }
502  GNUNET_FS_uri_destroy (psc->uri);
503  if (NULL != psc->nsn)
504  {
506  GNUNET_FS_uri_destroy (psc->nsn->uri);
507  GNUNET_free (psc->nsn->id);
508  GNUNET_free (psc->nsn->update);
509  GNUNET_free (psc->nsn);
510  }
511  GNUNET_free (psc);
512 }

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

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

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
hhandle to the file sharing subsystem
iteratorfunction to call on each indexed file
iterator_clsclosure for iterator
Returns
NULL on error (iterator is not called)

Definition at line 162 of file fs_list_indexed.c.

165 {
169  GNUNET_MQ_hd_fixed_size (index_info_end,
171  struct GNUNET_MessageHeader,
172  gic),
173  GNUNET_MQ_hd_var_size (index_info,
175  struct IndexInfoMessage,
176  gic),
178  };
179  struct GNUNET_MQ_Envelope *env;
180  struct GNUNET_MessageHeader *msg;
181 
183  "fs",
184  handlers,
186  h);
187  if (NULL == gic->mq)
188  {
190  _ ("Failed to not connect to `%s' service.\n"),
191  "fs");
192  GNUNET_free (gic);
193  return NULL;
194  }
195  gic->iterator = iterator;
196  gic->iterator_cls = iterator_cls;
197  env = GNUNET_MQ_msg (msg,
200  env);
201  return gic;
202 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
static void mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
static struct GNUNET_FS_GetIndexedContext * gic
Handle for the index listing operation.
Definition: gnunet-fs.c:41
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1056
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:303
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:71
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET
Request from client for list of indexed files.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY
Reply to client with an indexed file name.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END
Reply to client indicating end of list.
Context for GNUNET_FS_get_indexed_files().
void * iterator_cls
Closure for iterator.
GNUNET_FS_IndexedFileProcessor iterator
Function to call for each indexed file.
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Message handler for a specific message type.
Header for all communications.
Message send by FS service in response to a request asking for a list of all indexed files.
Definition: fs.h:196

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, 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
gicoperation to cancel

Definition at line 211 of file fs_list_indexed.c.

212 {
214  GNUNET_free (gic);
215 }
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:686

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
hhandle to the file sharing subsystem
filenamefile to unindex
cctxinitial value for the client context
Returns
NULL on error, otherwise handle

Definition at line 795 of file fs_unindex.c.

798 {
800  struct GNUNET_FS_ProgressInfo pi;
801  uint64_t size;
802 
803  if (GNUNET_OK !=
805  &size,
806  GNUNET_YES,
807  GNUNET_YES))
808  return NULL;
810  uc->h = h;
813  uc->file_size = size;
814  uc->client_info = cctx;
817  pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
819  uc->fhc =
821  filename,
826  uc);
827  return uc;
828 }
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:47
void GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
Synchronize this unindex struct with its mirror on disk.
Definition: fs_api.c:1822
void GNUNET_FS_unindex_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_UnindexContext *uc, uint64_t offset)
Fill in all of the generic fields for an unindex event and call the callback.
Definition: fs_unindex.c:84
void GNUNET_FS_unindex_signal_suspend_(void *cls)
Create SUSPEND event for the given unindex operation and then clean up our state (without stop signal...
Definition: fs_unindex.c:727
void GNUNET_FS_unindex_process_hash_(void *cls, const struct GNUNET_HashCode *file_id)
Function called once the hash of the file that is being unindexed has been computed.
Definition: fs_unindex.c:694
static struct GNUNET_FS_UnindexContext * uc
struct GNUNET_CRYPTO_FileHashContext * GNUNET_CRYPTO_hash_file(enum GNUNET_SCHEDULER_Priority priority, const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls)
Compute the hash of an entire file.
@ GNUNET_SCHEDULER_PRIORITY_IDLE
Run when otherwise idle.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:110
static unsigned int size
Size of the "table".
Definition: peer.c:67
void * cctx
Client context pointer (set the last time by the client for this operation; initially NULL on START/R...
Handle for controlling an unindexing operation.
Definition: fs_api.h:1350
void * client_info
Pointer kept for the client.
Definition: fs_api.h:1407
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1453
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
Definition: fs_api.h:1443
struct TopLevelActivity * top
Our top-level activity entry.
Definition: fs_api.h:1365
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1385
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1360
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1448

References GNUNET_FS_ProgressInfo::cctx, GNUNET_FS_UnindexContext::client_info, GNUNET_FS_UnindexContext::fhc, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, 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, pi, size, GNUNET_FS_UnindexContext::start_time, GNUNET_FS_UnindexContext::top, and uc.

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
uchandle

Definition at line 837 of file fs_unindex.c.

838 {
839  struct GNUNET_FS_ProgressInfo pi;
840 
841  if (NULL != uc->dscan)
842  {
844  uc->dscan = NULL;
845  }
846  if (NULL != uc->dqe)
847  {
849  uc->dqe = NULL;
850  }
851  if (NULL != uc->fhc)
852  {
854  uc->fhc = NULL;
855  }
856  if (NULL != uc->mq)
857  {
859  uc->mq = NULL;
860  }
861  if (NULL != uc->dsh)
862  {
864  uc->dsh = NULL;
865  }
866  if (NULL != uc->ksk_uri)
867  {
869  uc->ksk_uri = NULL;
870  }
871  if (NULL != uc->tc)
872  {
874  uc->tc = NULL;
875  }
876  if (uc->fh != NULL)
877  {
879  uc->fh = NULL;
880  }
881  GNUNET_FS_end_top (uc->h, uc->top);
882  if (uc->serialization != NULL)
883  {
885  uc->serialization);
887  uc->serialization = NULL;
888  }
890  pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
892  (uc->state ==
894  GNUNET_break (NULL == uc->client_info);
895  GNUNET_free (uc->emsg);
897  GNUNET_free (uc);
898 }
@ UNINDEX_STATE_COMPLETE
We're done.
Definition: fs_api.h:1337
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1306
void GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
Abort the scan.
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_FS_TreeEncoder * tc
Merkle-ish tree encoder context.
Definition: fs_api.h:1412
struct GNUNET_FS_DirScanner * dscan
Directory scanner to find keywords (KBlock removal).
Definition: fs_api.h:1370
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1463
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1438
struct GNUNET_DISK_FileHandle * fh
Handle used to read the file.
Definition: fs_api.h:1417
struct GNUNET_DATASTORE_QueueEntry * dqe
Handle to datastore 'get_key' operation issued for obtaining KBlocks.
Definition: fs_api.h:1423
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service, only valid during the UNINDEX_STATE_DS_NOTIFY phase.
Definition: fs_api.h:1402
char * serialization
Short name under which we are serializing the state of this operation.
Definition: fs_api.h:1390
struct GNUNET_FS_Uri * ksk_uri
Keywords found (telling us which KBlocks to remove).
Definition: fs_api.h:1375
struct GNUNET_MQ_Handle * mq
Connection to the FS service, only valid during the UNINDEX_STATE_FS_NOTIFY phase.
Definition: fs_api.h:1396

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, pi, GNUNET_FS_UnindexContext::serialization, GNUNET_FS_UnindexContext::state, GNUNET_FS_UnindexContext::tc, GNUNET_FS_UnindexContext::top, uc, and UNINDEX_STATE_COMPLETE.

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
hfs handle to use
nsnamespace to inspect for updateable content
next_idID to look for; use NULL to look for SCC roots
ipfunction to call on each updateable identifier
ip_clsclosure 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
hfs handle to use
nsnamespace to inspect for updateable content
next_idID to look for; use NULL to look for tree roots
ipfunction to call on each updateable identifier
ip_clsclosure for ip

Definition at line 666 of file fs_namespace.c.

672 {
673  unsigned int i;
674  unsigned int nug;
675  struct GNUNET_HashCode hc;
676  struct NamespaceUpdateNode *nsn;
677  struct ProcessUpdateClosure pc;
678  struct FindTreeClosure fc;
680 
682  if (NULL == uig->update_nodes)
683  {
685  "No updateable nodes found for ID `%s'\n",
686  next_id);
688  return; /* no nodes */
689  }
690  uig->update_map =
692  GNUNET_NO);
693  for (i = 0; i < uig->update_node_count; i++)
694  {
695  nsn = uig->update_nodes[i];
696  GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
698  uig->update_map,
699  &hc,
700  nsn,
702  }
703  if (NULL != next_id)
704  {
705  GNUNET_CRYPTO_hash (next_id, strlen (next_id), &hc);
706  pc.ip = ip;
707  pc.ip_cls = ip_cls;
709  &hc,
711  &pc);
713  return;
714  }
716  "Calculating TREEs to find roots of update trees\n");
717  /* Find heads of TREEs in update graph */
718  nug = ++uig->nug_gen;
719  fc.tree_array = NULL;
720  fc.tree_array_size = 0;
721 
722  for (i = 0; i < uig->update_node_count; i++)
723  {
724  nsn = uig->update_nodes[i];
725  if (nsn->nug == nug)
726  {
728  "TREE of node `%s' is %u\n",
729  nsn->id,
730  nsn->nug);
731  continue; /* already placed in TREE */
732  }
733  GNUNET_CRYPTO_hash (nsn->update, strlen (nsn->update), &hc);
734  nsn->nug = nug;
735  nsn->tree_id = UINT_MAX;
736  fc.id = UINT_MAX;
737  fc.nug = nug;
738  fc.uig = uig;
740  &hc,
741  &find_trees,
742  &fc);
743  if (UINT_MAX == fc.id)
744  {
745  /* start new TREE */
746  for (fc.id = 0; fc.id < fc.tree_array_size; fc.id++)
747  {
748  if (NULL == fc.tree_array[fc.id])
749  {
750  fc.tree_array[fc.id] = nsn;
751  nsn->tree_id = fc.id;
752  break;
753  }
754  }
755  if (fc.id == fc.tree_array_size)
756  {
757  GNUNET_array_append (fc.tree_array, fc.tree_array_size, nsn);
758  nsn->tree_id = fc.id;
759  }
761  "Starting new TREE %u with node `%s'\n",
762  nsn->tree_id,
763  nsn->id);
764  /* put all nodes with same identifier into this TREE */
765  GNUNET_CRYPTO_hash (nsn->id, strlen (nsn->id), &hc);
766  fc.id = nsn->tree_id;
767  fc.nug = nug;
768  fc.uig = uig;
770  &hc,
771  &find_trees,
772  &fc);
773  }
774  else
775  {
776  /* make head of TREE "id" */
777  fc.tree_array[fc.id] = nsn;
778  nsn->tree_id = fc.id;
779  }
781  "TREE of node `%s' is %u\n",
782  nsn->id,
783  fc.id);
784  }
785  for (i = 0; i < fc.tree_array_size; i++)
786  {
787  nsn = fc.tree_array[i];
788  if (NULL != nsn)
789  {
791  "Root of TREE %u is node `%s'\n",
792  i,
793  nsn->id);
794  ip (ip_cls, nsn->id, nsn->uri, nsn->md, nsn->update);
795  }
796  }
797  GNUNET_array_grow (fc.tree_array, fc.tree_array_size, 0);
798  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Done processing TREEs\n");
800 }
static struct GNUNET_FS_UpdateInformationGraph * read_update_information_graph(struct GNUNET_FS_Handle *h, const struct GNUNET_CRYPTO_EcdsaPrivateKey *ns)
Read the namespace update node graph from a file.
Definition: fs_namespace.c:248
static int process_update_node(void *cls, const struct GNUNET_HashCode *key, void *value)
Call the iterator in the closure for each node.
Definition: fs_namespace.c:543
static void free_update_information_graph(struct GNUNET_FS_UpdateInformationGraph *uig)
Release memory occupied by UIG datastructure.
Definition: fs_namespace.c:162
static int find_trees(void *cls, const struct GNUNET_HashCode *key, void *value)
Find all nodes reachable from the current node (including the current node itself).
Definition: fs_namespace.c:606
static char * next_id
Command-line option for namespace publishing: identifier for updates to this publication.
int GNUNET_CONTAINER_multihashmap_get_multiple(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map that match a particular key.
enum GNUNET_GenericReturnValue GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
Closure for 'find_trees'.
Definition: fs_namespace.c:557
Handle to update information for a namespace.
Definition: fs_namespace.c:79
unsigned int nug_gen
Generator for unique nug numbers.
Definition: fs_namespace.c:114
unsigned int update_node_count
Size of the update nodes array.
Definition: fs_namespace.c:104
struct GNUNET_CONTAINER_MultiHashMap * update_map
Hash map mapping identifiers of update nodes to the update nodes (initialized on-demand).
Definition: fs_namespace.c:99
struct NamespaceUpdateNode ** update_nodes
Array with information about nodes in the namespace.
Definition: fs_namespace.c:88
unsigned int tree_id
TREE this entry belongs to (if nug is current).
Definition: fs_namespace.c:71
unsigned int nug
Namespace update generation ID.
Definition: fs_namespace.c:66
Closure for 'process_update_node'.
Definition: fs_namespace.c:519

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
hhandle to the file sharing subsystem
urispecifies the search parameters; can be a KSK URI or an SKS URI.
anonymitydesired level of anonymity
optionsoptions for the search
cctxinitial value for the client context
Returns
context that can be used to control the search

Definition at line 1606 of file fs_search.c.

1609 {
1610  struct GNUNET_FS_SearchContext *ret;
1611 
1612  ret = search_start (h, uri, anonymity, options, cctx, NULL);
1613  if (NULL == ret)
1614  return NULL;
1616  return ret;
1617 }
static struct GNUNET_FS_SearchContext * search_start(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, uint32_t anonymity, enum GNUNET_FS_SearchOptions options, void *cctx, struct GNUNET_FS_SearchResult *psearch)
Start search for content, internal API.
Definition: fs_search.c:1333
void GNUNET_FS_search_signal_suspend_(void *cls)
Create SUSPEND event for the given search operation and then clean up our state (without stop signal)...
Definition: fs_search.c:1554
static unsigned int anonymity
Handle for controlling a search.
Definition: fs_api.h:1510

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
sccontext for the search that should be paused

Definition at line 1626 of file fs_search.c.

1627 {
1628  struct GNUNET_FS_ProgressInfo pi;
1629 
1630  if (NULL != sc->task)
1631  {
1633  sc->task = NULL;
1634  }
1635  if (NULL != sc->mq)
1636  {
1637  GNUNET_MQ_destroy (sc->mq);
1638  sc->mq = NULL;
1639  }
1643  sc);
1646  sc->h,
1647  sc);
1648 }
void GNUNET_FS_search_sync_(struct GNUNET_FS_SearchContext *sc)
Synchronize this search struct with its mirror on disk.
Definition: fs_api.c:2247
void * GNUNET_FS_search_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_Handle *h, struct GNUNET_FS_SearchContext *sc)
Fill in all of the generic fields for a search event and call the callback.
Definition: fs_search.c:48
static int search_result_freeze_probes(void *cls, const struct GNUNET_HashCode *key, void *value)
Freeze probes for the given search result.
Definition: fs_search.c:1461
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:84
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiHashMap * master_result_map
Map that contains a struct GNUNET_FS_SearchResult for each result that was found in the search.
Definition: fs_api.h:1558
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1540
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the search is being stopped (i...
Definition: fs_api.h:1582
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1514
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1535

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, pi, sc, search_result_freeze_probes(), 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
sccontext for the search that should be resumed

Definition at line 1657 of file fs_search.c.

1658 {
1659  struct GNUNET_FS_ProgressInfo pi;
1660 
1661  GNUNET_assert (NULL == sc->mq);
1662  GNUNET_assert (NULL == sc->task);
1663  do_reconnect (sc);
1669 }
static int search_result_resume_probes(void *cls, const struct GNUNET_HashCode *key, void *value)
Resume probes for the given search result.
Definition: fs_search.c:1493
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1271

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, pi, sc, search_result_resume_probes(), 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
sccontext for the search that should be stopped

Definition at line 1765 of file fs_search.c.

1766 {
1767  struct GNUNET_FS_ProgressInfo pi;
1768  unsigned int i;
1769 
1770  if (NULL != sc->top)
1771  GNUNET_FS_end_top (sc->h, sc->top);
1774  sc);
1775  if (NULL != sc->psearch_result)
1776  sc->psearch_result->update_search = NULL;
1777  if (NULL != sc->serialization)
1778  {
1780  (NULL != sc->psearch_result)
1783  sc->serialization);
1785  (NULL != sc->psearch_result)
1788  sc->serialization);
1790  }
1793  sc->h,
1794  sc);
1795  GNUNET_break (NULL == sc->client_info);
1796  if (NULL != sc->task)
1797  {
1799  sc->task = NULL;
1800  }
1801  if (NULL != sc->mq)
1802  {
1803  GNUNET_MQ_destroy (sc->mq);
1804  sc->mq = NULL;
1805  }
1809  if (NULL != sc->requests)
1810  {
1812  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1814  }
1815  GNUNET_free (sc->requests);
1816  GNUNET_free (sc->emsg);
1818  GNUNET_free (sc);
1819 }
void GNUNET_FS_remove_sync_dir_(struct GNUNET_FS_Handle *h, const char *ext, const char *uni)
Remove serialization/deserialization directory from disk.
Definition: fs_api.c:786
#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH
Name of the directory with sub-searches (namespace-updates).
Definition: fs_api.h:59
static int search_result_stop(void *cls, const struct GNUNET_HashCode *key, void *value)
Signal stop for the given search result.
Definition: fs_search.c:1681
static int search_result_free(void *cls, const struct GNUNET_HashCode *key, void *value)
Free the given search result.
Definition: fs_search.c:1736
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1323
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1550
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1564
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1545
struct GNUNET_FS_SearchResult * psearch_result
For update-searches, link to the search result that triggered the update search; otherwise NULL.
Definition: fs_api.h:1530
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1519
struct GNUNET_FS_Uri * uri
List of keywords that we're looking for.
Definition: fs_api.h:1524
struct GNUNET_FS_SearchContext * update_search
If this search result triggered an update search, this field links to the update search.
Definition: fs_api.h:551
struct GNUNET_CONTAINER_MultiHashMap * results
Map that contains a "struct GNUNET_FS_SearchResult" for each result that was found under this keyword...
Definition: fs_api.h:1496

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, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, pi, GNUNET_FS_SearchContext::psearch_result, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, sc, search_result_free(), search_result_stop(), GNUNET_FS_SearchContext::serialization, 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_CONTAINER_MetaData meta,
void *  client_info,
uint32_t  anonymity 
)

Start download probes for the given search result.

Parameters
hfile-sharing handle to use for the operation
uriURI to probe
metameta data associated with the URI
client_infoclient info pointer to use for associated events
anonymityanonymity level to use for the probes
Returns
the search result handle to access the probe activity

Definition at line 488 of file fs_search.c.

493 {
494  struct GNUNET_FS_SearchResult *sr;
495 
496  GNUNET_assert (NULL != h);
497  GNUNET_assert (NULL != uri);
498  sr = GNUNET_new (struct GNUNET_FS_SearchResult);
499  sr->h = h;
500  sr->uri = GNUNET_FS_uri_dup (uri);
502  sr->client_info = client_info;
503  sr->anonymity = anonymity;
505  return sr;
506 }
void GNUNET_FS_search_start_probe_(struct GNUNET_FS_SearchResult *sr)
Start download probes for the given search result.
Definition: fs_search.c:430
Information we store for each search result.
Definition: fs_api.h:498
void * client_info
Client info for this search result.
Definition: fs_api.h:533
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:523
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:502
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:528
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:588

References GNUNET_FS_SearchResult::anonymity, anonymity, GNUNET_FS_SearchResult::client_info, GNUNET_assert, GNUNET_CONTAINER_meta_data_duplicate(), GNUNET_FS_search_start_probe_(), GNUNET_FS_uri_dup(), GNUNET_new, h, GNUNET_FS_SearchResult::h, GNUNET_FS_SearchResult::meta, meta, GNUNET_FS_SearchResult::uri, and 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
srsearch result to stop probing for (freed)
Returns
the value of the 'client_info' pointer

Definition at line 539 of file fs_search.c.

540 {
541  void *client_info;
542 
543  GNUNET_assert (NULL == sr->sc);
547  client_info = sr->client_info;
548  GNUNET_free (sr);
549  return client_info;
550 }
static void GNUNET_FS_search_stop_probe_(struct GNUNET_FS_SearchResult *sr)
Stop probing activity associated with a search result.
Definition: fs_search.c:515
struct GNUNET_FS_SearchContext * sc
Search context this result belongs to; can be NULL for probes that come from a directory result.
Definition: fs_api.h:518

References GNUNET_FS_SearchResult::client_info, GNUNET_assert, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_free, 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_CONTAINER_MetaData meta,
const char *  filename,
const char *  tempname,
uint64_t  offset,
uint64_t  length,
uint32_t  anonymity,
enum GNUNET_FS_DownloadOptions  options,
void *  cctx,
struct GNUNET_FS_DownloadContext parent 
)

Download parts of a file.

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
hhandle to the file sharing subsystem
urithe URI of the file (determines what to download); CHK or LOC URI
metaknown metadata for the file (can be NULL)
filenamewhere to store the file, maybe NULL (then no file is created on disk and data must be grabbed from the callbacks)
tempnamewhere 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
offsetat what offset should we start the download (typically 0)
lengthhow many bytes should be downloaded starting at offset
anonymityanonymity level to use for the download
optionsvarious download options
cctxinitial value for the client context for this download
parentparent 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.

2110 {
2111  struct GNUNET_FS_DownloadContext *dc;
2112 
2114  uri,
2115  meta,
2116  filename,
2117  tempname,
2118  offset,
2119  length,
2120  anonymity,
2121  options,
2122  cctx);
2123  if (NULL == dc)
2124  return NULL;
2125  dc->parent = parent;
2126  if (NULL != parent)
2128  else if (0 == (GNUNET_FS_DOWNLOAD_IS_PROBE & options))
2129  dc->top =
2131  return dc;
2132 }
void GNUNET_FS_download_signal_suspend_(void *cls)
Create SUSPEND event for the given download operation and then clean up our state (without stop signa...
Definition: fs_download.c:1952
struct GNUNET_FS_DownloadContext * create_download_context(struct GNUNET_FS_Handle *h, const struct GNUNET_FS_Uri *uri, const struct GNUNET_CONTAINER_MetaData *meta, const char *filename, const char *tempname, uint64_t offset, uint64_t length, uint32_t anonymity, enum GNUNET_FS_DownloadOptions options, void *cctx)
Helper function to setup the download context.
Definition: fs_download.c:2028
static struct GNUNET_FS_DownloadContext * dc
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Context for controlling a download.
Definition: fs_api.h:1743
uint64_t offset
What is the first offset that we're interested in?
Definition: fs_api.h:1877
struct GNUNET_FS_DownloadContext * child_tail
Tail of list of child downloads.
Definition: fs_api.h:1779
struct GNUNET_FS_DownloadContext * child_head
Head of list of child downloads.
Definition: fs_api.h:1774
uint64_t length
How many bytes starting from offset are desired? This is NOT the overall length of the file!
Definition: fs_api.h:1883
struct GNUNET_FS_DownloadContext * parent
Parent download (used when downloading files in directories).
Definition: fs_api.h:1763
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1747
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1752

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 download_fs_connect_complete_cb(), 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
hhandle to the file sharing subsystem
srthe search result to use for the download (determines uri and meta data and associations)
filenamewhere to store the file, maybe NULL (then no file is created on disk and data must be grabbed from the callbacks)
tempnamewhere 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
offsetat what offset should we start the download (typically 0)
lengthhow many bytes should be downloaded starting at offset
anonymityanonymity level to use for the download
optionsvarious download options
cctxinitial 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.

2145 {
2146  struct GNUNET_FS_DownloadContext *dc;
2147 
2148  if ((NULL == sr) || (NULL != sr->download))
2149  {
2150  GNUNET_break (0);
2151  return NULL;
2152  }
2154  sr->uri,
2155  sr->meta,
2156  filename,
2157  tempname,
2158  offset,
2159  length,
2160  anonymity,
2161  options,
2162  cctx);
2163  if (NULL == dc)
2164  return NULL;
2165  dc->search = sr;
2166  sr->download = dc;
2167  if (NULL != sr->probe_ctx)
2168  {
2170  sr->probe_ctx = NULL;
2172  }
2173  return dc;
2174 }
void GNUNET_FS_stop_probe_ping_task_(struct GNUNET_FS_SearchResult *sr)
Stop the ping task for this search result.
Definition: fs_search.c:409