GNUnet  0.10.x
Data Structures | Macros | Typedefs | Enumerations | Functions
fs_api.h File Reference

shared definitions for the FS library More...

#include "gnunet_constants.h"
#include "gnunet_datastore_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_fs_service.h"
#include "gnunet_block_lib.h"
#include "block_fs.h"
#include "fs.h"
Include dependency graph for fs_api.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures

struct  FileIdentifier
 complete information needed to download a file. More...
 
struct  Location
 Information about a file and its location (peer claiming to share the file). More...
 
struct  GNUNET_FS_Uri
 A Universal Resource Identifier (URI), opaque. More...
 
struct  GNUNET_FS_FileInformation
 Information for a file or directory that is about to be published. More...
 
struct  GNUNET_FS_QueueEntry
 Entry in the job queue. More...
 
struct  GNUNET_FS_SearchResult
 Information we store for each search result. More...
 
struct  TopLevelActivity
 We track all of the top-level activities of FS so that we can signal 'suspend' on shutdown. More...
 
struct  GNUNET_FS_Handle
 Master context for most FS operations. More...
 
struct  GNUNET_FS_PublishContext
 Handle for controlling a publication process. More...
 
struct  GNUNET_FS_UnindexContext
 Handle for controlling an unindexing operation. More...
 
struct  SearchRequestEntry
 Information we keep for each keyword in a keyword search. More...
 
struct  GNUNET_FS_SearchContext
 Handle for controlling a search. More...
 
struct  DownloadRequest
 Information about an active download request. More...
 
struct  GNUNET_FS_DownloadContext
 Context for controlling a download. More...
 

Macros

#define CHK_PER_INODE   256
 Pick a multiple of 2 here to achive 8-byte alignment! We also probably want DBlocks to have (roughly) the same size as IBlocks. More...
 
#define MAX_INLINE_SIZE   65536
 Maximum size for a file to be considered for inlining in a directory. More...
 
#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH   "search"
 Name of the directory with top-level searches. More...
 
#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH   "search-child"
 Name of the directory with sub-searches (namespace-updates). More...
 
#define GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD   "download"
 Name of the directory with master downloads (not associated with search or part of another download). More...
 
#define GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD   "download-child"
 Name of the directory with downloads that are part of another download or a search. More...
 
#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH   "publish"
 Name of the directory with publishing operations. More...
 
#define GNUNET_FS_SYNC_PATH_FILE_INFO   "publish-file"
 Name of the directory with files that are being published. More...
 
#define GNUNET_FS_SYNC_PATH_MASTER_UNINDEX   "unindex"
 Name of the directory with unindex operations. More...
 

Typedefs

typedef void(* SuspendSignalFunction) (void *cls)
 Function signature of the functions that can be called to trigger suspend signals and clean-up for top-level activities. More...
 

Enumerations

enum  GNUNET_FS_UriType { GNUNET_FS_URI_CHK, GNUNET_FS_URI_SKS, GNUNET_FS_URI_KSK, GNUNET_FS_URI_LOC }
 Types of URIs. More...
 
enum  GNUNET_FS_QueuePriority { GNUNET_FS_QUEUE_PRIORITY_PROBE, GNUNET_FS_QUEUE_PRIORITY_NORMAL }
 Priorities for the queue. More...
 
enum  UnindexState {
  UNINDEX_STATE_HASHING = 0, UNINDEX_STATE_DS_REMOVE = 1, UNINDEX_STATE_EXTRACT_KEYWORDS = 2, UNINDEX_STATE_DS_REMOVE_KBLOCKS = 3,
  UNINDEX_STATE_FS_NOTIFY = 4, UNINDEX_STATE_COMPLETE = 5, UNINDEX_STATE_ERROR = 6
}
 Phases of unindex processing (state machine). More...
 
enum  BlockRequestState {
  BRS_INIT = 0, BRS_RECONSTRUCT_DOWN = 1, BRS_RECONSTRUCT_META_UP = 2, BRS_RECONSTRUCT_UP = 3,
  BRS_CHK_SET = 4, BRS_DOWNLOAD_DOWN = 5, BRS_DOWNLOAD_UP = 6, BRS_ERROR = 7
}
 FSM for possible states a block can go through. More...
 

Functions

struct GNUNET_FS_QueueEntryGNUNET_FS_queue_ (struct GNUNET_FS_Handle *h, GNUNET_SCHEDULER_TaskCallback start, GNUNET_SCHEDULER_TaskCallback stop, void *cls, unsigned int blocks, enum GNUNET_FS_QueuePriority priority)
 Add a job to the queue. More...
 
void GNUNET_FS_dequeue_ (struct GNUNET_FS_QueueEntry *qe)
 Dequeue a job from the queue. More...
 
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. More...
 
void * GNUNET_FS_make_file_reader_context_ (const char *filename)
 Create the closure for the GNUNET_FS_data_reader_file_() callback. More...
 
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. More...
 
void * GNUNET_FS_search_probe_progress_ (void *cls, const struct GNUNET_FS_ProgressInfo *info)
 Notification of FS that a search probe has made progress. More...
 
void GNUNET_FS_publish_main_ (void *cls)
 Main function that performs the upload. More...
 
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. More...
 
void GNUNET_FS_unindex_do_extract_keywords_ (struct GNUNET_FS_UnindexContext *uc)
 Extract the keywords for KBlock removal. More...
 
void GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
 If necessary, connect to the datastore and remove the KBlocks. More...
 
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. More...
 
void GNUNET_FS_download_make_status_ (struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_DownloadContext *dc)
 Fill in all of the generic fields for a download event and call the callback. More...
 
void GNUNET_FS_download_start_task_ (void *cls)
 Task that creates the initial (top-level) download request for the file. More...
 
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. More...
 
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. More...
 
void GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
 Connect to the datastore and remove the blocks. More...
 
int GNUNET_FS_search_start_searching_ (struct GNUNET_FS_SearchContext *sc)
 Build the request and actually initiate the search using the GNUnet FS service. More...
 
void GNUNET_FS_download_start_downloading_ (struct GNUNET_FS_DownloadContext *dc)
 Start the downloading process (by entering the queue). More...
 
void GNUNET_FS_search_start_probe_ (struct GNUNET_FS_SearchResult *sr)
 Start download probes for the given search result. More...
 
void GNUNET_FS_remove_sync_file_ (struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
 Remove serialization/deserialization file from disk. More...
 
void GNUNET_FS_remove_sync_dir_ (struct GNUNET_FS_Handle *h, const char *ext, const char *uni)
 Remove serialization/deserialization directory from disk. More...
 
void GNUNET_FS_file_information_sync_ (struct GNUNET_FS_FileInformation *f)
 Synchronize this file-information struct with its mirror on disk. More...
 
void GNUNET_FS_publish_sync_ (struct GNUNET_FS_PublishContext *pc)
 Synchronize this publishing struct with its mirror on disk. More...
 
void GNUNET_FS_unindex_sync_ (struct GNUNET_FS_UnindexContext *uc)
 Synchronize this unindex struct with its mirror on disk. More...
 
void GNUNET_FS_search_sync_ (struct GNUNET_FS_SearchContext *sc)
 Synchronize this search struct with its mirror on disk. More...
 
void GNUNET_FS_search_result_sync_ (struct GNUNET_FS_SearchResult *sr)
 Synchronize this search result with its mirror on disk. More...
 
void GNUNET_FS_download_sync_ (struct GNUNET_FS_DownloadContext *dc)
 Synchronize this download struct with its mirror on disk. More...
 
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). More...
 
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). More...
 
void GNUNET_FS_download_signal_suspend_ (void *cls)
 Create SUSPEND event for the given download operation and then clean up our state (without stop signal). More...
 
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). More...
 
struct TopLevelActivityGNUNET_FS_make_top (struct GNUNET_FS_Handle *h, SuspendSignalFunction ssf, void *ssf_cls)
 Create a top-level activity entry. More...
 
void GNUNET_FS_end_top (struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
 Destroy a top-level activity entry. More...
 
void GNUNET_FS_free_download_request_ (struct DownloadRequest *dr)
 (recursively) free download request structure More...
 
void GNUNET_FS_stop_probe_ping_task_ (struct GNUNET_FS_SearchResult *sr)
 Stop the ping task for this search result. More...
 

Detailed Description

shared definitions for the FS library

Author
Igor Wronsky, Christian Grothoff

Definition in file fs_api.h.

Macro Definition Documentation

◆ CHK_PER_INODE

#define CHK_PER_INODE   256

Pick a multiple of 2 here to achive 8-byte alignment! We also probably want DBlocks to have (roughly) the same size as IBlocks.

With SHA-512, the optimal value is 32768 byte / 128 byte = 256 (128 byte = 2 * 512 bits). DO NOT CHANGE!

Definition at line 43 of file fs_api.h.

Referenced by compute_chk_offset(), compute_disk_offset(), create_download_request(), GNUNET_FS_compute_depth(), GNUNET_FS_tree_calculate_block_size(), GNUNET_FS_tree_compute_iblock_size(), GNUNET_FS_tree_compute_tree_size(), GNUNET_FS_tree_encoder_create(), GNUNET_FS_tree_encoder_next(), and read_download_request().

◆ MAX_INLINE_SIZE

#define MAX_INLINE_SIZE   65536

Maximum size for a file to be considered for inlining in a directory.

Definition at line 49 of file fs_api.h.

Referenced by GNUNET_FS_directory_builder_add(), GNUNET_FS_download_start_task_(), and publish_content().

◆ GNUNET_FS_SYNC_PATH_MASTER_SEARCH

#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH   "search"

◆ GNUNET_FS_SYNC_PATH_CHILD_SEARCH

#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH   "search-child"

Name of the directory with sub-searches (namespace-updates).

Definition at line 59 of file fs_api.h.

Referenced by deserialize_search(), deserialize_search_result(), free_search_context(), GNUNET_FS_search_result_sync_(), GNUNET_FS_search_stop(), and GNUNET_FS_search_sync_().

◆ GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD

#define GNUNET_FS_SYNC_PATH_MASTER_DOWNLOAD   "download"

Name of the directory with master downloads (not associated with search or part of another download).

Definition at line 65 of file fs_api.h.

Referenced by get_download_sync_filename(), GNUNET_FS_download_stop(), and GNUNET_FS_start().

◆ GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD

#define GNUNET_FS_SYNC_PATH_CHILD_DOWNLOAD   "download-child"

Name of the directory with downloads that are part of another download or a search.

Definition at line 71 of file fs_api.h.

Referenced by deserialize_search_result(), get_download_sync_filename(), GNUNET_FS_download_stop(), and search_result_stop().

◆ GNUNET_FS_SYNC_PATH_MASTER_PUBLISH

#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH   "publish"

Name of the directory with publishing operations.

Definition at line 76 of file fs_api.h.

Referenced by GNUNET_FS_publish_stop(), GNUNET_FS_publish_sync_(), and GNUNET_FS_start().

◆ GNUNET_FS_SYNC_PATH_FILE_INFO

#define GNUNET_FS_SYNC_PATH_FILE_INFO   "publish-file"

Name of the directory with files that are being published.

Definition at line 81 of file fs_api.h.

Referenced by deserialize_file_information(), fip_signal_stop(), GNUNET_FS_file_information_sync_(), and GNUNET_FS_publish_stop().

◆ GNUNET_FS_SYNC_PATH_MASTER_UNINDEX

#define GNUNET_FS_SYNC_PATH_MASTER_UNINDEX   "unindex"

Name of the directory with unindex operations.

Definition at line 86 of file fs_api.h.

Referenced by deserialize_unindex_file(), GNUNET_FS_start(), GNUNET_FS_unindex_stop(), and GNUNET_FS_unindex_sync_().

Typedef Documentation

◆ SuspendSignalFunction

typedef void(* SuspendSignalFunction) (void *cls)

Function signature of the functions that can be called to trigger suspend signals and clean-up for top-level activities.

Parameters
clsclosure

Definition at line 1028 of file fs_api.h.

Enumeration Type Documentation

◆ GNUNET_FS_UriType

Types of URIs.

Enumerator
GNUNET_FS_URI_CHK 

Content-hash-key (simple file).

GNUNET_FS_URI_SKS 

Signed key space (file in namespace).

GNUNET_FS_URI_KSK 

Keyword search key (query with keywords).

GNUNET_FS_URI_LOC 

Location (chk with identity of hosting peer).

Definition at line 141 of file fs_api.h.

142 {
147 
152 
157 
162 };
Keyword search key (query with keywords).
Definition: fs_api.h:156
Content-hash-key (simple file).
Definition: fs_api.h:146
Signed key space (file in namespace).
Definition: fs_api.h:151
Location (chk with identity of hosting peer).
Definition: fs_api.h:161

◆ GNUNET_FS_QueuePriority

Priorities for the queue.

Enumerator
GNUNET_FS_QUEUE_PRIORITY_PROBE 

This is a probe (low priority).

GNUNET_FS_QUEUE_PRIORITY_NORMAL 

Default priority.

Definition at line 415 of file fs_api.h.

416 {
421 
426 };
This is a probe (low priority).
Definition: fs_api.h:420
Default priority.
Definition: fs_api.h:425

◆ UnindexState

Phases of unindex processing (state machine).

Enumerator
UNINDEX_STATE_HASHING 

We're currently hashing the file.

UNINDEX_STATE_DS_REMOVE 

We're telling the datastore to delete the respective DBlocks and IBlocks.

UNINDEX_STATE_EXTRACT_KEYWORDS 

Find out which keywords apply.

UNINDEX_STATE_DS_REMOVE_KBLOCKS 

We're telling the datastore to remove KBlocks.

UNINDEX_STATE_FS_NOTIFY 

We're notifying the FS service about the unindexing.

UNINDEX_STATE_COMPLETE 

We're done.

UNINDEX_STATE_ERROR 

We've encountered a fatal error.

Definition at line 1325 of file fs_api.h.

1326 {
1331 
1337 
1342 
1347 
1353 
1358 
1363 };
We're done.
Definition: fs_api.h:1357
Find out which keywords apply.
Definition: fs_api.h:1341
We're notifying the FS service about the unindexing.
Definition: fs_api.h:1352
We're telling the datastore to remove KBlocks.
Definition: fs_api.h:1346
We've encountered a fatal error.
Definition: fs_api.h:1362
We're currently hashing the file.
Definition: fs_api.h:1330
We're telling the datastore to delete the respective DBlocks and IBlocks.
Definition: fs_api.h:1336

◆ BlockRequestState

FSM for possible states a block can go through.

The typical order of progression is linear through the states, alternatives are documented in the comments.

Enumerator
BRS_INIT 

Initial state, block has only been allocated (since it is relevant to the overall download request).

BRS_RECONSTRUCT_DOWN 

We've checked the block on the path down the tree, and the content on disk did match the desired CHK, but not all the way down, so at the bottom some blocks will still need to be reconstructed).

BRS_RECONSTRUCT_META_UP 

We've calculated the CHK bottom-up based on the meta data.

This may work, but if it did we have to write the meta data to disk at the end (and we still need to check against the CHK set on top).

BRS_RECONSTRUCT_UP 

We've calculated the CHK bottom-up based on what we have on disk, which may not be what the desired CHK is.

If the reconstructed CHKs match whatever comes from above, we're done with the respective subtree.

BRS_CHK_SET 

We've determined the real, desired CHK for this block (full tree reconstruction failed), request is now pending.

If the CHK that bubbled up through reconstruction did match the top-level request, the state machine for the subtree would have moved to BRS_DOWNLOAD_UP.

BRS_DOWNLOAD_DOWN 

We've successfully downloaded this block, but the children still need to be either downloaded or verified (download request propagates down).

If the download fails, the state machine for this block may move to BRS_DOWNLOAD_ERROR instead.

BRS_DOWNLOAD_UP 

This block and all of its children have been downloaded successfully (full completion propagates up).

BRS_ERROR 

We got a block back that matched the query but did not hash to the key (malicious publisher or hash collision); this block can never be downloaded (error propagates up).

Definition at line 1630 of file fs_api.h.

1631 {
1636  BRS_INIT = 0,
1637 
1645 
1653 
1660  BRS_RECONSTRUCT_UP = 3,
1661 
1669  BRS_CHK_SET = 4,
1670 
1678  BRS_DOWNLOAD_DOWN = 5,
1679 
1684  BRS_DOWNLOAD_UP = 6,
1685 
1691  BRS_ERROR = 7
1692 };
We've calculated the CHK bottom-up based on what we have on disk, which may not be what the desired C...
Definition: fs_api.h:1660
Initial state, block has only been allocated (since it is relevant to the overall download request)...
Definition: fs_api.h:1636
We've checked the block on the path down the tree, and the content on disk did match the desired CHK...
Definition: fs_api.h:1644
We've calculated the CHK bottom-up based on the meta data.
Definition: fs_api.h:1652
We've successfully downloaded this block, but the children still need to be either downloaded or veri...
Definition: fs_api.h:1678
This block and all of its children have been downloaded successfully (full completion propagates up)...
Definition: fs_api.h:1684
We got a block back that matched the query but did not hash to the key (malicious publisher or hash c...
Definition: fs_api.h:1691
We've determined the real, desired CHK for this block (full tree reconstruction failed), request is now pending.
Definition: fs_api.h:1669

Function Documentation

◆ GNUNET_FS_queue_()

struct GNUNET_FS_QueueEntry* GNUNET_FS_queue_ ( struct GNUNET_FS_Handle h,
GNUNET_SCHEDULER_TaskCallback  start,
GNUNET_SCHEDULER_TaskCallback  stop,
void *  cls,
unsigned int  blocks,
enum GNUNET_FS_QueuePriority  priority 
)

Add a job to the queue.

Parameters
hhandle to the overall FS state
startfunction to call to begin the job
stopfunction to call to pause the job, or on dequeue (if the job was running)
clsclosure for start and stop
blocksnumber of blocks this download has
priorityhow important is this download
Returns
queue handle
Parameters
hhandle to the overall FS state
startfunction to call to begin the job
stopfunction to call to pause the job, or on dequeue (if the job was running)
clsclosure for start and stop
blocksnumber of blocks this jobs uses
priorityhow important is this download
Returns
queue handle

Definition at line 328 of file fs_api.c.

References GNUNET_FS_QueueEntry::blocks, GNUNET_FS_QueueEntry::cls, GNUNET_CONTAINER_DLL_insert_after, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), h, GNUNET_FS_QueueEntry::h, GNUNET_FS_Handle::pending_head, GNUNET_FS_Handle::pending_tail, GNUNET_FS_QueueEntry::priority, process_job_queue(), qe, GNUNET_FS_Handle::queue_job, GNUNET_FS_QueueEntry::queue_time, start, GNUNET_FS_QueueEntry::start, and GNUNET_FS_QueueEntry::stop.

Referenced by GNUNET_FS_download_resume(), and GNUNET_FS_download_start_downloading_().

334 {
335  struct GNUNET_FS_QueueEntry *qe;
336 
337  qe = GNUNET_new (struct GNUNET_FS_QueueEntry);
338  qe->h = h;
339  qe->start = start;
340  qe->stop = stop;
341  qe->cls = cls;
343  qe->blocks = blocks;
344  qe->priority = priority;
346  h->pending_tail, qe);
347  if (NULL != h->queue_job)
351  "Queueing job %p\n",
352  qe);
353  return qe;
354 }
static struct GNUNET_DATASTORE_QueueEntry * qe
Current operation.
struct GNUNET_SCHEDULER_Task * queue_job
Task that processes the jobs in the running and pending queues (and moves jobs around as needed)...
Definition: fs_api.h:1153
static int start
Set if we are to start default services (including ARM).
Definition: gnunet-arm.c:39
struct GNUNET_FS_QueueEntry * pending_head
Head of DLL of pending jobs.
Definition: fs_api.h:1132
static void process_job_queue(void *cls)
Process the jobs in the job queue, possibly starting some and stopping others.
Definition: fs_api.c:111
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_TIME_Absolute queue_time
Time the job was originally queued.
Definition: fs_api.h:472
enum GNUNET_FS_QueuePriority priority
How important is this download?
Definition: fs_api.h:493
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:1273
#define GNUNET_CONTAINER_DLL_insert_after(head, tail, other, element)
Insert an element into a DLL after the given other element.
GNUNET_SCHEDULER_TaskCallback start
Function to call when the job is started.
Definition: fs_api.h:447
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
struct GNUNET_FS_Handle * h
Handle to FS primary context.
Definition: fs_api.h:462
unsigned int blocks
How many blocks do the active downloads have?
Definition: fs_api.h:488
#define GNUNET_log(kind,...)
GNUNET_SCHEDULER_TaskCallback stop
Function to call when the job needs to stop (or is done / dequeued).
Definition: fs_api.h:452
struct GNUNET_FS_QueueEntry * pending_tail
Tail of DLL of pending jobs.
Definition: fs_api.h:1137
void * cls
Closure for start and stop.
Definition: fs_api.h:457
Entry in the job queue.
Definition: fs_api.h:432
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_dequeue_()

void GNUNET_FS_dequeue_ ( struct GNUNET_FS_QueueEntry qe)

Dequeue a job from the queue.

Parameters
qehandle for the job

Definition at line 363 of file fs_api.c.

References GNUNET_FS_QueueEntry::active, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, h, GNUNET_FS_QueueEntry::h, GNUNET_FS_Handle::pending_head, GNUNET_FS_Handle::pending_tail, process_job_queue(), GNUNET_FS_Handle::queue_job, and stop_job().

Referenced by check_completed(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_stop(), and process_result_with_request().

364 {
365  struct GNUNET_FS_Handle *h;
366 
367  h = qe->h;
369  "Dequeueing job %p\n",
370  qe);
371  if (GNUNET_YES == qe->active)
372  stop_job (qe);
374  h->pending_tail,
375  qe);
376  GNUNET_free (qe);
377  if (NULL != h->queue_job)
380  h);
381 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_SCHEDULER_Task * queue_job
Task that processes the jobs in the running and pending queues (and moves jobs around as needed)...
Definition: fs_api.h:1153
Master context for most FS operations.
Definition: fs_api.h:1087
static void stop_job(struct GNUNET_FS_QueueEntry *qe)
Stop the given job (send signal, remove from active queue, update counters and state).
Definition: fs_api.c:79
struct GNUNET_FS_QueueEntry * pending_head
Head of DLL of pending jobs.
Definition: fs_api.h:1132
static void process_job_queue(void *cls)
Process the jobs in the job queue, possibly starting some and stopping others.
Definition: fs_api.c:111
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
int active
GNUNET_YES if the job is active now.
Definition: fs_api.h:503
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:1273
struct GNUNET_FS_Handle * h
Handle to FS primary context.
Definition: fs_api.h:462
#define GNUNET_log(kind,...)
struct GNUNET_FS_QueueEntry * pending_tail
Tail of DLL of pending jobs.
Definition: fs_api.h:1137
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_data_reader_file_()

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.

Parameters
clsclosure (points to the file information)
offsetoffset to read from; it is possible that the caller might need to go backwards a bit at times
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
Parameters
clsclosure with the struct FileInfo *
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 464 of file fs_api.c.

References _, FileInfo::fd, FileInfo::filename, GNUNET_asprintf(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_read(), GNUNET_DISK_file_seek(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_DISK_SEEK_SET, GNUNET_free, GNUNET_SYSERR, ret, and STRERROR.

Referenced by block_reader(), deserialize_fi_node(), GNUNET_FS_file_information_create_from_file(), and GNUNET_FS_file_information_create_from_reader().

469 {
470  struct FileInfo *fi = cls;
471  ssize_t ret;
472 
473  if (UINT64_MAX == offset)
474  {
475  if (NULL != fi->fd)
476  {
478  fi->fd = NULL;
479  }
480  return 0;
481  }
482  if (0 == max)
483  {
484  if (NULL != fi->fd)
486  GNUNET_free (fi->filename);
487  GNUNET_free (fi);
488  return 0;
489  }
490  if (NULL == fi->fd)
491  {
492  fi->fd =
496  if (NULL == fi->fd)
497  {
498  GNUNET_asprintf (emsg,
499  _("Could not open file `%s': %s"),
500  fi->filename,
501  STRERROR (errno));
502  return 0;
503  }
504  }
505  if ( (GNUNET_SYSERR ==
507  (-1 == (ret = GNUNET_DISK_file_read (fi->fd, buf, max))) )
508  {
509  GNUNET_asprintf (emsg,
510  _("Could not read file `%s': %s"),
511  fi->filename,
512  STRERROR (errno));
513  return 0;
514  }
515  if (ret != max)
516  {
517  GNUNET_asprintf (emsg,
518  _("Short read reading from file `%s'!"),
519  fi->filename);
520  return 0;
521  }
522  return max;
523 }
Open the file for reading.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1817
ssize_t GNUNET_DISK_file_read(const struct GNUNET_DISK_FileHandle *h, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: disk.c:881
#define STRERROR(i)
Definition: plibc.h:676
Nobody is allowed to do anything to the file.
struct GNUNET_DISK_FileHandle * fd
File descriptor, NULL if it has not yet been opened.
Definition: fs_api.c:439
off_t GNUNET_DISK_file_seek(const struct GNUNET_DISK_FileHandle *h, off_t offset, enum GNUNET_DISK_Seek whence)
Move the read/write pointer in a file.
Definition: disk.c:241
static int ret
Final status code.
Definition: gnunet-arm.c:89
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static char buf[2048]
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
Seek an absolute position (from the start of the file).
char * filename
Name of the file to read.
Definition: fs_api.c:434
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1673
Closure for GNUNET_FS_data_reader_file_().
Definition: fs_api.c:429
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_make_file_reader_context_()

void* GNUNET_FS_make_file_reader_context_ ( const char *  filename)

Create the closure for the GNUNET_FS_data_reader_file_() callback.

Parameters
filenamefile to read
Returns
closure to use
Parameters
filenamefile to read
Returns
closure to use, NULL on error

Definition at line 533 of file fs_api.c.

References FileInfo::filename, GNUNET_free, GNUNET_new, and GNUNET_STRINGS_filename_expand().

Referenced by deserialize_fi_node(), and GNUNET_FS_file_information_create_from_file().

534 {
535  struct FileInfo *fi;
536 
537  fi = GNUNET_new (struct FileInfo);
539  if (NULL == fi->filename)
540  {
541  GNUNET_free (fi);
542  return NULL;
543  }
544  return fi;
545 }
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static char * filename
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:602
char * filename
Name of the file to read.
Definition: fs_api.c:434
Closure for GNUNET_FS_data_reader_file_().
Definition: fs_api.c:429
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_data_reader_copy_()

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.

Parameters
clsclosure (points to the buffer)
offsetoffset to read from; it is possible that the caller might need to go backwards a bit at times
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
Parameters
clsclosure (points to the buffer)
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 569 of file fs_api.c.

References data, GNUNET_free_non_null, and GNUNET_memcpy.

Referenced by deserialize_fi_node(), and GNUNET_FS_file_information_create_from_data().

574 {
575  char *data = cls;
576 
577  if (UINT64_MAX == offset)
578  return 0;
579  if (0 == max)
580  {
581  GNUNET_free_non_null (data);
582  return 0;
583  }
584  GNUNET_memcpy (buf, &data[offset], max);
585  return max;
586 }
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
#define GNUNET_memcpy(dst, src, n)
static char buf[2048]
uint32_t data
The data value.
Here is the caller graph for this function:

◆ GNUNET_FS_search_probe_progress_()

void* GNUNET_FS_search_probe_progress_ ( void *  cls,
const struct GNUNET_FS_ProgressInfo info 
)

Notification of FS that a search probe has made progress.

This function is used INSTEAD of the client's event handler for downloads where the GNUNET_FS_DOWNLOAD_IS_PROBE flag is set.

Parameters
clsclosure, always NULL (!), actual closure is in the client-context of the info struct
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 279 of file fs_search.c.

References GNUNET_FS_ProgressInfo::download, GNUNET_assert, GNUNET_break, GNUNET_FS_search_result_sync_(), GNUNET_FS_STATUS_DOWNLOAD_ACTIVE, GNUNET_FS_STATUS_DOWNLOAD_COMPLETED, GNUNET_FS_STATUS_DOWNLOAD_ERROR, GNUNET_FS_STATUS_DOWNLOAD_INACTIVE, GNUNET_FS_STATUS_DOWNLOAD_PROGRESS, GNUNET_FS_STATUS_DOWNLOAD_RESUME, GNUNET_FS_STATUS_DOWNLOAD_START, GNUNET_FS_STATUS_DOWNLOAD_STOPPED, GNUNET_FS_STATUS_DOWNLOAD_SUSPEND, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_subtract(), GNUNET_FS_SearchResult::probe_active_time, GNUNET_FS_SearchResult::probe_cancel_task, probe_failure_handler(), probe_success_handler(), GNUNET_TIME_Relative::rel_value_us, GNUNET_FS_SearchResult::remaining_probe_time, GetResultContext::sr, GNUNET_FS_ProgressInfo::status, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_download_make_status_().

281 {
282  struct GNUNET_FS_SearchResult *sr = info->value.download.cctx;
283  struct GNUNET_TIME_Relative dur;
284 
285  switch (info->status)
286  {
288  /* ignore */
289  break;
291  /* probes should never be resumed */
292  GNUNET_assert (0);
293  break;
295  /* probes should never be suspended */
296  GNUNET_break (0);
297  break;
299  /* ignore */
300  break;
302  if (NULL != sr->probe_cancel_task)
303  {
305  sr->probe_cancel_task = NULL;
306  }
307  sr->probe_cancel_task =
309  &probe_failure_handler, sr);
310  break;
312  if (NULL != sr->probe_cancel_task)
313  {
315  sr->probe_cancel_task = NULL;
316  }
317  sr->probe_cancel_task =
319  break;
321  if (NULL != sr->probe_cancel_task)
322  {
324  sr->probe_cancel_task = NULL;
325  }
326  sr = NULL;
327  break;
329  if (NULL == sr->probe_cancel_task)
330  {
332  sr->probe_cancel_task =
334  &probe_failure_handler, sr);
335  }
336  break;
338  if (NULL != sr->probe_cancel_task)
339  {
341  sr->probe_cancel_task = NULL;
342  }
346  if (0 == sr->remaining_probe_time.rel_value_us)
347  sr->probe_cancel_task =
350  break;
351  default:
352  GNUNET_break (0);
353  return NULL;
354  }
355  return sr;
356 }
Notification that we have started this download.
uint64_t rel_value_us
The actual value.
Notification that this download was suspended.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_FS_ProgressInfo::@28::@30 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
static void probe_failure_handler(void *cls)
Handle the case where we have failed to receive a response for our probe.
Definition: fs_search.c:220
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
Notification that this download completed.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1246
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:598
Information we store for each search result.
Definition: fs_api.h:511
static void probe_success_handler(void *cls)
Handle the case where we have gotten a response for our probe.
Definition: fs_search.c:244
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:1273
enum GNUNET_FS_Status status
Specific status code (determines the event type).
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2048
struct GNUNET_TIME_Relative GNUNET_TIME_relative_subtract(struct GNUNET_TIME_Relative a1, struct GNUNET_TIME_Relative a2)
Subtract relative timestamp from the other.
Definition: time.c:601
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Notification that this download is no longer actively being pursued (back in the queue).
Notification about progress with this download.
Notification that this download is now actively being pursued (as opposed to waiting in the queue)...
Notification that this download is being resumed.
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
struct GNUNET_TIME_Absolute probe_active_time
When did the current probe become active?
Definition: fs_api.h:593
Notification that this download was stopped (final event with respect to this action).
Notification that this download encountered an error.
Time for relative time used by GNUnet, in microseconds.
struct GNUNET_SCHEDULER_Task * probe_cancel_task
ID of the task that will clean up the probe_ctx should it not complete on time (and that will need to...
Definition: fs_api.h:588
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_publish_main_()

void GNUNET_FS_publish_main_ ( void *  cls)

Main function that performs the upload.

Parameters
clsstruct GNUNET_FS_PublishContext identifies the upload
clsstruct GNUNET_FS_PublishContext * identifies the upload

Definition at line 1053 of file fs_publish.c.

References _, GNUNET_FS_PublishContext::all_done, GNUNET_FS_BlockOptions::anonymity_level, GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::chk_uri, GNUNET_FS_FileInformation::client_info, create_loc_uri(), GNUNET_FS_FileInformation::data, GNUNET_FS_FileInformation::dir, GNUNET_FS_FileInformation::emsg, GNUNET_FS_FileInformation::entries, EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME, GNUNET_FS_PublishContext::fhc, GNUNET_FS_PublishContext::fi_pos, GNUNET_FS_FileInformation::file, GNUNET_FS_FileInformation::filename, fn, GNUNET_asprintf(), GNUNET_CONTAINER_meta_data_get_by_type(), GNUNET_CRYPTO_hash_file(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_make_status_(), GNUNET_FS_publish_sync_(), GNUNET_FS_STATUS_PUBLISH_ERROR, GNUNET_FS_uri_test_loc(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, hash_for_index_cb(), HASHING_BLOCKSIZE, GNUNET_FS_FileInformation::is_directory, GNUNET_FS_FileInformation::meta, p, pc, GNUNET_FS_ProgressInfo::publish, publish_content(), publish_kblocks(), publish_sblock(), GNUNET_FS_FileInformation::start_time, GNUNET_FS_ProgressInfo::status, GNUNET_FS_PublishContext::upload_task, and GNUNET_FS_ProgressInfo::value.

Referenced by block_proc(), deserialize_publish_file(), ds_put_cont(), encode_cont(), finish_reserve(), GNUNET_FS_publish_start(), and publish_kblocks_cont().

1054 {
1055  struct GNUNET_FS_PublishContext *pc = cls;
1056  struct GNUNET_FS_ProgressInfo pi;
1057  struct GNUNET_FS_FileInformation *p;
1058  char *fn;
1059 
1060  pc->upload_task = NULL;
1061  p = pc->fi_pos;
1062  if (NULL == p)
1063  {
1065  "Publishing complete, now publishing SKS and KSK blocks.\n");
1066  /* upload of entire hierarchy complete,
1067  * publish namespace entries */
1069  publish_sblock (pc);
1070  return;
1071  }
1072  /* find starting position */
1073  while ( (GNUNET_YES == p->is_directory) &&
1074  (NULL != p->data.dir.entries) &&
1075  (NULL == p->emsg) &&
1076  (NULL == p->data.dir.entries->chk_uri) )
1077  {
1078  p = p->data.dir.entries;
1079  pc->fi_pos = p;
1081  }
1082  /* abort on error */
1083  if (NULL != p->emsg)
1084  {
1086  "Error uploading: %s\n",
1087  p->emsg);
1088  /* error with current file, abort all
1089  * related files as well! */
1090  while (NULL != p->dir)
1091  {
1094  p = p->dir;
1095  if (fn != NULL)
1096  {
1097  GNUNET_asprintf (&p->emsg,
1098  _("Recursive upload failed at `%s': %s"),
1099  fn,
1100  p->emsg);
1101  GNUNET_free (fn);
1102  }
1103  else
1104  {
1105  GNUNET_asprintf (&p->emsg,
1106  _("Recursive upload failed: %s"),
1107  p->emsg);
1108  }
1110  pi.value.publish.eta = GNUNET_TIME_UNIT_FOREVER_REL;
1111  pi.value.publish.specifics.error.message = p->emsg;
1112  p->client_info = GNUNET_FS_publish_make_status_ (&pi, pc, p, 0);
1113  }
1114  pc->all_done = GNUNET_YES;
1116  return;
1117  }
1118  /* handle completion */
1119  if (NULL != p->chk_uri)
1120  {
1122  "File upload complete, now publishing KSK blocks.\n");
1124 
1125  if ( (0 == p->bo.anonymity_level) &&
1126  (GNUNET_YES !=
1128  {
1129  /* zero anonymity, box CHK URI in LOC URI */
1130  create_loc_uri (pc);
1131  }
1132  else
1133  {
1134  publish_kblocks (pc);
1135  }
1136  return;
1137  }
1138  if ((GNUNET_YES != p->is_directory) && (p->data.file.do_index))
1139  {
1140  if (NULL == p->filename)
1141  {
1142  p->data.file.do_index = GNUNET_NO;
1144  _("Can not index file `%s': %s. Will try to insert instead.\n"),
1145  "<no-name>",
1146  _("needs to be an actual file"));
1148  publish_content (pc);
1149  return;
1150  }
1151  if (p->data.file.have_hash)
1152  {
1153  hash_for_index_cb (pc, &p->data.file.file_id);
1154  }
1155  else
1156  {
1158  pc->fhc =
1161  }
1162  return;
1163  }
1164  publish_content (pc);
1165 }
struct GNUNET_FS_FileInformation * entries
Linked list of entries in the directory.
Definition: fs_api.h:371
struct GNUNET_SCHEDULER_Task * upload_task
ID of the task performing the upload.
Definition: fs_api.h:1278
struct GNUNET_FS_FileInformation * dir
If this is a file in a directory, "dir" refers to the directory; otherwise NULL.
Definition: fs_api.h:243
void GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *fi)
Create a temporary file on disk to store the current state of fi in.
Definition: fs_api.c:1296
struct GNUNET_CONTAINER_MetaData * meta
Metadata to use for the file.
Definition: fs_api.h:258
struct GNUNET_FS_FileInformation::@19::@20 file
Data for a file.
void * client_info
Pointer kept for the client.
Definition: fs_api.h:253
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:302
static void publish_content(struct GNUNET_FS_PublishContext *pc)
We are uploading a file or directory; load (if necessary) the next block into memory, encrypt it and send it to the FS service.
Definition: fs_publish.c:610
struct GNUNET_TIME_Absolute start_time
At what time did we start this upload?
Definition: fs_api.h:285
char * filename
Name of the file or directory (must be an absolute path).
Definition: fs_api.h:307
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_CRYPTO_FileHashContext * fhc
Non-null if we are currently hashing a file.
Definition: fs_api.h:1250
Information for a file or directory that is about to be published.
Definition: fs_api.h:231
char * GNUNET_CONTAINER_meta_data_get_by_type(const struct GNUNET_CONTAINER_MetaData *md, enum EXTRACTOR_MetaType type)
Get the first MD entry of the given type.
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.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
static void hash_for_index_cb(void *cls, const struct GNUNET_HashCode *res)
Function called once the hash computation over an indexed file has completed.
Definition: fs_publish.c:799
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
int GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
Is this a location URI?
Definition: fs_uri.c:1381
static void publish_kblocks(struct GNUNET_FS_PublishContext *pc)
We&#39;ve computed the CHK/LOC URI, now publish the KSKs (if applicable).
Definition: fs_publish.c:925
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP, >1: with cover traffic).
static void publish_sblock(struct GNUNET_FS_PublishContext *pc)
We are almost done publishing the structure, add SBlocks (if needed).
Definition: fs_publish.c:285
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
static void create_loc_uri(struct GNUNET_FS_PublishContext *pc)
We&#39;re publishing without anonymity.
Definition: fs_publish.c:1008
void GNUNET_FS_publish_sync_(struct GNUNET_FS_PublishContext *pc)
Synchronize this publishing struct with its mirror on disk.
Definition: fs_api.c:1685
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
static char * fn
Filename of the unique file.
int is_directory
Is this struct for a file or directory?
Definition: fs_api.h:402
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
struct GNUNET_FS_FileInformation * fi_pos
Current position in the file-tree for the upload.
Definition: fs_api.h:1245
struct GNUNET_FS_Uri * chk_uri
CHK for this file or directory.
Definition: fs_api.h:269
Handle for controlling a publication process.
Definition: fs_api.h:1198
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_get(void)
Get the current time.
Definition: time.c:118
Run when otherwise idle.
int all_done
Set to GNUNET_YES if all processing has completed.
Definition: fs_api.h:1311
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
struct GNUNET_FS_BlockOptions bo
Block options for the file.
Definition: fs_api.h:280
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
union GNUNET_FS_FileInformation::@19 data
Data describing either the file or the directory.
Notification that an error was encountered sharing a file structure.
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:47
#define GNUNET_log(kind,...)
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_unindex_process_hash_()

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.

Parameters
clsclosure, unindex context
file_idcomputed hash, NULL on error

Definition at line 690 of file fs_unindex.c.

References _, GNUNET_FS_UnindexContext::emsg, GNUNET_FS_UnindexContext::fhc, GNUNET_FS_UnindexContext::file_id, GNUNET_FS_unindex_do_remove_(), GNUNET_FS_unindex_stop(), GNUNET_FS_unindex_sync_(), GNUNET_strdup, signal_unindex_error(), GNUNET_FS_UnindexContext::state, uc, UNINDEX_STATE_DS_REMOVE, UNINDEX_STATE_ERROR, and UNINDEX_STATE_HASHING.

Referenced by deserialize_unindex_file(), and GNUNET_FS_unindex_start().

692 {
693  struct GNUNET_FS_UnindexContext *uc = cls;
694 
695  uc->fhc = NULL;
696  if (uc->state != UNINDEX_STATE_HASHING)
697  {
699  return;
700  }
701  if (file_id == NULL)
702  {
704  uc->emsg = GNUNET_strdup (_("Failed to compute hash of file."));
707  return;
708  }
709  uc->file_id = *file_id;
713 }
static void signal_unindex_error(struct GNUNET_FS_UnindexContext *uc)
We&#39;ve encountered an error during unindexing.
Definition: fs_unindex.c:138
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:833
static struct GNUNET_FS_UnindexContext * uc
struct GNUNET_HashCode file_id
Hash of the file&#39;s contents (once computed).
Definition: fs_api.h:1479
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1484
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
Handle for controlling an unindexing operation.
Definition: fs_api.h:1369
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
Definition: fs_api.h:1464
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
void GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc)
Connect to the datastore and remove the blocks.
Definition: fs_unindex.c:645
We&#39;ve encountered a fatal error.
Definition: fs_api.h:1362
void GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
Synchronize this unindex struct with its mirror on disk.
Definition: fs_api.c:1754
We&#39;re currently hashing the file.
Definition: fs_api.h:1330
We&#39;re telling the datastore to delete the respective DBlocks and IBlocks.
Definition: fs_api.h:1336
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1459
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_unindex_do_extract_keywords_()

void GNUNET_FS_unindex_do_extract_keywords_ ( struct GNUNET_FS_UnindexContext uc)

Extract the keywords for KBlock removal.

Parameters
uccontext for the unindex operation.

Extract the keywords for KBlock removal.

Parameters
uccontext for the unindex operation.

Definition at line 404 of file fs_unindex.c.

References GNUNET_FS_Handle::cfg, GNUNET_FS_UnindexContext::dscan, GNUNET_FS_UnindexContext::filename, GNUNET_CONFIGURATION_get_value_string(), GNUNET_free_non_null, GNUNET_FS_directory_scan_start(), GNUNET_NO, GNUNET_OK, GNUNET_FS_UnindexContext::h, and unindex_directory_scan_cb().

Referenced by deserialize_unindex_file(), and unindex_extract_keywords().

405 {
406  char *ex;
407 
408  if (GNUNET_OK !=
409  GNUNET_CONFIGURATION_get_value_string (uc->h->cfg, "FS", "EXTRACTORS", &ex))
410  ex = NULL;
412  GNUNET_NO, ex,
414  uc);
416 }
struct GNUNET_FS_DirScanner * GNUNET_FS_directory_scan_start(const char *filename, int disable_extractor, const char *ex, GNUNET_FS_DirScannerProgressCallback cb, void *cb_cls)
Start a directory scanner thread.
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1406
int GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
static void unindex_directory_scan_cb(void *cls, const char *filename, int is_directory, enum GNUNET_FS_DirScannerProgressUpdateReason reason)
Function called by the directory scanner as we extract keywords that we will need to remove UBlocks...
Definition: fs_unindex.c:354
struct GNUNET_FS_DirScanner * dscan
Directory scanner to find keywords (KBlock removal).
Definition: fs_api.h:1391
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1381
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1092
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_unindex_do_remove_kblocks_()

void GNUNET_FS_unindex_do_remove_kblocks_ ( struct GNUNET_FS_UnindexContext uc)

If necessary, connect to the datastore and remove the KBlocks.

Parameters
uccontext for the unindex operation.

Definition at line 576 of file fs_unindex.c.

References _, GNUNET_FS_Handle::cfg, GNUNET_FS_Uri::data, GNUNET_FS_UnindexContext::dqe, GNUNET_FS_UnindexContext::dsh, GNUNET_FS_UnindexContext::emsg, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_CRYPTO_ecdsa_key_get_anonymous(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_hash(), GNUNET_DATASTORE_connect(), GNUNET_DATASTORE_get_key(), GNUNET_FS_unindex_sync_(), GNUNET_strdup, GNUNET_FS_UnindexContext::h, GNUNET_FS_Uri::ksk, GNUNET_FS_UnindexContext::ksk_offset, GNUNET_FS_UnindexContext::ksk_uri, process_kblock_for_unindex(), signal_unindex_error(), GNUNET_FS_UnindexContext::state, unindex_finish(), UNINDEX_STATE_ERROR, and GNUNET_FS_UnindexContext::uquery.

Referenced by continue_after_remove(), deserialize_unindex_file(), process_kblock_for_unindex(), and unindex_directory_scan_cb().

577 {
578  const char *keyword;
579  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
580  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
581  struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
582 
583  if (NULL == uc->dsh)
584  uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
585  if (NULL == uc->dsh)
586  {
588  uc->emsg = GNUNET_strdup (_("Failed to connect to `datastore' service."));
591  return;
592  }
593  if ( (NULL == uc->ksk_uri) ||
594  (uc->ksk_offset >= uc->ksk_uri->data.ksk.keywordCount) )
595  {
596  unindex_finish (uc);
597  return;
598  }
601  &anon_pub);
602  keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
604  keyword,
605  "fs-ublock",
606  &dpub);
607  GNUNET_CRYPTO_hash (&dpub,
608  sizeof (dpub),
609  &uc->uquery);
610  uc->dqe = GNUNET_DATASTORE_get_key (uc->dsh,
611  0 /* next_uid */,
612  false /* random */,
613  &uc->uquery,
615  0 /* priority */,
616  1 /* queue size */,
618  uc);
619 }
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_key_get_anonymous(void)
Get the shared private key we use for anonymous users.
Definition: crypto_ecc.c:814
static void signal_unindex_error(struct GNUNET_FS_UnindexContext *uc)
We&#39;ve encountered an error during unindexing.
Definition: fs_unindex.c:138
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
Definition: crypto_ecc.c:1339
uint32_t ksk_offset
Current offset in KSK removal.
Definition: fs_api.h:1401
Private ECC key encoded for transmission.
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1484
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service, only valid during the UNINDEX_STATE_DS_NOTIFY phase...
Definition: fs_api.h:1423
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_HashCode uquery
Current query of &#39;get_key&#39; operation.
Definition: fs_api.h:1454
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
struct GNUNET_FS_Uri::@16::@17 ksk
union GNUNET_FS_Uri::@16 data
We&#39;ve encountered a fatal error.
Definition: fs_api.h:1362
struct GNUNET_FS_Uri * ksk_uri
Keywords found (telling us which KBlocks to remove).
Definition: fs_api.h:1396
Type of a block representing any type of search result (universal).
struct GNUNET_DATASTORE_QueueEntry * dqe
Handle to datastore &#39;get_key&#39; operation issued for obtaining KBlocks.
Definition: fs_api.h:1444
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:241
void GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
Synchronize this unindex struct with its mirror on disk.
Definition: fs_api.c:1754
static void unindex_finish(struct GNUNET_FS_UnindexContext *uc)
Function called when we are done with removing UBlocks.
Definition: fs_unindex.c:289
static void process_kblock_for_unindex(void *cls, const struct GNUNET_HashCode *key, size_t size, const void *data, enum GNUNET_BLOCK_Type type, uint32_t priority, uint32_t anonymity, uint32_t replication, struct GNUNET_TIME_Absolute expiration, uint64_t uid)
Function called from datastore with result from us looking for a UBlock.
Definition: fs_unindex.c:473
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1459
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_get_key(struct GNUNET_DATASTORE_Handle *h, uint64_t next_uid, bool random, const struct GNUNET_HashCode *key, enum GNUNET_BLOCK_Type type, unsigned int queue_priority, unsigned int max_queue_size, GNUNET_DATASTORE_DatumProcessor proc, void *proc_cls)
Get a result for a particular key from the datastore.
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1381
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1092
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_publish_make_status_()

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.

Parameters
pistructure to fill in
pcoverall publishing context
pfile information for the file being published
offsetwhere in the file are we so far
Returns
value returned from callback

Definition at line 47 of file fs_publish.c.

References GNUNET_FS_BlockOptions::anonymity_level, GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::client_info, GNUNET_FS_FileInformation::data, GNUNET_FS_FileInformation::dir, GNUNET_FS_FileInformation::dir_size, GNUNET_FS_FileInformation::file, GNUNET_FS_FileInformation::filename, GNUNET_FS_ProgressInfo::fsh, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_calculate_eta(), GNUNET_YES, GNUNET_FS_PublishContext::h, GNUNET_FS_FileInformation::is_directory, p, pc, GNUNET_FS_ProgressInfo::publish, GNUNET_FS_FileInformation::start_time, GNUNET_FS_Handle::upcb, GNUNET_FS_Handle::upcb_cls, and GNUNET_FS_ProgressInfo::value.

Referenced by ds_put_cont(), encode_cont(), fip_signal_resume(), fip_signal_start(), fip_signal_stop(), GNUNET_FS_publish_main_(), GNUNET_FS_publish_stop(), progress_proc(), signal_publish_completion(), signal_publish_error(), and suspend_operation().

51 {
52  pi->value.publish.pc = pc;
53  pi->value.publish.fi = p;
54  pi->value.publish.cctx = p->client_info;
55  pi->value.publish.pctx = (NULL == p->dir) ? NULL : p->dir->client_info;
56  pi->value.publish.filename = p->filename;
57  pi->value.publish.size =
58  (GNUNET_YES == p->is_directory) ? p->data.dir.dir_size : p->data.file.file_size;
59  pi->value.publish.eta =
61  pi->value.publish.size);
62  pi->value.publish.completed = offset;
63  pi->value.publish.duration =
65  pi->value.publish.anonymity = p->bo.anonymity_level;
66  pi->fsh = pc->h;
67  return pc->h->upcb (pc->h->upcb_cls, pi);
68 }
struct GNUNET_FS_FileInformation * dir
If this is a file in a directory, "dir" refers to the directory; otherwise NULL.
Definition: fs_api.h:243
struct GNUNET_FS_FileInformation::@19::@20 file
Data for a file.
void * client_info
Pointer kept for the client.
Definition: fs_api.h:253
struct GNUNET_TIME_Absolute start_time
At what time did we start this upload?
Definition: fs_api.h:285
char * filename
Name of the file or directory (must be an absolute path).
Definition: fs_api.h:307
struct GNUNET_FS_Handle * h
Handle to the global fs context.
Definition: fs_api.h:1203
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP, >1: with cover traffic).
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
static struct GNUNET_OS_Process * p
Helper process we started.
Definition: gnunet-qr.c:59
int is_directory
Is this struct for a file or directory?
Definition: fs_api.h:402
struct GNUNET_FS_ProgressInfo::@28::@29 publish
Values for all "GNUNET_FS_STATUS_PUBLISH_*" events.
struct GNUNET_FS_BlockOptions bo
Block options for the file.
Definition: fs_api.h:280
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
union GNUNET_FS_FileInformation::@19 data
Data describing either the file or the directory.
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1102
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1107
struct GNUNET_TIME_Relative GNUNET_TIME_calculate_eta(struct GNUNET_TIME_Absolute start, uint64_t finished, uint64_t total)
Calculate the estimate time of arrival/completion for an operation.
Definition: time.c:549
#define GNUNET_YES
Definition: gnunet_common.h:80
size_t dir_size
Size of the directory itself (in bytes); 0 if the size has not yet been calculated.
Definition: fs_api.h:377
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_download_make_status_()

void GNUNET_FS_download_make_status_ ( struct GNUNET_FS_ProgressInfo pi,
struct GNUNET_FS_DownloadContext dc 
)

Fill in all of the generic fields for a download event and call the callback.

Parameters
pistructure to fill in
dcoverall download context

Definition at line 106 of file fs_download.c.

References GNUNET_FS_DownloadContext::anonymity, GNUNET_FS_SearchResult::client_info, GNUNET_FS_DownloadContext::client_info, GNUNET_FS_DownloadContext::completed, dc, GNUNET_FS_ProgressInfo::download, GNUNET_FS_DownloadContext::filename, GNUNET_FS_ProgressInfo::fsh, GNUNET_FS_DOWNLOAD_IS_PROBE, GNUNET_FS_search_probe_progress_(), GNUNET_NO, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_calculate_eta(), GNUNET_YES, GNUNET_FS_DownloadContext::h, GNUNET_FS_DownloadContext::length, GNUNET_FS_DownloadContext::mq, GNUNET_FS_DownloadContext::options, GNUNET_FS_DownloadContext::parent, GNUNET_FS_DownloadContext::search, GNUNET_FS_DownloadContext::start_time, GNUNET_FS_Handle::upcb, GNUNET_FS_Handle::upcb_cls, GNUNET_FS_DownloadContext::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by activate_fs_download(), check_completed(), deactivate_fs_download(), GNUNET_FS_download_resume(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_start_task_(), GNUNET_FS_download_stop(), process_result_with_request(), reconstruct_cb(), search_result_stop(), signal_download_resume(), and try_match_block().

108 {
109  pi->value.download.dc = dc;
110  pi->value.download.cctx = dc->client_info;
111  pi->value.download.pctx =
112  (NULL == dc->parent) ? NULL : dc->parent->client_info;
113  pi->value.download.sctx =
114  (NULL == dc->search) ? NULL : dc->search->client_info;
115  pi->value.download.uri = dc->uri;
116  pi->value.download.filename = dc->filename;
117  pi->value.download.size = dc->length;
118  /* FIXME: Fix duration calculation to account for pauses */
119  pi->value.download.duration =
121  pi->value.download.completed = dc->completed;
122  pi->value.download.anonymity = dc->anonymity;
123  pi->value.download.eta =
125  pi->value.download.is_active = (NULL == dc->mq) ? GNUNET_NO : GNUNET_YES;
126  pi->fsh = dc->h;
127  if (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
128  dc->client_info = dc->h->upcb (dc->h->upcb_cls, pi);
129  else
131 }
void * client_info
Client info for this search result.
Definition: fs_api.h:548
void * GNUNET_FS_search_probe_progress_(void *cls, const struct GNUNET_FS_ProgressInfo *info)
Notification of FS that a search probe has made progress.
Definition: fs_search.c:279
enum GNUNET_FS_DownloadOptions options
Options for the download.
Definition: fs_api.h:1949
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1774
struct GNUNET_FS_ProgressInfo::@28::@30 download
Values for all "GNUNET_FS_STATUS_DOWNLOAD_*" events.
struct GNUNET_FS_DownloadContext * parent
Parent download (used when downloading files in directories).
Definition: fs_api.h:1790
#define GNUNET_NO
Definition: gnunet_common.h:81
char * filename
Where are we writing the data (name of the file, can be NULL!).
Definition: fs_api.h:1848
void * client_info
Context kept for the client.
Definition: fs_api.h:1821
uint64_t length
How many bytes starting from offset are desired? This is NOT the overall length of the file! ...
Definition: fs_api.h:1910
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
Internal option used to flag this download as a &#39;probe&#39; for a search result.
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none...
Definition: fs_api.h:1796
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1102
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1107
uint32_t anonymity
Desired level of anonymity.
Definition: fs_api.h:1939
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1784
struct GNUNET_TIME_Relative GNUNET_TIME_calculate_eta(struct GNUNET_TIME_Absolute start, uint64_t finished, uint64_t total)
Calculate the estimate time of arrival/completion for an operation.
Definition: time.c:549
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_TIME_Absolute start_time
Time download was started.
Definition: fs_api.h:1929
uint64_t completed
How many bytes have we already received within the specified range (DBlocks only).
Definition: fs_api.h:1916
struct GNUNET_FS_Uri * uri
URI that identifies the file that we are downloading.
Definition: fs_api.h:1826
static struct GNUNET_FS_DownloadContext * dc
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_download_start_task_()

void GNUNET_FS_download_start_task_ ( void *  cls)

Task that creates the initial (top-level) download request for the file.

Parameters
clsthe 'struct GNUNET_FS_DownloadContext'

Definition at line 1802 of file fs_download.c.

References _, BRS_CHK_SET, BRS_DOWNLOAD_DOWN, BRS_DOWNLOAD_UP, BRS_ERROR, check_completed(), GNUNET_FS_Uri::chk, FileIdentifier::chk, DownloadRequest::chk, create_download_request(), GNUNET_FS_Uri::data, GNUNET_FS_ProgressInfo::download, GNUNET_FS_DownloadContext::emsg, fh, fh_reader(), Location::fi, GNUNET_FS_DownloadContext::filename, get_next_block(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONTAINER_meta_data_get_serialized_size(), GNUNET_CONTAINER_meta_data_iterate(), GNUNET_DISK_file_close(), GNUNET_DISK_file_open(), GNUNET_DISK_file_test(), GNUNET_DISK_OPEN_CREATE, GNUNET_DISK_OPEN_READ, GNUNET_DISK_OPEN_READWRITE, GNUNET_DISK_OPEN_TRUNCATE, GNUNET_DISK_PERM_GROUP_READ, GNUNET_DISK_PERM_NONE, GNUNET_DISK_PERM_OTHER_READ, GNUNET_DISK_PERM_USER_READ, GNUNET_DISK_PERM_USER_WRITE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_download_make_status_(), GNUNET_FS_download_start_downloading_(), GNUNET_FS_download_sync_(), GNUNET_FS_search_result_sync_(), GNUNET_FS_STATUS_DOWNLOAD_ERROR, GNUNET_FS_STATUS_DOWNLOAD_START, GNUNET_FS_tree_encoder_create(), GNUNET_FS_URI_CHK, GNUNET_FS_uri_chk_get_file_size(), GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_YES, GNUNET_FS_DownloadContext::h, GNUNET_FS_DownloadContext::issue_requests, GNUNET_FS_DownloadContext::length, GNUNET_FS_Uri::loc, match_full_data(), MAX_INLINE_SIZE, GNUNET_FS_DownloadContext::meta, GNUNET_FS_DownloadContext::offset, reconstruct_cb(), reconstruct_cont(), GNUNET_FS_DownloadContext::rfh, schedule_block_download(), GNUNET_FS_DownloadContext::search, DownloadRequest::state, GNUNET_FS_ProgressInfo::status, GNUNET_FS_DownloadContext::task, GNUNET_FS_DownloadContext::te, GNUNET_FS_DownloadContext::top_request, GNUNET_FS_DownloadContext::treedepth, try_top_down_reconstruction(), GNUNET_FS_Uri::type, GNUNET_FS_DownloadContext::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by create_download_context(), and deserialize_download().

1803 {
1804  struct GNUNET_FS_DownloadContext *dc = cls;
1805  struct GNUNET_FS_ProgressInfo pi;
1806  struct GNUNET_DISK_FileHandle *fh;
1807 
1809  "Start task running...\n");
1810  dc->task = NULL;
1811  if (0 == dc->length)
1812  {
1813  /* no bytes required! */
1814  if (NULL != dc->filename)
1815  {
1816  fh = GNUNET_DISK_file_open (dc->filename,
1819  ((0 ==
1827  }
1830  pi.value.download.specifics.start.meta = dc->meta;
1832  check_completed (dc);
1833  return;
1834  }
1835  if (NULL != dc->emsg)
1836  return;
1837  if (NULL == dc->top_request)
1838  {
1839  dc->top_request =
1840  create_download_request (NULL, 0, dc->treedepth - 1, 0, dc->offset,
1841  dc->length);
1842  dc->top_request->state = BRS_CHK_SET;
1843  dc->top_request->chk =
1844  (dc->uri->type ==
1845  GNUNET_FS_URI_CHK) ? dc->uri->data.chk.chk : dc->uri->data.loc.fi.chk;
1846  /* signal start */
1848  if (NULL != dc->search)
1851  pi.value.download.specifics.start.meta = dc->meta;
1853  }
1855  /* attempt reconstruction from disk */
1857  dc->rfh =
1860  if (dc->top_request->state == BRS_CHK_SET)
1861  {
1862  if (NULL != dc->rfh)
1863  {
1864  /* first, try top-down */
1866  "Trying top-down reconstruction for `%s'\n", dc->filename);
1868  switch (dc->top_request->state)
1869  {
1870  case BRS_CHK_SET:
1871  break; /* normal */
1872  case BRS_DOWNLOAD_DOWN:
1873  break; /* normal, some blocks already down */
1874  case BRS_DOWNLOAD_UP:
1875  /* already done entirely, party! */
1876  if (NULL != dc->rfh)
1877  {
1878  /* avoid hanging on to file handle longer than
1879  * necessary */
1881  dc->rfh = NULL;
1882  }
1883  return;
1884  case BRS_ERROR:
1885  GNUNET_asprintf (&dc->emsg, _("Invalid URI"));
1888  pi.value.download.specifics.error.message = dc->emsg;
1890  return;
1891  default:
1892  GNUNET_assert (0);
1893  break;
1894  }
1895  }
1896  }
1897  /* attempt reconstruction from meta data */
1899  (NULL != dc->meta))
1900  {
1902  "Trying to find embedded meta data for download of size %llu with %u bytes MD\n",
1903  (unsigned long long) GNUNET_FS_uri_chk_get_file_size (dc->uri),
1904  (unsigned int)
1907  if (BRS_DOWNLOAD_UP == dc->top_request->state)
1908  {
1909  if (NULL != dc->rfh)
1910  {
1911  /* avoid hanging on to file handle longer than
1912  * necessary */
1914  dc->rfh = NULL;
1915  }
1916  return; /* finished, status update was already done for us */
1917  }
1918  }
1919  if (NULL != dc->rfh)
1920  {
1921  /* finally, actually run bottom-up */
1923  "Trying bottom-up reconstruction of file `%s'\n", dc->filename);
1924  dc->te =
1927  dc,
1928  &fh_reader,
1929  &reconstruct_cb,
1930  NULL,
1931  &reconstruct_cont);
1933  dc);
1934  }
1935  else
1936  {
1937  /* simple, top-level download */
1938  dc->issue_requests = GNUNET_YES;
1940  }
1941  if (BRS_DOWNLOAD_UP == dc->top_request->state)
1942  check_completed (dc);
1943 }
ssize_t GNUNET_CONTAINER_meta_data_get_serialized_size(const struct GNUNET_CONTAINER_MetaData *md)
Get the size of the full meta-data in serialized form.
int GNUNET_DISK_file_test(const char *fil)
Check that fil corresponds to a filename (of a file that exists and that is not a directory)...
Definition: disk.c:669
Notification that we have started this download.
Open the file for reading.
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:104
Create file if it doesn&#39;t exist.
Context for controlling a download.
Definition: fs_api.h:1768
static void reconstruct_cb(void *cls, const struct ContentHashKey *chk, uint64_t offset, unsigned int depth, enum GNUNET_BLOCK_Type type, const void *block, uint16_t block_size)
Function called asking for the current (encoded) block to be processed.
Definition: fs_download.c:1627
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1817
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:215
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1774
static void try_top_down_reconstruction(struct GNUNET_FS_DownloadContext *dc, struct DownloadRequest *dr)
Try top-down reconstruction.
Definition: fs_download.c:663
void GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_DownloadContext *dc)
Fill in all of the generic fields for a download event and call the callback.
Definition: fs_download.c:106
void GNUNET_FS_download_sync_(struct GNUNET_FS_DownloadContext *dc)
Synchronize this download struct with its mirror on disk.
Definition: fs_api.c:1944
static struct DownloadRequest * create_download_request(struct DownloadRequest *parent, unsigned int chk_idx, unsigned int depth, uint64_t dr_offset, uint64_t file_start_offset, uint64_t desired_length)
(recursively) Create a download request structure.
Definition: fs_download.c:1494
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct DownloadRequest * top_request
Top-level download request.
Definition: fs_api.h:1882
Nobody is allowed to do anything to the file.
char * filename
Where are we writing the data (name of the file, can be NULL!).
Definition: fs_api.h:1848
struct ContentHashKey chk
CHK for the request for this block (set during reconstruction to what we have on disk, later to what we want to have).
Definition: fs_api.h:1715
enum BlockRequestState state
State in the FSM.
Definition: fs_api.h:1742
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
#define MAX_INLINE_SIZE
Maximum size for a file to be considered for inlining in a directory.
Definition: fs_api.h:49
uint64_t length
How many bytes starting from offset are desired? This is NOT the overall length of the file! ...
Definition: fs_api.h:1910
int GNUNET_asprintf(char **buf, const char *format,...)
Like asprintf, just portable.
Truncate file if it exists.
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:1273
union GNUNET_FS_Uri::@16 data
void GNUNET_FS_search_result_sync_(struct GNUNET_FS_SearchResult *sr)
Synchronize this search result with its mirror on disk.
Definition: fs_api.c:2048
static void check_completed(struct GNUNET_FS_DownloadContext *dc)
Check if all child-downloads have completed (or trigger them if necessary) and once we&#39;re completely ...
Definition: fs_download.c:376
static void reconstruct_cont(void *cls)
Continuation after a possible attempt to reconstruct the current IBlock from the existing file...
Definition: fs_download.c:1571
int issue_requests
Are we ready to issue requests (reconstructions are finished)?
Definition: fs_api.h:1961
static int fh
Handle to the unique file.
struct GNUNET_FS_TreeEncoder * te
Tree encoder used for the reconstruction.
Definition: fs_api.h:1865
struct GNUNET_FS_TreeEncoder * GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size, void *cls, GNUNET_FS_DataReader reader, GNUNET_FS_TreeBlockProcessor proc, GNUNET_FS_TreeProgressCallback progress, GNUNET_SCHEDULER_TaskCallback cont)
Initialize a tree encoder.
Definition: fs_tree.c:270
uint64_t offset
What is the first offset that we&#39;re interested in?
Definition: fs_api.h:1904
static size_t fh_reader(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function called by the tree encoder to obtain a block of plaintext data (for the lowest level of the ...
Definition: fs_download.c:1770
We&#39;ve successfully downloaded this block, but the children still need to be either downloaded or veri...
Definition: fs_api.h:1678
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the download is being stopped ...
Definition: fs_api.h:1898
struct GNUNET_DISK_FileHandle * rfh
File handle for reading data from an existing file (to pass to tree encoder).
Definition: fs_api.h:1871
This block and all of its children have been downloaded successfully (full completion propagates up)...
Definition: fs_api.h:1684
Content-hash-key (simple file).
Definition: fs_api.h:146
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none...
Definition: fs_api.h:1796
char * emsg
Error message, NULL if we&#39;re doing OK.
Definition: fs_api.h:1836
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:173
We got a block back that matched the query but did not hash to the key (malicious publisher or hash c...
Definition: fs_api.h:1691
static void get_next_block(void *cls)
Task requesting the next block from the tree encoder.
Definition: fs_download.c:1600
Everybody can read.
static int match_full_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)
Type of a function that libextractor calls for each meta data item found.
Definition: fs_download.c:604
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?
Definition: fs_uri.c:1359
struct FileIdentifier fi
Information about the shared file.
Definition: fs_api.h:118
int GNUNET_CONTAINER_meta_data_iterate(const struct GNUNET_CONTAINER_MetaData *md, EXTRACTOR_MetaDataProcessor iter, void *iter_cls)
Iterate over MD entries.
#define GNUNET_log(kind,...)
Open the file for both reading and writing.
unsigned int treedepth
The depth of the file-tree.
Definition: fs_api.h:1944
struct GNUNET_CONTAINER_MetaData * meta
Known meta-data for the file (can be NULL).
Definition: fs_api.h:1831
struct Location loc
Information needed to retrieve a file including signed location (identity of a peer) of the content...
Definition: fs_api.h:221
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_FS_Uri * uri
URI that identifies the file that we are downloading.
Definition: fs_api.h:1826
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1673
void GNUNET_FS_download_start_downloading_(struct GNUNET_FS_DownloadContext *dc)
Start the downloading process (by entering the queue).
Definition: fs_download.c:2244
Handle used to access files (and pipes).
static void schedule_block_download(struct GNUNET_FS_DownloadContext *dc, struct DownloadRequest *dr)
Schedule the download of the specified block in the tree.
Definition: fs_download.c:782
We&#39;ve determined the real, desired CHK for this block (full tree reconstruction failed), request is now pending.
Definition: fs_api.h:1669
Notification that this download encountered an error.
static struct GNUNET_FS_DownloadContext * dc
Argument given to the progress callback with information about what is going on.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_unindex_make_status_()

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.

Parameters
pistructure to fill in
ucoverall unindex context
offsetwhere we are in the file (for progress)

Definition at line 84 of file fs_unindex.c.

References GNUNET_FS_UnindexContext::client_info, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, GNUNET_FS_ProgressInfo::fsh, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_calculate_eta(), GNUNET_FS_UnindexContext::h, GNUNET_FS_UnindexContext::start_time, uc, GNUNET_FS_ProgressInfo::unindex, GNUNET_FS_Handle::upcb, GNUNET_FS_Handle::upcb_cls, and GNUNET_FS_ProgressInfo::value.

Referenced by deserialize_unindex_file(), GNUNET_FS_unindex_signal_suspend_(), GNUNET_FS_unindex_start(), GNUNET_FS_unindex_stop(), handle_unindex_response(), signal_unindex_error(), and unindex_progress().

87 {
88  pi->value.unindex.uc = uc;
89  pi->value.unindex.cctx = uc->client_info;
90  pi->value.unindex.filename = uc->filename;
91  pi->value.unindex.size = uc->file_size;
92  pi->value.unindex.eta =
94  pi->value.unindex.duration =
96  pi->value.unindex.completed = offset;
97  pi->fsh = uc->h;
98  uc->client_info = uc->h->upcb (uc->h->upcb_cls, pi);
99 }
static struct GNUNET_FS_UnindexContext * uc
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1474
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1406
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1102
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1107
struct GNUNET_TIME_Relative GNUNET_TIME_calculate_eta(struct GNUNET_TIME_Absolute start, uint64_t finished, uint64_t total)
Calculate the estimate time of arrival/completion for an operation.
Definition: time.c:549
void * client_info
Pointer kept for the client.
Definition: fs_api.h:1428
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1381
struct GNUNET_FS_ProgressInfo::@28::@32 unindex
Values for all "GNUNET_FS_STATUS_UNINDEX_*" events.
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1469
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_make_status_()

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.

Parameters
pistructure to fill in
hfile-sharing handle
scoverall search context
Returns
value returned by the callback

Definition at line 48 of file fs_search.c.

References GNUNET_FS_SearchContext::anonymity, GNUNET_FS_SearchResult::client_info, GNUNET_FS_SearchContext::client_info, GNUNET_FS_ProgressInfo::fsh, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_UNIT_ZERO, GNUNET_FS_SearchContext::psearch_result, ret, sc, GNUNET_FS_ProgressInfo::search, GNUNET_FS_SearchContext::start_time, GNUNET_FS_Handle::upcb, GNUNET_FS_Handle::upcb_cls, GNUNET_FS_SearchContext::uri, and GNUNET_FS_ProgressInfo::value.

Referenced by GNUNET_FS_search_continue(), GNUNET_FS_search_pause(), GNUNET_FS_search_signal_suspend_(), GNUNET_FS_search_stop(), notify_client_chk_result(), notify_client_chk_update(), search_result_stop(), search_result_suspend(), search_start(), signal_probe_result(), signal_result_resume(), and signal_search_resume().

51 {
52  void *ret;
53 
54  pi->value.search.sc = sc;
55  pi->value.search.cctx = (NULL != sc) ? sc->client_info : NULL;
56  pi->value.search.pctx =
57  ((NULL == sc) || (NULL == sc->psearch_result))
58  ? NULL
60  pi->value.search.query = (NULL != sc) ? sc->uri : NULL;
61  pi->value.search.duration = (NULL != sc)
64  pi->value.search.anonymity = (NULL != sc) ? sc->anonymity : 0;
65  pi->fsh = h;
66  ret = h->upcb (h->upcb_cls, pi);
67  return ret;
68 }
void * client_info
Client info for this search result.
Definition: fs_api.h:548
struct GNUNET_FS_ProgressInfo::@28::@31 search
Values for all "GNUNET_FS_STATUS_SEARCH_*" events.
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:1554
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1593
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1611
union GNUNET_FS_ProgressInfo::@28 value
Values that depend on the event type.
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
struct GNUNET_FS_Handle * fsh
File-sharing handle that generated the event.
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1102
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:373
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1107
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1564
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_unindex_do_remove_()

void GNUNET_FS_unindex_do_remove_ ( struct GNUNET_FS_UnindexContext uc)

Connect to the datastore and remove the blocks.

Parameters
uccontext for the unindex operation.

Definition at line 645 of file fs_unindex.c.

References _, GNUNET_FS_Handle::cfg, GNUNET_FS_UnindexContext::dsh, GNUNET_FS_UnindexContext::emsg, GNUNET_FS_UnindexContext::fh, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, GNUNET_DATASTORE_connect(), GNUNET_DATASTORE_disconnect(), GNUNET_DISK_file_open(), GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_FS_tree_encoder_create(), GNUNET_FS_tree_encoder_next(), GNUNET_FS_unindex_sync_(), GNUNET_NO, GNUNET_strdup, GNUNET_FS_UnindexContext::h, signal_unindex_error(), GNUNET_FS_UnindexContext::state, GNUNET_FS_UnindexContext::tc, unindex_extract_keywords(), unindex_process(), unindex_progress(), unindex_reader(), and UNINDEX_STATE_ERROR.

Referenced by deserialize_unindex_file(), and GNUNET_FS_unindex_process_hash_().

646 {
647  if (NULL == uc->dsh)
648  uc->dsh = GNUNET_DATASTORE_connect (uc->h->cfg);
649  if (NULL == uc->dsh)
650  {
652  uc->emsg = GNUNET_strdup (_("Failed to connect to `datastore' service."));
655  return;
656  }
657  uc->fh =
660  if (NULL == uc->fh)
661  {
663  uc->dsh = NULL;
665  uc->emsg = GNUNET_strdup (_("Failed to open file for unindexing."));
668  return;
669  }
670  uc->tc =
672  uc->file_size,
673  uc,
679 }
Open the file for reading.
static void signal_unindex_error(struct GNUNET_FS_UnindexContext *uc)
We&#39;ve encountered an error during unindexing.
Definition: fs_unindex.c:138
static void unindex_progress(void *cls, uint64_t offset, const void *pt_block, size_t pt_size, unsigned int depth)
Function called with information about our progress in computing the tree encoding.
Definition: fs_unindex.c:113
struct GNUNET_FS_TreeEncoder * tc
Merkle-ish tree encoder context.
Definition: fs_api.h:1433
Nobody is allowed to do anything to the file.
void GNUNET_FS_tree_encoder_next(struct GNUNET_FS_TreeEncoder *te)
Encrypt the next block of the file (and call proc and progress accordingly; or of course "cont" if we...
Definition: fs_tree.c:332
#define GNUNET_NO
Definition: gnunet_common.h:81
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1484
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service, only valid during the UNINDEX_STATE_DS_NOTIFY phase...
Definition: fs_api.h:1423
static void unindex_process(void *cls, const struct ContentHashKey *chk, uint64_t offset, unsigned int depth, enum GNUNET_BLOCK_Type type, const void *block, uint16_t block_size)
Function called asking for the current (encoded) block to be processed.
Definition: fs_unindex.c:193
#define _(String)
GNU gettext support macro.
Definition: platform.h:208
struct GNUNET_DISK_FileHandle * fh
Handle used to read the file.
Definition: fs_api.h:1438
We&#39;ve encountered a fatal error.
Definition: fs_api.h:1362
struct GNUNET_FS_TreeEncoder * GNUNET_FS_tree_encoder_create(struct GNUNET_FS_Handle *h, uint64_t size, void *cls, GNUNET_FS_DataReader reader, GNUNET_FS_TreeBlockProcessor proc, GNUNET_FS_TreeProgressCallback progress, GNUNET_SCHEDULER_TaskCallback cont)
Initialize a tree encoder.
Definition: fs_tree.c:270
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1406
void GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
Synchronize this unindex struct with its mirror on disk.
Definition: fs_api.c:1754
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
static void unindex_extract_keywords(void *cls)
Function called when the tree encoder has processed all blocks.
Definition: fs_unindex.c:629
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1459
static size_t unindex_reader(void *cls, uint64_t offset, size_t max, void *buf, char **emsg)
Function called by the tree encoder to obtain a block of plaintext data (for the lowest level of the ...
Definition: fs_unindex.c:51
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1381
struct GNUNET_DISK_FileHandle * GNUNET_DISK_file_open(const char *fn, enum GNUNET_DISK_OpenFlags flags, enum GNUNET_DISK_AccessPermissions perm)
Open a file.
Definition: disk.c:1673
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1469
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1092
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_start_searching_()

int GNUNET_FS_search_start_searching_ ( struct GNUNET_FS_SearchContext sc)

Build the request and actually initiate the search using the GNUnet FS service.

Parameters
scsearch context
Returns
GNUNET_OK on success, GNUNET_SYSERR on error
Parameters
scsearch context
Returns
GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 1387 of file fs_search.c.

References GNUNET_FS_Uri::data, do_reconnect(), SearchRequestEntry::dpub, GNUNET_assert, GNUNET_CONTAINER_multihashmap_create(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CRYPTO_ecdsa_key_get_anonymous(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_ecdsa_public_key_derive(), GNUNET_CRYPTO_hash(), GNUNET_FS_uri_test_ksk(), GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_strdup, GNUNET_SYSERR, SearchRequestEntry::keyword, GNUNET_FS_Uri::ksk, SearchRequestEntry::mandatory, GNUNET_FS_SearchContext::mandatory_count, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, GNUNET_FS_SearchContext::task, update_sre_result_maps(), SearchRequestEntry::uquery, and GNUNET_FS_SearchContext::uri.

Referenced by deserialize_search(), and search_start().

1388 {
1389  unsigned int i;
1390  const char *keyword;
1391  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
1392  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
1393  struct SearchRequestEntry *sre;
1394 
1395  GNUNET_assert (NULL == sc->mq);
1396  if (GNUNET_FS_uri_test_ksk (sc->uri))
1397  {
1398  GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
1400  GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
1401  sc->requests
1402  = GNUNET_new_array (sc->uri->data.ksk.keywordCount,
1403  struct SearchRequestEntry);
1404 
1405  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1406  {
1407  keyword = &sc->uri->data.ksk.keywords[i][1];
1408  sre = &sc->requests[i];
1409  sre->keyword = GNUNET_strdup (keyword);
1411  keyword,
1412  "fs-ublock",
1413  &sre->dpub);
1414  GNUNET_CRYPTO_hash (&sre->dpub,
1415  sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey),
1416  &sre->uquery);
1417  sre->mandatory = (sc->uri->data.ksk.keywords[i][0] == '+');
1418  if (sre->mandatory)
1419  sc->mandatory_count++;
1421  }
1424  sc);
1425  }
1426  GNUNET_assert (NULL == sc->task);
1427  do_reconnect (sc);
1428  if (NULL == sc->mq)
1429  {
1431  sc->task = NULL;
1432  return GNUNET_SYSERR;
1433  }
1434  return GNUNET_OK;
1435 }
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1323
const struct GNUNET_CRYPTO_EcdsaPrivateKey * GNUNET_CRYPTO_ecdsa_key_get_anonymous(void)
Get the shared private key we use for anonymous users.
Definition: crypto_ecc.c:814
void GNUNET_CRYPTO_ecdsa_public_key_derive(const struct GNUNET_CRYPTO_EcdsaPublicKey *pub, const char *label, const char *context, struct GNUNET_CRYPTO_EcdsaPublicKey *result)
Derive a public key from a given public key and a label.
Definition: crypto_ecc.c:1339
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:1606
uint32_t mandatory_count
Number of mandatory keywords in this query.
Definition: fs_api.h:1616
struct GNUNET_HashCode uquery
Hash of the public key, also known as the query.
Definition: fs_api.h:1498
struct GNUNET_CRYPTO_EcdsaPublicKey dpub
Derived public key, hashes to &#39;uquery&#39;.
Definition: fs_api.h:1503
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int mandatory
Is this keyword a mandatory keyword (started with &#39;+&#39;)?
Definition: fs_api.h:1525
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
Private ECC key encoded for transmission.
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
static void do_reconnect(void *cls)
Reconnect to the FS service and transmit our queries NOW.
Definition: fs_search.c:1250
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:1582
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:44
struct GNUNET_FS_Uri::@16::@17 ksk
union GNUNET_FS_Uri::@16 data
#define GNUNET_new_array(n, type)
Allocate a size n array with structs or unions of the given type.
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:1519
#define GNUNET_SYSERR
Definition: gnunet_common.h:79
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:241
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
static int update_sre_result_maps(void *cls, const struct GNUNET_HashCode *key, void *value)
Update the &#39;results&#39; map for the individual keywords with the results from the &#39;global&#39; result set...
Definition: fs_search.c:1359
Information we keep for each keyword in a keyword search.
Definition: fs_api.h:1492
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1509
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_download_start_downloading_()

void GNUNET_FS_download_start_downloading_ ( struct GNUNET_FS_DownloadContext dc)

Start the downloading process (by entering the queue).

Parameters
dcour download context

Definition at line 2244 of file fs_download.c.

References activate_fs_download(), GNUNET_FS_DownloadContext::active, GNUNET_FS_DownloadContext::completed, DBLOCK_SIZE, deactivate_fs_download(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_DOWNLOAD_IS_PROBE, GNUNET_FS_queue_(), GNUNET_FS_QUEUE_PRIORITY_NORMAL, GNUNET_FS_QUEUE_PRIORITY_PROBE, GNUNET_log, GNUNET_FS_DownloadContext::h, GNUNET_FS_DownloadContext::job_queue, GNUNET_FS_DownloadContext::length, GNUNET_FS_DownloadContext::mq, GNUNET_FS_DownloadContext::options, and GNUNET_FS_DownloadContext::task.

Referenced by GNUNET_FS_download_start_task_().

2245 {
2246  if (dc->completed == dc->length)
2247  return;
2248  if (NULL != dc->mq)
2249  return; /* already running */
2250  GNUNET_assert (NULL == dc->job_queue);
2251  GNUNET_assert (NULL == dc->task);
2252  GNUNET_assert (NULL != dc->active);
2253  dc->job_queue
2254  = GNUNET_FS_queue_ (dc->h,
2257  dc,
2258  (dc->length + DBLOCK_SIZE - 1) / DBLOCK_SIZE,
2259  (0 == (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
2263  "Download %p put into queue as job %p\n",
2264  dc,
2265  dc->job_queue);
2266 }
This is a probe (low priority).
Definition: fs_api.h:420
enum GNUNET_FS_DownloadOptions options
Options for the download.
Definition: fs_api.h:1949
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1774
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static void activate_fs_download(void *cls)
We&#39;re allowed to ask the FS service for our blocks.
Definition: fs_download.c:1433
uint64_t length
How many bytes starting from offset are desired? This is NOT the overall length of the file! ...
Definition: fs_api.h:1910
Internal option used to flag this download as a &#39;probe&#39; for a search result.
struct GNUNET_FS_QueueEntry * GNUNET_FS_queue_(struct GNUNET_FS_Handle *h, GNUNET_SCHEDULER_TaskCallback start, GNUNET_SCHEDULER_TaskCallback stop, void *cls, unsigned int blocks, enum GNUNET_FS_QueuePriority priority)
Add a job to the queue.
Definition: fs_api.c:328
struct GNUNET_CONTAINER_MultiHashMap * active
Map of active requests (those waiting for a response).
Definition: fs_api.h:1877
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the download is being stopped ...
Definition: fs_api.h:1898
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
static void deactivate_fs_download(void *cls)
We must stop to ask the FS service for our blocks.
Definition: fs_download.c:1456
#define GNUNET_log(kind,...)
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1784
uint64_t completed
How many bytes have we already received within the specified range (DBlocks only).
Definition: fs_api.h:1916
Default priority.
Definition: fs_api.h:425
struct GNUNET_FS_QueueEntry * job_queue
Our entry in the job queue.
Definition: fs_api.h:1860
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_start_probe_()

void GNUNET_FS_search_start_probe_ ( struct GNUNET_FS_SearchResult sr)

Start download probes for the given search result.

Parameters
srthe search result

Definition at line 427 of file fs_search.c.

References GNUNET_FS_SearchResult::anonymity, GNUNET_FS_SearchResult::availability_success, GNUNET_FS_SearchResult::availability_trials, AVAILABILITY_TRIALS_MAX, GNUNET_FS_Handle::avg_block_latency, DBLOCK_SIZE, GNUNET_FS_SearchResult::download, GNUNET_FS_Handle::flags, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_DOWNLOAD_IS_PROBE, GNUNET_FS_DOWNLOAD_NO_TEMPORARIES, GNUNET_FS_download_start(), GNUNET_FS_FLAGS_DO_PROBES, GNUNET_FS_URI_CHK, GNUNET_FS_uri_chk_get_file_size(), GNUNET_FS_URI_LOC, GNUNET_log, GNUNET_TIME_relative_saturating_multiply(), GNUNET_FS_SearchResult::h, len, GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::probe_ctx, GNUNET_FS_SearchResult::remaining_probe_time, start_probe_ping_task(), GNUNET_FS_Uri::type, and GNUNET_FS_SearchResult::uri.

Referenced by GNUNET_FS_probe(), process_ksk_result(), process_sks_result(), search_result_resume_probes(), signal_probe_result(), and signal_result_resume().

428 {
429  uint64_t off;
430  uint64_t len;
431 
432  if (NULL != sr->probe_ctx)
433  return;
434  if (NULL != sr->download)
435  return;
436  if (0 == (sr->h->flags & GNUNET_FS_FLAGS_DO_PROBES))
437  return;
439  return;
440  if ( (GNUNET_FS_URI_CHK != sr->uri->type) && (GNUNET_FS_URI_LOC != sr->uri->type))
441  return;
443  if (0 == len)
444  return;
445  if ((len <= DBLOCK_SIZE) && (sr->availability_success > 0))
446  return;
447  off = len / DBLOCK_SIZE;
448  if (off > 0)
450  off *= DBLOCK_SIZE;
451  if (len - off < DBLOCK_SIZE)
452  len = len - off;
453  else
454  len = DBLOCK_SIZE;
456  "Starting probe #%u (at offset %llu) for search result %p\n",
457  sr->availability_trials + 1,
458  (unsigned long long) off,
459  sr);
462  2 * (1 + sr->availability_trials));
463  sr->probe_ctx =
464  GNUNET_FS_download_start (sr->h, sr->uri, sr->meta, NULL, NULL, off,
465  len, sr->anonymity,
467  GNUNET_FS_DOWNLOAD_IS_PROBE, sr, NULL);
469 }
static void start_probe_ping_task(struct GNUNET_FS_SearchResult *sr)
Start the ping task for this search result.
Definition: fs_search.c:386
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:560
struct GNUNET_TIME_Relative avg_block_latency
Average time we take for a single request to be satisfied.
Definition: fs_api.h:1165
uint32_t GNUNET_CRYPTO_random_u32(enum GNUNET_CRYPTO_Quality mode, uint32_t i)
Produce a random value.
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
struct GNUNET_FS_DownloadContext * probe_ctx
ID of a job that is currently probing this results&#39; availability (NULL if we are not currently probin...
Definition: fs_api.h:554
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.
Definition: fs_download.c:2126
Do not append temporary data to the target file (for the IBlocks).
struct GNUNET_TIME_Relative remaining_probe_time
How much longer should we run the current probe before giving up?
Definition: fs_api.h:598
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:627
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
Should we automatically trigger probes for search results to determine availability? (will create GNUNET_FS_STATUS_SEARCH_UPDATE events).
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:621
Internal option used to flag this download as a &#39;probe&#39; for a search result.
uint32_t anonymity
Anonymity level to use for probes using this search result.
Definition: fs_api.h:603
#define AVAILABILITY_TRIALS_MAX
Number of availability trials we perform per search result.
Definition: fs_search.c:36
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
Content-hash-key (simple file).
Definition: fs_api.h:146
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:173
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?
Definition: fs_uri.c:1359
#define GNUNET_log(kind,...)
Location (chk with identity of hosting peer).
Definition: fs_api.h:161
struct GNUNET_TIME_Relative GNUNET_TIME_relative_saturating_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Saturating multiply relative time by a given factor.
Definition: time.c:499
No good quality of the operation is needed (i.e., random numbers can be pseudo-random).
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
enum GNUNET_FS_Flags flags
General flags.
Definition: fs_api.h:1180
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_remove_sync_file_()

void GNUNET_FS_remove_sync_file_ ( struct GNUNET_FS_Handle h,
const char *  ext,
const char *  ent 
)

Remove serialization/deserialization file from disk.

Parameters
hmaster context
extcomponent of the path
ententity identifier

Definition at line 738 of file fs_api.c.

References FileInfo::filename, get_serialization_file_name(), GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror_file, and UNLINK.

Referenced by deserialize_search_file(), deserialize_unindex_file(), fip_signal_stop(), free_search_context(), GNUNET_FS_download_stop(), GNUNET_FS_publish_stop(), GNUNET_FS_publish_sync_(), GNUNET_FS_search_stop(), GNUNET_FS_search_sync_(), GNUNET_FS_unindex_stop(), GNUNET_FS_unindex_sync_(), and search_result_stop().

741 {
742  char *filename;
743 
744  if ((NULL == ent) || (0 == strlen (ent)))
745  {
746  GNUNET_break (0);
747  return;
748  }
749  filename = get_serialization_file_name (h, ext, ent);
750  if (NULL != filename)
751  {
752  if ( (0 != UNLINK (filename)) &&
753  (ENOENT != errno) )
755  GNUNET_free (filename);
756  }
757 }
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define UNLINK(f)
Definition: plibc.h:666
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static char * filename
static char * get_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return the full filename where we would store state information (for serialization/deserialization).
Definition: fs_api.c:599
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_remove_sync_dir_()

void GNUNET_FS_remove_sync_dir_ ( struct GNUNET_FS_Handle h,
const char *  ext,
const char *  uni 
)

Remove serialization/deserialization directory from disk.

Parameters
hmaster context
extcomponent of the path
uniunique name of parent

Definition at line 797 of file fs_api.c.

References get_serialization_file_name_in_dir(), GNUNET_DISK_directory_remove(), GNUNET_DISK_directory_test(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log_strerror_file, GNUNET_OK, and GNUNET_YES.

Referenced by free_search_context(), GNUNET_FS_download_stop(), and GNUNET_FS_search_stop().

800 {
801  char *dn;
802 
803  if (NULL == uni)
804  return;
805  dn = get_serialization_file_name_in_dir (h, ext, uni, "");
806  if (NULL == dn)
807  return;
811  GNUNET_free (dn);
812 }
int GNUNET_DISK_directory_test(const char *fil, int is_readable)
Test if fil is a directory and listable.
Definition: disk.c:628
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static char * get_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni, const char *ent)
Return the full filename where we would store state information (for serialization/deserialization) t...
Definition: fs_api.c:632
int GNUNET_DISK_directory_remove(const char *filename)
Remove all files in a directory (rm -rf).
Definition: disk.c:1359
#define GNUNET_YES
Definition: gnunet_common.h:80
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_file_information_sync_()

void GNUNET_FS_file_information_sync_ ( struct GNUNET_FS_FileInformation fi)

Synchronize this file-information struct with its mirror on disk.

Note that all internal FS-operations that change file information data should already call "sync" internally, so this function is likely not useful for clients.

Parameters
fithe struct to sync

Synchronize this file-information struct with its mirror on disk.

Parameters
fifile information to sync with disk

Definition at line 1296 of file fs_api.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_FS_BlockOptions::anonymity_level, GNUNET_FS_FileInformation::bo, GNUNET_FS_FileInformation::chk_uri, cleanup(), GNUNET_FS_BlockOptions::content_priority, GNUNET_FS_FileInformation::contents_completed, GNUNET_FS_FileInformation::contents_size, copy_from_reader(), GNUNET_FS_FileInformation::data, GNUNET_FS_FileInformation::dir, GNUNET_FS_FileInformation::dir_data, GNUNET_FS_FileInformation::dir_size, GNUNET_FS_FileInformation::emsg, entries, GNUNET_FS_FileInformation::entries, GNUNET_FS_BlockOptions::expiration_time, GNUNET_FS_FileInformation::file, GNUNET_FS_FileInformation::filename, fn, get_serialization_file_name(), get_write_handle(), GNUNET_assert, GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_meta_data(), GNUNET_BIO_write_string(), GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_FS_file_information_sync_(), GNUNET_FS_SYNC_PATH_FILE_INFO, GNUNET_FS_uri_to_string(), GNUNET_log_strerror_file, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_FS_FileInformation::h, GNUNET_FS_FileInformation::is_directory, GNUNET_FS_FileInformation::is_published, GNUNET_FS_FileInformation::keywords, make_serialization_file_name(), GNUNET_FS_FileInformation::meta, GNUNET_FS_FileInformation::next, GNUNET_FS_BlockOptions::replication_level, GNUNET_FS_FileInformation::serialization, GNUNET_FS_FileInformation::sks_uri, GNUNET_FS_FileInformation::start_time, UNLINK, wh, and write_start_time().

Referenced by encode_cont(), fip_signal_start(), GNUNET_FS_file_information_sync_(), GNUNET_FS_publish_main_(), handle_index_start_failed(), handle_index_start_ok(), handle_signature_response(), hash_for_index_cb(), index_mq_error_handler(), publish_content(), and publish_kblocks_cont().

1297 {
1298  char *fn;
1299  struct GNUNET_BIO_WriteHandle *wh;
1300  char b;
1301  char *ksks;
1302  char *chks;
1303  char *skss;
1304 
1305  if (NULL == fi->serialization)
1306  fi->serialization =
1308  if (NULL == fi->serialization)
1309  return;
1311  fi->serialization);
1312  if (NULL == wh)
1313  {
1314  GNUNET_free (fi->serialization);
1315  fi->serialization = NULL;
1316  return;
1317  }
1318  if (GNUNET_YES == fi->is_directory)
1319  b = 4;
1320  else if (GNUNET_YES == fi->data.file.index_start_confirmed)
1321  b = 3;
1322  else if (GNUNET_YES == fi->data.file.have_hash)
1323  b = 2;
1324  else if (GNUNET_YES == fi->data.file.do_index)
1325  b = 1;
1326  else
1327  b = 0;
1328  if (NULL != fi->keywords)
1329  ksks = GNUNET_FS_uri_to_string (fi->keywords);
1330  else
1331  ksks = NULL;
1332  if (NULL != fi->chk_uri)
1333  chks = GNUNET_FS_uri_to_string (fi->chk_uri);
1334  else
1335  chks = NULL;
1336  if (NULL != fi->sks_uri)
1337  skss = GNUNET_FS_uri_to_string (fi->sks_uri);
1338  else
1339  skss = NULL;
1340  if ((GNUNET_OK != GNUNET_BIO_write (wh, &b, sizeof (b))) ||
1341  (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, fi->meta)) ||
1342  (GNUNET_OK != GNUNET_BIO_write_string (wh, ksks)) ||
1343  (GNUNET_OK != GNUNET_BIO_write_string (wh, chks)) ||
1344  (GNUNET_OK != GNUNET_BIO_write_string (wh, skss)) ||
1345  (GNUNET_OK != write_start_time (wh, fi->start_time)) ||
1346  (GNUNET_OK != GNUNET_BIO_write_string (wh, fi->emsg)) ||
1347  (GNUNET_OK != GNUNET_BIO_write_string (wh, fi->filename)) ||
1348  (GNUNET_OK !=
1353  {
1354  GNUNET_break (0);
1355  goto cleanup;
1356  }
1357  GNUNET_free_non_null (chks);
1358  chks = NULL;
1359  GNUNET_free_non_null (ksks);
1360  ksks = NULL;
1361  GNUNET_free_non_null (skss);
1362  skss = NULL;
1363 
1364  switch (b)
1365  {
1366  case 0: /* file-insert */
1367  if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, fi->data.file.file_size))
1368  {
1369  GNUNET_break (0);
1370  goto cleanup;
1371  }
1372  if ((GNUNET_NO == fi->is_published) && (NULL == fi->filename))
1373  if (GNUNET_OK != copy_from_reader (wh, fi))
1374  {
1375  GNUNET_break (0);
1376  goto cleanup;
1377  }
1378  break;
1379  case 1: /* file-index, no hash */
1380  if (NULL == fi->filename)
1381  {
1382  GNUNET_break (0);
1383  goto cleanup;
1384  }
1385  if (GNUNET_OK != GNUNET_BIO_write_int64 (wh, fi->data.file.file_size))
1386  {
1387  GNUNET_break (0);
1388  goto cleanup;
1389  }
1390  break;
1391  case 2: /* file-index-with-hash */
1392  case 3: /* file-index-with-hash-confirmed */
1393  if (NULL == fi->filename)
1394  {
1395  GNUNET_break (0);
1396  goto cleanup;
1397  }
1398  if ((GNUNET_OK != GNUNET_BIO_write_int64 (wh, fi->data.file.file_size)) ||
1399  (GNUNET_OK !=
1400  GNUNET_BIO_write (wh, &fi->data.file.file_id,
1401  sizeof (struct GNUNET_HashCode))))
1402  {
1403  GNUNET_break (0);
1404  goto cleanup;
1405  }
1406  break;
1407  case 4: /* directory */
1408  if ( (NULL != fi->data.dir.entries) &&
1409  (NULL == fi->data.dir.entries->serialization) )
1411  if ((GNUNET_OK != GNUNET_BIO_write_int32 (wh, fi->data.dir.dir_size)) ||
1414  (GNUNET_OK !=
1415  GNUNET_BIO_write (wh, fi->data.dir.dir_data,
1416  (uint32_t) fi->data.dir.dir_size)) ||
1417  (GNUNET_OK !=
1419  (fi->data.dir.entries ==
1420  NULL) ? NULL : fi->data.dir.
1421  entries->serialization)))
1422  {
1423  GNUNET_break (0);
1424  goto cleanup;
1425  }
1426  break;
1427  default:
1428  GNUNET_assert (0);
1429  goto cleanup;
1430  }
1431  if ( (NULL != fi->next) &&
1432  (NULL == fi->next->serialization) )
1434  if (GNUNET_OK !=
1436  (fi->next !=
1437  NULL) ? fi->next->serialization : NULL))
1438  {
1439  GNUNET_break (0);
1440  goto cleanup;
1441  }
1442  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
1443  {
1444  wh = NULL;
1445  GNUNET_break (0);
1446  goto cleanup;
1447  }
1448  return; /* done! */
1449 cleanup:
1450  if (NULL != wh)
1451  (void) GNUNET_BIO_write_close (wh);
1452  GNUNET_free_non_null (chks);
1453  GNUNET_free_non_null (ksks);
1454  GNUNET_free_non_null (skss);
1456  fi->serialization);
1457  if (NULL != fn)
1458  {
1459  if (0 != UNLINK (fn))
1461  GNUNET_free (fn);
1462  }
1463  GNUNET_free (fi->serialization);
1464  fi->serialization = NULL;
1465 }
struct GNUNET_TIME_Absolute expiration_time
At what time should the block expire? Data blocks (DBLOCKS and IBLOCKS) may still be used even if the...
struct GNUNET_FS_FileInformation * entries
Linked list of entries in the directory.
Definition: fs_api.h:371
int GNUNET_BIO_write_meta_data(struct GNUNET_BIO_WriteHandle *h, const struct GNUNET_CONTAINER_MetaData *m)
Write metadata container to a file.
Definition: bio.c:569
struct GNUNET_FS_FileInformation * dir
If this is a file in a directory, "dir" refers to the directory; otherwise NULL.
Definition: fs_api.h:243
void GNUNET_FS_file_information_sync_(struct GNUNET_FS_FileInformation *fi)
Create a temporary file on disk to store the current state of fi in.
Definition: fs_api.c:1296
struct GNUNET_CONTAINER_MetaData * meta
Metadata to use for the file.
Definition: fs_api.h:258
struct GNUNET_FS_FileInformation::@19::@20 file
Data for a file.
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:302
char * serialization
Under what filename is this struct serialized (for operational persistence).
Definition: fs_api.h:292
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:547
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, int64_t i)
Write an (u)int64_t.
Definition: bio.c:623
struct GNUNET_TIME_Absolute start_time
At what time did we start this upload?
Definition: fs_api.h:285
char * filename
Name of the file or directory (must be an absolute path).
Definition: fs_api.h:307
static struct GNUNET_BIO_WriteHandle * get_write_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return a write handle for serialization.
Definition: fs_api.c:688
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
struct GNUNET_FS_Handle * h
Handle to the master context.
Definition: fs_api.h:248
void * dir_data
Pointer to the data for the directory (or NULL if not available).
Definition: fs_api.h:383
uint64_t abs_value_us
The actual value.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define UNLINK(f)
Definition: plibc.h:666
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:1988
uint32_t anonymity_level
At which anonymity level should the block be shared? (0: no anonymity, 1: normal GAP, >1: with cover traffic).
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static char * fn
Filename of the unique file.
struct ListEntry * entries
List of peers in the list.
int is_directory
Is this struct for a file or directory?
Definition: fs_api.h:402
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
Handle for buffered writing.
Definition: bio.c:399
struct GNUNET_FS_Uri * chk_uri
CHK for this file or directory.
Definition: fs_api.h:269
A 512-bit hashcode.
uint64_t contents_size
Sum of all of the sizes of all of the files in the directory.
Definition: fs_api.h:393
#define GNUNET_FS_SYNC_PATH_FILE_INFO
Name of the directory with files that are being published.
Definition: fs_api.h:81
static char * get_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return the full filename where we would store state information (for serialization/deserialization).
Definition: fs_api.c:599
static int write_start_time(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_TIME_Absolute timestamp)
Serialize a start-time.
Definition: fs_api.c:830
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
struct GNUNET_FS_FileInformation * next
Files in a directory are kept as a linked list.
Definition: fs_api.h:237
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:457
struct GNUNET_FS_BlockOptions bo
Block options for the file.
Definition: fs_api.h:280
uint32_t replication_level
How often should we try to migrate the block to other peers? Only used if "CONTENT_PUSHING" is set to...
union GNUNET_FS_FileInformation::@19 data
Data describing either the file or the directory.
static char * make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
Create a new random name for serialization.
Definition: fs_api.c:1187
struct GNUNET_FS_Uri * keywords
Keywords to use for KBlocks.
Definition: fs_api.h:263
uint32_t content_priority
How important is it for us to store the block? If we run out of space, the highest-priority, non-expired blocks will be kept.
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:605
uint64_t contents_completed
How much of the directory have we published (relative to contents_size).
Definition: fs_api.h:388
#define GNUNET_YES
Definition: gnunet_common.h:80
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:505
int is_published
Are we done publishing this file?
Definition: fs_api.h:407
size_t dir_size
Size of the directory itself (in bytes); 0 if the size has not yet been calculated.
Definition: fs_api.h:377
static int copy_from_reader(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_FS_FileInformation *fi)
Copy all of the data from the reader to the write handle.
Definition: fs_api.c:1260
struct GNUNET_FS_Uri * sks_uri
SKS URI for this file or directory.
Definition: fs_api.h:275
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_publish_sync_()

void GNUNET_FS_publish_sync_ ( struct GNUNET_FS_PublishContext pc)

Synchronize this publishing struct with its mirror on disk.

Note that all internal FS-operations that change publishing structs should already call "sync" internally, so this function is likely not useful for clients.

Parameters
pcthe struct to sync

Definition at line 1685 of file fs_api.c.

References GNUNET_FS_PublishContext::all_done, cleanup(), GNUNET_FS_PublishContext::fi, GNUNET_FS_PublishContext::fi_pos, get_write_handle(), GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_string(), GNUNET_break, GNUNET_free, GNUNET_FS_remove_sync_file_(), GNUNET_FS_SYNC_PATH_MASTER_PUBLISH, GNUNET_NO, GNUNET_OK, GNUNET_YES, GNUNET_FS_PublishContext::h, make_serialization_file_name(), GNUNET_FS_PublishContext::nid, GNUNET_FS_PublishContext::ns, GNUNET_FS_PublishContext::nuid, GNUNET_FS_PublishContext::options, GNUNET_FS_FileInformation::serialization, GNUNET_FS_PublishContext::serialization, and wh.

Referenced by finish_release_reserve(), GNUNET_FS_publish_main_(), GNUNET_FS_publish_start(), handle_index_start_failed(), handle_signature_response(), publish_kblocks_cont(), and publish_sblocks_cont().

1686 {
1687  struct GNUNET_BIO_WriteHandle *wh;
1688  int32_t have_ns;
1689 
1690  if (NULL == pc->serialization)
1691  pc->serialization =
1694  if (NULL == pc->serialization)
1695  return;
1696  if (NULL == pc->fi)
1697  return;
1698  if (NULL == pc->fi->serialization)
1699  {
1700  GNUNET_break (0);
1701  return;
1702  }
1704  pc->serialization);
1705  if (NULL == wh)
1706  {
1707  GNUNET_break (0);
1708  goto cleanup;
1709  }
1710  have_ns = (NULL != pc->ns) ? GNUNET_YES : GNUNET_NO;
1711  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, pc->nid)) ||
1712  (GNUNET_OK != GNUNET_BIO_write_string (wh, pc->nuid)) ||
1713  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pc->options)) ||
1714  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, pc->all_done)) ||
1715  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, have_ns)) ||
1717  (GNUNET_OK !=
1719  (NULL == pc->fi_pos) ? NULL : pc->fi_pos->serialization)) ||
1720  ( (NULL != pc->ns) &&
1721  (GNUNET_OK != GNUNET_BIO_write (wh,
1722  pc->ns,
1723  sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey)) ) ))
1724  {
1725  GNUNET_break (0);
1726  goto cleanup;
1727  }
1728  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
1729  {
1730  wh = NULL;
1731  GNUNET_break (0);
1732  goto cleanup;
1733  }
1734  return;
1735 cleanup:
1736  if (NULL != wh)
1737  (void) GNUNET_BIO_write_close (wh);
1739  pc->serialization);
1740  GNUNET_free (pc->serialization);
1741  pc->serialization = NULL;
1742 }
char * nid
ID of the content in the namespace, NULL if we have no namespace.
Definition: fs_api.h:1223
char * serialization
Under what filename is this struct serialized (for operational persistence).
Definition: fs_api.h:292
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:547
static struct GNUNET_BIO_WriteHandle * get_write_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return a write handle for serialization.
Definition: fs_api.c:688
enum GNUNET_FS_PublishOptions options
Options for publishing.
Definition: fs_api.h:1294
#define GNUNET_NO
Definition: gnunet_common.h:81
struct GNUNET_FS_Handle * h
Handle to the global fs context.
Definition: fs_api.h:1203
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
char * serialization
Filename used for serializing information about this operation (should be determined using &#39;mktemp&#39;)...
Definition: fs_api.h:1234
Private ECC key encoded for transmission.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
char * nuid
ID for future updates, NULL if we have no namespace or no updates.
Definition: fs_api.h:1228
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
struct GNUNET_FS_FileInformation * fi_pos
Current position in the file-tree for the upload.
Definition: fs_api.h:1245
Handle for buffered writing.
Definition: bio.c:399
int all_done
Set to GNUNET_YES if all processing has completed.
Definition: fs_api.h:1311
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:457
struct GNUNET_FS_FileInformation * fi
File-structure that is being shared.
Definition: fs_api.h:1213
static char * make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
Create a new random name for serialization.
Definition: fs_api.c:1187
struct GNUNET_CRYPTO_EcdsaPrivateKey * ns
Namespace that we are publishing in, NULL if we have no namespace.
Definition: fs_api.h:1218
#define GNUNET_FS_SYNC_PATH_MASTER_PUBLISH
Name of the directory with publishing operations.
Definition: fs_api.h:76
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:605
#define GNUNET_YES
Definition: gnunet_common.h:80
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:505
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:738
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_unindex_sync_()

void GNUNET_FS_unindex_sync_ ( struct GNUNET_FS_UnindexContext uc)

Synchronize this unindex struct with its mirror on disk.

Note that all internal FS-operations that change publishing structs should already call "sync" internally, so this function is likely not useful for clients.

Parameters
ucthe struct to sync

Definition at line 1754 of file fs_api.c.

References GNUNET_FS_UnindexContext::chk, cleanup(), GNUNET_FS_UnindexContext::emsg, GNUNET_FS_UnindexContext::file_id, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, get_write_handle(), GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_string(), GNUNET_break, GNUNET_free, GNUNET_FS_remove_sync_file_(), GNUNET_FS_SYNC_PATH_MASTER_UNINDEX, GNUNET_FS_uri_to_string(), GNUNET_OK, GNUNET_FS_UnindexContext::h, GNUNET_FS_UnindexContext::ksk_offset, GNUNET_FS_UnindexContext::ksk_uri, make_serialization_file_name(), GNUNET_FS_UnindexContext::serialization, GNUNET_FS_UnindexContext::start_time, GNUNET_FS_UnindexContext::state, UNINDEX_STATE_ERROR, UNINDEX_STATE_FS_NOTIFY, wh, and write_start_time().

Referenced by GNUNET_FS_unindex_do_remove_(), GNUNET_FS_unindex_do_remove_kblocks_(), GNUNET_FS_unindex_process_hash_(), GNUNET_FS_unindex_start(), handle_unindex_response(), unindex_directory_scan_cb(), unindex_extract_keywords(), unindex_finish(), and unindex_mq_error_handler().

1755 {
1756  struct GNUNET_BIO_WriteHandle *wh;
1757  char *uris;
1758 
1759  if (NULL == uc->serialization)
1760  uc->serialization =
1763  if (NULL == uc->serialization)
1764  return;
1766  uc->serialization);
1767  if (NULL == wh)
1768  {
1769  GNUNET_break (0);
1770  goto cleanup;
1771  }
1772  if (NULL != uc->ksk_uri)
1773  uris = GNUNET_FS_uri_to_string (uc->ksk_uri);
1774  else
1775  uris = NULL;
1776  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uc->filename)) ||
1777  (GNUNET_OK != GNUNET_BIO_write_int64 (wh, uc->file_size)) ||
1778  (GNUNET_OK != write_start_time (wh, uc->start_time)) ||
1779  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) uc->state)) ||
1780  (GNUNET_OK !=
1781  GNUNET_BIO_write (wh, &uc->chk, sizeof (struct ContentHashKey))) ||
1782  (GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
1783  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) uc->ksk_offset)) ||
1784  ((uc->state == UNINDEX_STATE_FS_NOTIFY) &&
1785  (GNUNET_OK !=
1786  GNUNET_BIO_write (wh, &uc->file_id, sizeof (struct GNUNET_HashCode)))) ||
1787  ((uc->state == UNINDEX_STATE_ERROR) &&
1788  (GNUNET_OK != GNUNET_BIO_write_string (wh, uc->emsg))))
1789  {
1790  GNUNET_break (0);
1791  goto cleanup;
1792  }
1793  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
1794  {
1795  wh = NULL;
1796  GNUNET_break (0);
1797  goto cleanup;
1798  }
1799  return;
1800 cleanup:
1801  if (NULL != wh)
1802  (void) GNUNET_BIO_write_close (wh);
1804  uc->serialization);
1805  GNUNET_free (uc->serialization);
1806  uc->serialization = NULL;
1807 }
char * serialization
Short name under which we are serializing the state of this operation.
Definition: fs_api.h:1411
content hash key
Definition: fs.h:53
uint32_t ksk_offset
Current offset in KSK removal.
Definition: fs_api.h:1401
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:547
int GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, int64_t i)
Write an (u)int64_t.
Definition: bio.c:623
static struct GNUNET_BIO_WriteHandle * get_write_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return a write handle for serialization.
Definition: fs_api.c:688
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
struct GNUNET_HashCode file_id
Hash of the file&#39;s contents (once computed).
Definition: fs_api.h:1479
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1484
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
We&#39;re notifying the FS service about the unindexing.
Definition: fs_api.h:1352
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:1988
#define GNUNET_FS_SYNC_PATH_MASTER_UNINDEX
Name of the directory with unindex operations.
Definition: fs_api.h:86
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1474
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
Handle for buffered writing.
Definition: bio.c:399
We&#39;ve encountered a fatal error.
Definition: fs_api.h:1362
struct GNUNET_FS_Uri * ksk_uri
Keywords found (telling us which KBlocks to remove).
Definition: fs_api.h:1396
A 512-bit hashcode.
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1406
static int write_start_time(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_TIME_Absolute timestamp)
Serialize a start-time.
Definition: fs_api.c:830
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:457
static char * make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
Create a new random name for serialization.
Definition: fs_api.c:1187
struct ContentHashKey chk
The content hash key of the last block we processed, will in the end be set to the CHK from the URI...
Definition: fs_api.h:1376
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:605
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1459
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:505
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1381
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:738
#define GNUNET_free(ptr)
Wrapper around free.
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1469
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_sync_()

void GNUNET_FS_search_sync_ ( struct GNUNET_FS_SearchContext sc)

Synchronize this search struct with its mirror on disk.

Note that all internal FS-operations that change publishing structs should already call "sync" internally, so this function is likely not useful for clients.

Parameters
scthe struct to sync

Definition at line 2135 of file fs_api.c.

References GNUNET_FS_SearchContext::anonymity, cleanup(), GNUNET_FS_SearchContext::emsg, get_write_handle(), GNUNET_assert, GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_string(), GNUNET_break, GNUNET_free, GNUNET_free_non_null, GNUNET_FS_remove_sync_file_(), GNUNET_FS_SYNC_PATH_CHILD_SEARCH, GNUNET_FS_SYNC_PATH_MASTER_SEARCH, GNUNET_FS_uri_test_ksk(), GNUNET_FS_uri_test_sks(), GNUNET_FS_uri_to_string(), GNUNET_OK, GNUNET_YES, GNUNET_FS_SearchContext::h, make_serialization_file_name(), GNUNET_FS_SearchContext::options, GNUNET_FS_SearchContext::psearch_result, GNUNET_FS_SearchContext::serialization, GNUNET_FS_SearchContext::start_time, GNUNET_FS_SearchContext::task, GNUNET_FS_SearchContext::uri, wh, and write_start_time().

Referenced by GNUNET_FS_search_continue(), GNUNET_FS_search_pause(), and search_start().

2136 {
2137  struct GNUNET_BIO_WriteHandle *wh;
2138  char *uris;
2139  char in_pause;
2140  const char *category;
2141 
2142  category =
2143  (NULL == sc->psearch_result)
2146  if (NULL == sc->serialization)
2147  sc->serialization = make_serialization_file_name (sc->h, category);
2148  if (NULL == sc->serialization)
2149  return;
2150  uris = NULL;
2151  wh = get_write_handle (sc->h, category, sc->serialization);
2152  if (NULL == wh)
2153  {
2154  GNUNET_break (0);
2155  goto cleanup;
2156  }
2159  uris = GNUNET_FS_uri_to_string (sc->uri);
2160  in_pause = (sc->task != NULL) ? 'r' : '\0';
2161  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
2162  (GNUNET_OK != write_start_time (wh, sc->start_time)) ||
2163  (GNUNET_OK != GNUNET_BIO_write_string (wh, sc->emsg)) ||
2164  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) sc->options)) ||
2165  (GNUNET_OK != GNUNET_BIO_write (wh, &in_pause, sizeof (in_pause))) ||
2167  {
2168  GNUNET_break (0);
2169  goto cleanup;
2170  }
2171  GNUNET_free (uris);
2172  uris = NULL;
2173  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
2174  {
2175  wh = NULL;
2176  GNUNET_break (0);
2177  goto cleanup;
2178  }
2179  return;
2180 cleanup:
2181  if (NULL != wh)
2182  (void) GNUNET_BIO_write_close (wh);
2183  GNUNET_free_non_null (uris);
2184  GNUNET_FS_remove_sync_file_ (sc->h, category, sc->serialization);
2185  GNUNET_free (sc->serialization);
2186  sc->serialization = NULL;
2187 }
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1323
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:1606
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:1554
enum GNUNET_FS_SearchOptions options
Options for the search.
Definition: fs_api.h:1621
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:547
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1574
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1593
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
static struct GNUNET_BIO_WriteHandle * get_write_handle(struct GNUNET_FS_Handle *h, const char *ext, const char *ent)
Return a write handle for serialization.
Definition: fs_api.c:688
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
int GNUNET_FS_uri_test_sks(const struct GNUNET_FS_Uri *uri)
Is this a namespace URI?
Definition: fs_uri.c:1270
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
uint32_t anonymity
Anonymity level for the search.
Definition: fs_api.h:1611
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:1988
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1569
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
Handle for buffered writing.
Definition: bio.c:399
#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH
Name of the directory with sub-searches (namespace-updates).
Definition: fs_api.h:59
static int write_start_time(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_TIME_Absolute timestamp)
Serialize a start-time.
Definition: fs_api.c:830
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:457
#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH
Name of the directory with top-level searches.
Definition: fs_api.h:54
static char * make_serialization_file_name(struct GNUNET_FS_Handle *h, const char *ext)
Create a new random name for serialization.
Definition: fs_api.c:1187
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:605
#define GNUNET_YES
Definition: gnunet_common.h:80
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:505
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:738
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_result_sync_()

void GNUNET_FS_search_result_sync_ ( struct GNUNET_FS_SearchResult sr)

Synchronize this search result with its mirror on disk.

Note that all internal FS-operations that change publishing structs should already call "sync" internally, so this function is likely not useful for clients.

Parameters
srthe struct to sync

Definition at line 2048 of file fs_api.c.

References GNUNET_FS_SearchResult::availability_success, GNUNET_FS_SearchResult::availability_trials, cleanup(), GNUNET_FS_Uri::data, GNUNET_FS_SearchResult::download, get_write_handle_in_dir(), GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_meta_data(), GNUNET_BIO_write_string(), GNUNET_break, GNUNET_free, GNUNET_free_non_null, GNUNET_FS_SYNC_PATH_CHILD_SEARCH, GNUNET_FS_SYNC_PATH_MASTER_SEARCH, GNUNET_FS_URI_KSK, GNUNET_FS_uri_to_string(), GNUNET_OK, GNUNET_FS_SearchResult::h, GNUNET_FS_SearchResult::key, GNUNET_FS_SearchResult::keyword_bitmap, GNUNET_FS_Uri::ksk, make_serialization_file_name_in_dir(), GNUNET_FS_SearchResult::mandatory_missing, GNUNET_FS_SearchResult::meta, GNUNET_FS_SearchResult::optional_support, GNUNET_FS_SearchContext::psearch_result, remove_sync_file_in_dir(), GNUNET_FS_SearchResult::sc, GNUNET_FS_SearchResult::serialization, GNUNET_FS_SearchContext::serialization, GNUNET_FS_DownloadContext::serialization, GNUNET_FS_Uri::type, GNUNET_FS_SearchResult::update_search, GNUNET_FS_SearchResult::uri, GNUNET_FS_SearchContext::uri, and wh.

Referenced by GNUNET_FS_download_start_task_(), GNUNET_FS_download_stop(), GNUNET_FS_search_probe_progress_(), probe_failure_handler(), probe_success_handler(), process_ksk_result(), and process_sks_result().

2049 {
2050  struct GNUNET_BIO_WriteHandle *wh;
2051  char *uris;
2052 
2053  if (NULL == sr->sc)
2054  return;
2055  uris = NULL;
2056  if (NULL == sr->serialization)
2057  sr->serialization =
2059  (sr->sc->psearch_result ==
2060  NULL) ?
2063  sr->sc->serialization);
2064  if (NULL == sr->serialization)
2065  return;
2066  wh = get_write_handle_in_dir (sr->h,
2067  (sr->sc->psearch_result ==
2070  sr->sc->serialization, sr->serialization);
2071  if (NULL == wh)
2072  {
2073  GNUNET_break (0);
2074  goto cleanup;
2075  }
2076  uris = GNUNET_FS_uri_to_string (sr->uri);
2077  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
2078  (GNUNET_OK !=
2080  sr->download !=
2081  NULL ? sr->download->serialization : NULL)) ||
2082  (GNUNET_OK !=
2084  sr->update_search !=
2085  NULL ? sr->update_search->serialization : NULL))
2086  || (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, sr->meta)) ||
2087  (GNUNET_OK != GNUNET_BIO_write (wh, &sr->key, sizeof (struct GNUNET_HashCode)))
2092  {
2093  GNUNET_break (0);
2094  goto cleanup;
2095  }
2096  if ( (NULL != sr->uri) &&
2097  (GNUNET_FS_URI_KSK == sr->sc->uri->type) &&
2099  (sr->sc->uri->data.ksk.keywordCount + 7) / 8)) )
2100  {
2101  GNUNET_break (0);
2102  goto cleanup;
2103  }
2104  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
2105  {
2106  wh = NULL;
2107  GNUNET_break (0);
2108  goto cleanup;
2109  }
2110  GNUNET_free_non_null (uris);
2111  return;
2112 cleanup:
2113  GNUNET_free_non_null (uris);
2114  if (NULL != wh)
2115  (void) GNUNET_BIO_write_close (wh);
2117  (NULL == sr->sc->psearch_result)
2120  sr->sc->serialization, sr->serialization);
2121  GNUNET_free (sr->serialization);
2122  sr->serialization = NULL;
2123 }
uint32_t optional_support
Number of optional keywords under which this result was also found.
Definition: fs_api.h:616
int GNUNET_BIO_write_meta_data(struct GNUNET_BIO_WriteHandle *h, const struct GNUNET_CONTAINER_MetaData *m)
Write metadata container to a file.
Definition: bio.c:569
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:560
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:1554
static char * make_serialization_file_name_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni)
Create a new random name for serialization.
Definition: fs_api.c:1224
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:547
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:533
uint8_t * keyword_bitmap
Bitmap that specifies precisely which keywords have been matched already.
Definition: fs_api.h:576
static void remove_sync_file_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni, const char *ent)
Remove serialization/deserialization file from disk.
Definition: fs_api.c:769
Keyword search key (query with keywords).
Definition: fs_api.h:156
struct GNUNET_FS_Uri * uri
URI to which this search result refers to.
Definition: fs_api.h:538
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_BIO_WriteHandle * get_write_handle_in_dir(struct GNUNET_FS_Handle *h, const char *ext, const char *uni, const char *ent)
Return a write handle for serialization.
Definition: fs_api.c:715
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
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:566
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:1988
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1569
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1842
uint32_t availability_trials
Number of availability trials that we have performed for this search result.
Definition: fs_api.h:627
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
struct GNUNET_FS_Uri::@16::@17 ksk
uint32_t availability_success
Number of availability tests that have succeeded for this result.
Definition: fs_api.h:621
union GNUNET_FS_Uri::@16 data
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
Handle for buffered writing.
Definition: bio.c:399
A 512-bit hashcode.
#define GNUNET_FS_SYNC_PATH_CHILD_SEARCH
Name of the directory with sub-searches (namespace-updates).
Definition: fs_api.h:59
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
struct GNUNET_CONTAINER_MetaData * meta
Metadata for the search result.
Definition: fs_api.h:543
enum GNUNET_FS_UriType type
Type of the URI.
Definition: fs_api.h:173
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:457
struct GNUNET_HashCode key
Key for the search result based on the URI.
Definition: fs_api.h:581
#define GNUNET_FS_SYNC_PATH_MASTER_SEARCH
Name of the directory with top-level searches.
Definition: fs_api.h:54
uint32_t mandatory_missing
Number of mandatory keywords for which we have NOT yet found the search result; when this value hits ...
Definition: fs_api.h:610
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:605
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:505
char * serialization
Name under which this search result is stored on disk.
Definition: fs_api.h:571
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_download_sync_()

void GNUNET_FS_download_sync_ ( struct GNUNET_FS_DownloadContext dc)

Synchronize this download struct with its mirror on disk.

Note that all internal FS-operations that change publishing structs should already call "sync" internally, so this function is likely not useful for clients.

Parameters
dcthe struct to sync

Definition at line 1944 of file fs_api.c.

References GNUNET_FS_DownloadContext::anonymity, cleanup(), GNUNET_FS_DownloadContext::completed, dir, GNUNET_FS_DownloadContext::emsg, GNUNET_FS_DownloadContext::filename, fn, get_download_sync_filename(), get_serialization_short_name(), GNUNET_assert, GNUNET_BIO_write_close(), GNUNET_BIO_write_int32(), GNUNET_BIO_write_int64(), GNUNET_BIO_write_meta_data(), GNUNET_BIO_write_open(), GNUNET_BIO_write_string(), GNUNET_break, GNUNET_DISK_directory_create_for_file(), GNUNET_DISK_mktemp(), GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_free_non_null, GNUNET_FS_DOWNLOAD_IS_PROBE, GNUNET_FS_uri_test_chk(), GNUNET_FS_uri_test_loc(), GNUNET_FS_uri_to_string(), GNUNET_log_strerror_file, GNUNET_OK, GNUNET_YES, GNUNET_FS_DownloadContext::has_finished, GNUNET_FS_DownloadContext::length, GNUNET_FS_DownloadContext::meta, GNUNET_FS_DownloadContext::offset, GNUNET_FS_DownloadContext::old_file_size, GNUNET_FS_DownloadContext::options, GNUNET_FS_DownloadContext::serialization, GNUNET_FS_DownloadContext::start_time, GNUNET_FS_DownloadContext::temp_filename, GNUNET_FS_DownloadContext::top_request, UNLINK, GNUNET_FS_DownloadContext::uri, wh, write_download_request(), and write_start_time().

Referenced by check_completed(), GNUNET_FS_download_start_task_(), process_result_with_request(), search_result_stop(), and try_match_block().

1945 {
1946  struct GNUNET_BIO_WriteHandle *wh;
1947  char *uris;
1948  char *fn;
1949  char *dir;
1950 
1951  if (0 != (dc->options & GNUNET_FS_DOWNLOAD_IS_PROBE))
1952  return; /* we don't sync probes */
1953  if (NULL == dc->serialization)
1954  {
1955  dir = get_download_sync_filename (dc, "", "");
1956  if (NULL == dir)
1957  return;
1959  {
1960  GNUNET_free (dir);
1961  return;
1962  }
1963  fn = GNUNET_DISK_mktemp (dir);
1964  GNUNET_free (dir);
1965  if (NULL == fn)
1966  return;
1968  }
1969  else
1970  {
1971  fn = get_download_sync_filename (dc, dc->serialization, "");
1972  if (NULL == fn)
1973  {
1974  GNUNET_free (dc->serialization);
1975  dc->serialization = NULL;
1976  GNUNET_free (fn);
1977  return;
1978  }
1979  }
1980  wh = GNUNET_BIO_write_open (fn);
1981  if (NULL == wh)
1982  {
1983  GNUNET_free (dc->serialization);
1984  dc->serialization = NULL;
1985  GNUNET_free (fn);
1986  return;
1987  }
1990  uris = GNUNET_FS_uri_to_string (dc->uri);
1991  if ((GNUNET_OK != GNUNET_BIO_write_string (wh, uris)) ||
1992  (GNUNET_OK != GNUNET_BIO_write_meta_data (wh, dc->meta)) ||
1993  (GNUNET_OK != GNUNET_BIO_write_string (wh, dc->emsg)) ||
1994  (GNUNET_OK != GNUNET_BIO_write_string (wh, dc->filename)) ||
1997  (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dc->offset)) ||
1998  (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dc->length)) ||
1999  (GNUNET_OK != GNUNET_BIO_write_int64 (wh, dc->completed)) ||
2000  (GNUNET_OK != write_start_time (wh, dc->start_time)) ||
2001  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, dc->anonymity)) ||
2002  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) dc->options)) ||
2003  (GNUNET_OK != GNUNET_BIO_write_int32 (wh, (uint32_t) dc->has_finished)))
2004  {
2005  GNUNET_break (0);
2006  goto cleanup;
2007  }
2008  if (NULL == dc->emsg)
2009  {
2010  GNUNET_assert (dc->top_request != NULL);
2012  {
2013  GNUNET_break (0);
2014  goto cleanup;
2015  }
2016  }
2017  GNUNET_free_non_null (uris);
2018  uris = NULL;
2019  if (GNUNET_OK != GNUNET_BIO_write_close (wh))
2020  {
2021  wh = NULL;
2022  GNUNET_break (0);
2023  goto cleanup;
2024  }
2025  GNUNET_free (fn);
2026  return;
2027 cleanup:
2028  if (NULL != wh)
2029  (void) GNUNET_BIO_write_close (wh);
2030  GNUNET_free_non_null (uris);
2031  if (0 != UNLINK (fn))
2033  GNUNET_free (fn);
2034  GNUNET_free (dc->serialization);
2035  dc->serialization = NULL;
2036 }
int GNUNET_BIO_write_meta_data(struct GNUNET_BIO_WriteHandle *h, const struct GNUNET_CONTAINER_MetaData *m)
Write metadata container to a file.
Definition: bio.c:569
static char * dir
Set to the directory where runtime files are stored.
Definition: gnunet-arm.c:84
enum GNUNET_FS_DownloadOptions options
Options for the download.
Definition: fs_api.h:1949
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:547
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
int GNUNET_BIO_write_int64(struct GNUNET_BIO_WriteHandle *h, int64_t i)
Write an (u)int64_t.
Definition: bio.c:623
struct DownloadRequest * top_request
Top-level download request.
Definition: fs_api.h:1882
int GNUNET_DISK_directory_create_for_file(const char *filename)
Create the directory structure for storing a file.
Definition: disk.c:833
char * filename
Where are we writing the data (name of the file, can be NULL!).
Definition: fs_api.h:1848
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:78
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
char * temp_filename
Where are we writing the data temporarily (name of the file, can be NULL!); used if we do not have a ...
Definition: fs_api.h:1855
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
uint64_t old_file_size
What was the size of the file on disk that we&#39;re downloading before we started? Used to detect if the...
Definition: fs_api.h:1924
#define UNLINK(f)
Definition: plibc.h:666
int GNUNET_FS_uri_test_loc(const struct GNUNET_FS_Uri *uri)
Is this a location URI?
Definition: fs_uri.c:1381
char * GNUNET_FS_uri_to_string(const struct GNUNET_FS_Uri *uri)
Convert a URI to a UTF-8 String.
Definition: fs_uri.c:1988
uint64_t length
How many bytes starting from offset are desired? This is NOT the overall length of the file! ...
Definition: fs_api.h:1910
char * GNUNET_DISK_mktemp(const char *t)
Create an (empty) temporary file on disk.
Definition: disk.c:593
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1842
#define GNUNET_log_strerror_file(level, cmd, filename)
Log an error message at log-level &#39;level&#39; that indicates a failure of the command &#39;cmd&#39; with the mess...
static char * fn
Filename of the unique file.
Internal option used to flag this download as a &#39;probe&#39; for a search result.
static void cleanup(void *cls)
Function scheduled as very last function, cleans up after us.
Handle for buffered writing.
Definition: bio.c:399
uint64_t offset
What is the first offset that we&#39;re interested in?
Definition: fs_api.h:1904
int GNUNET_FS_uri_test_chk(const struct GNUNET_FS_Uri *uri)
Is this a file (or directory) URI?
Definition: fs_uri.c:1345
char * emsg
Error message, NULL if we&#39;re doing OK.
Definition: fs_api.h:1836
int has_finished
Flag set upon transitive completion (includes child downloads).
Definition: fs_api.h:1956
static char * get_download_sync_filename(struct GNUNET_FS_DownloadContext *dc, const char *uni, const char *ext)
Compute the name of the sync file (or directory) for the given download context.
Definition: fs_api.c:1911
static int write_start_time(struct GNUNET_BIO_WriteHandle *wh, struct GNUNET_TIME_Absolute timestamp)
Serialize a start-time.
Definition: fs_api.c:830
static struct GNUNET_TESTBED_BarrierWaitHandle * wh
Our barrier wait handle.
static char * get_serialization_short_name(const char *fullname)
Given a serialization name (full absolute path), return the basename of the file (without the path)...
Definition: fs_api.c:1153
int GNUNET_BIO_write_close(struct GNUNET_BIO_WriteHandle *h)
Close an open file for writing.
Definition: bio.c:457
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open(const char *fn)
Open a file for writing.
Definition: bio.c:430
static int write_download_request(struct GNUNET_BIO_WriteHandle *wh, struct DownloadRequest *dr)
Serialize a download request.
Definition: fs_api.c:1818
uint32_t anonymity
Desired level of anonymity.
Definition: fs_api.h:1939
int GNUNET_BIO_write_int32(struct GNUNET_BIO_WriteHandle *h, int32_t i)
Write an (u)int32_t.
Definition: bio.c:605
struct GNUNET_CONTAINER_MetaData * meta
Known meta-data for the file (can be NULL).
Definition: fs_api.h:1831
#define GNUNET_YES
Definition: gnunet_common.h:80
struct GNUNET_TIME_Absolute start_time
Time download was started.
Definition: fs_api.h:1929
uint64_t completed
How many bytes have we already received within the specified range (DBlocks only).
Definition: fs_api.h:1916
struct GNUNET_FS_Uri * uri
URI that identifies the file that we are downloading.
Definition: fs_api.h:1826
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_publish_signal_suspend_()

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

Parameters
clsthe struct GNUNET_FS_PublishContext to signal for

Definition at line 1343 of file fs_publish.c.

References GNUNET_FS_PublishContext::fi, fip_signal_suspend(), GNUNET_FS_end_top(), GNUNET_FS_file_information_inspect(), GNUNET_SCHEDULER_cancel(), GNUNET_YES, GNUNET_FS_PublishContext::h, pc, publish_cleanup(), GNUNET_FS_PublishContext::skip_next_fi_callback, suspend_operation(), GNUNET_FS_PublishContext::top, and GNUNET_FS_PublishContext::upload_task.

Referenced by deserialize_publish_file(), and GNUNET_FS_publish_start().

1344 {
1345  struct GNUNET_FS_PublishContext *pc = cls;
1346 
1347  if (NULL != pc->upload_task)
1348  {
1350  pc->upload_task = NULL;
1351  }
1354  suspend_operation (pc->fi, pc);
1355  GNUNET_FS_end_top (pc->h, pc->top);
1356  pc->top = NULL;
1357  publish_cleanup (pc);
1358 }
struct GNUNET_SCHEDULER_Task * upload_task
ID of the task performing the upload.
Definition: fs_api.h:1278
struct GNUNET_FS_Handle * h
Handle to the global fs context.
Definition: fs_api.h:1203
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:416
static void publish_cleanup(struct GNUNET_FS_PublishContext *pc)
Cleanup the publish context, we&#39;re done with it.
Definition: fs_publish.c:77
Handle for controlling a publication process.
Definition: fs_api.h:1198
static void suspend_operation(struct GNUNET_FS_FileInformation *fi, struct GNUNET_FS_PublishContext *pc)
Actually signal the FS&#39;s progress function that we are suspending an upload.
Definition: fs_publish.c:1256
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1208
static struct GNUNET_FS_PublishContext * pc
Handle to FS-publishing operation.
struct GNUNET_FS_FileInformation * fi
File-structure that is being shared.
Definition: fs_api.h:1213
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_YES
Definition: gnunet_common.h:80
static int fip_signal_suspend(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&#39;s progress function that we are suspending an upload.
Definition: fs_publish.c:1308
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:1318
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_search_signal_suspend_()

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

Parameters
clsthe 'struct GNUNET_FS_SearchContext' to signal for
clsthe struct GNUNET_FS_SearchContext to signal for

Definition at line 1546 of file fs_search.c.

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_free_non_null, GNUNET_FS_end_top(), GNUNET_FS_search_make_status_(), GNUNET_FS_STATUS_SEARCH_SUSPEND, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_test_ksk(), GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_FS_SearchContext::h, SearchRequestEntry::keyword, GNUNET_FS_Uri::ksk, GNUNET_FS_SearchContext::master_result_map, GNUNET_FS_SearchContext::mq, GNUNET_FS_SearchContext::requests, SearchRequestEntry::results, search_result_suspend(), GNUNET_FS_SearchContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_SearchContext::task, GNUNET_FS_SearchContext::top, and GNUNET_FS_SearchContext::uri.

Referenced by deserialize_search_file(), GNUNET_FS_search_start(), and search_result_suspend().

1547 {
1548  struct GNUNET_FS_SearchContext *sc = cls;
1549  struct GNUNET_FS_ProgressInfo pi;
1550  unsigned int i;
1551 
1552  GNUNET_FS_end_top (sc->h, sc->top);
1554  &search_result_suspend, sc);
1556  sc->client_info = GNUNET_FS_search_make_status_ (&pi, sc->h, sc);
1557  GNUNET_break (NULL == sc->client_info);
1558  if (sc->task != NULL)
1559  {
1561  sc->task = NULL;
1562  }
1563  if (NULL != sc->mq)
1564  {
1565  GNUNET_MQ_destroy (sc->mq);
1566  sc->mq = NULL;
1567  }
1569  if (NULL != sc->requests)
1570  {
1572  for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
1573  {
1575  GNUNET_free (sc->requests[i].keyword);
1576  }
1577  }
1579  GNUNET_free_non_null (sc->emsg);
1580  GNUNET_FS_uri_destroy (sc->uri);
1582  GNUNET_free (sc);
1583 }
int GNUNET_FS_uri_test_ksk(const struct GNUNET_FS_Uri *uri)
Is this a keyword URI?
Definition: fs_uri.c:1323
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:1606
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1543
char * emsg
Error message (non-NULL if this operation failed).
Definition: fs_api.h:1574
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct SearchRequestEntry * requests
Per-keyword information for a keyword search.
Definition: fs_api.h:1588
struct GNUNET_FS_Uri * uri
List of keywords that we&#39;re looking for.
Definition: fs_api.h:1548
char * serialization
Name of the file on disk we use for persistence.
Definition: fs_api.h:1569
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:1582
struct GNUNET_FS_Uri::@16::@17 ksk
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:416
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
union GNUNET_FS_Uri::@16 data
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:1519
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
Last event when a search is being suspended; note that "GNUNET_FS_SEARCH_STOPPED" will not be generat...
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
Handle for controlling a search.
Definition: fs_api.h:1533
static int search_result_suspend(void *cls, const struct GNUNET_HashCode *key, void *value)
Signal suspend and free the given search result.
Definition: fs_search.c:1501
struct GNUNET_MQ_Handle * mq
Connection to the FS service.
Definition: fs_api.h:1559
struct GNUNET_FS_Handle * h
Handle to the global FS context.
Definition: fs_api.h:1538
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
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
int GNUNET_CONTAINER_multihashmap_iterate(struct GNUNET_CONTAINER_MultiHashMap *map, GNUNET_CONTAINER_MulitHashMapIteratorCallback it, void *it_cls)
Iterate over all entries in the map.
void * client_info
Pointer we keep for the client.
Definition: fs_api.h:1564
char * keyword
The original keyword, used to derive the key (for decrypting the UBlock).
Definition: fs_api.h:1509
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_download_signal_suspend_()

void GNUNET_FS_download_signal_suspend_ ( void *  cls)

Create SUSPEND event for the given download operation and then clean up our state (without stop signal).

Parameters
clsthe struct GNUNET_FS_DownloadContext to signal for
clsthe 'struct GNUNET_FS_DownloadContext' to signal for

Definition at line 1953 of file fs_download.c.

References GNUNET_FS_DownloadContext::active, GNUNET_FS_DownloadContext::child_head, GNUNET_FS_DownloadContext::child_tail, GNUNET_FS_SearchResult::download, GNUNET_FS_DownloadContext::filename, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_meta_data_destroy(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_DISK_file_close(), GNUNET_free, GNUNET_free_non_null, GNUNET_FS_dequeue_(), GNUNET_FS_download_make_status_(), GNUNET_FS_end_top(), GNUNET_FS_free_download_request_(), GNUNET_FS_STATUS_DOWNLOAD_SUSPEND, GNUNET_FS_tree_encoder_finish(), GNUNET_FS_uri_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_FS_DownloadContext::h, GNUNET_FS_DownloadContext::job_queue, GNUNET_FS_DownloadContext::meta, GNUNET_FS_DownloadContext::parent, GNUNET_FS_DownloadContext::rfh, GNUNET_FS_DownloadContext::search, GNUNET_FS_DownloadContext::serialization, GNUNET_FS_ProgressInfo::status, GNUNET_FS_DownloadContext::task, GNUNET_FS_DownloadContext::te, GNUNET_FS_DownloadContext::temp_filename, GNUNET_FS_DownloadContext::top, GNUNET_FS_DownloadContext::top_request, and GNUNET_FS_DownloadContext::uri.

Referenced by deserialize_download(), GNUNET_FS_download_start(), search_result_stop(), and search_result_suspend().

1954 {
1955  struct GNUNET_FS_DownloadContext *dc = cls;
1956  struct GNUNET_FS_ProgressInfo pi;
1957 
1958  if (NULL != dc->top)
1959  GNUNET_FS_end_top (dc->h, dc->top);
1960  while (NULL != dc->child_head)
1962  if (NULL != dc->search)
1963  {
1964  dc->search->download = NULL;
1965  dc->search = NULL;
1966  }
1967  if (NULL != dc->job_queue)
1968  {
1970  dc->job_queue = NULL;
1971  }
1972  if (NULL != dc->parent)
1974  dc);
1975  if (NULL != dc->task)
1976  {
1978  dc->task = NULL;
1979  }
1982  if (NULL != dc->te)
1983  {
1984  GNUNET_FS_tree_encoder_finish (dc->te, NULL);
1985  dc->te = NULL;
1986  }
1987  if (NULL != dc->rfh)
1988  {
1990  dc->rfh = NULL;
1991  }
1993  if (NULL != dc->active)
1994  {
1996  dc->active = NULL;
1997  }
2000  GNUNET_FS_uri_destroy (dc->uri);
2003  GNUNET_assert (NULL == dc->job_queue);
2004  GNUNET_free (dc);
2005 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Context for controlling a download.
Definition: fs_api.h:1768
struct GNUNET_FS_DownloadContext * download
ID of an associated download based on this search result (or NULL for none).
Definition: fs_api.h:560
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1817
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1774
Notification that this download was suspended.
void GNUNET_FS_download_make_status_(struct GNUNET_FS_ProgressInfo *pi, struct GNUNET_FS_DownloadContext *dc)
Fill in all of the generic fields for a download event and call the callback.
Definition: fs_download.c:106
struct GNUNET_FS_DownloadContext * child_head
Head of list of child downloads.
Definition: fs_api.h:1801
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct DownloadRequest * top_request
Top-level download request.
Definition: fs_api.h:1882
struct GNUNET_FS_DownloadContext * parent
Parent download (used when downloading files in directories).
Definition: fs_api.h:1790
char * filename
Where are we writing the data (name of the file, can be NULL!).
Definition: fs_api.h:1848
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
char * temp_filename
Where are we writing the data temporarily (name of the file, can be NULL!); used if we do not have a ...
Definition: fs_api.h:1855
void GNUNET_FS_dequeue_(struct GNUNET_FS_QueueEntry *qe)
Dequeue a job from the queue.
Definition: fs_api.c:363
char * serialization
Random portion of filename we use for syncing state of this download.
Definition: fs_api.h:1842
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:416
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
void GNUNET_CONTAINER_meta_data_destroy(struct GNUNET_CONTAINER_MetaData *md)
Free meta data.
struct GNUNET_CONTAINER_MultiHashMap * active
Map of active requests (those waiting for a response).
Definition: fs_api.h:1877
struct GNUNET_FS_TreeEncoder * te
Tree encoder used for the reconstruction.
Definition: fs_api.h:1865
struct TopLevelActivity * top
Our top-level activity entry (if we are top-level, otherwise NULL).
Definition: fs_api.h:1779
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
struct GNUNET_SCHEDULER_Task * task
ID of a task that is using this struct and that must be cancelled when the download is being stopped ...
Definition: fs_api.h:1898
struct GNUNET_DISK_FileHandle * rfh
File handle for reading data from an existing file (to pass to tree encoder).
Definition: fs_api.h:1871
struct GNUNET_FS_SearchResult * search
Associated search (used when downloading files based on search results), or NULL for none...
Definition: fs_api.h:1796
void GNUNET_FS_free_download_request_(struct DownloadRequest *dr)
(recursively) free download request structure
Definition: fs_download.c:992
struct GNUNET_FS_DownloadContext * child_tail
Tail of list of child downloads.
Definition: fs_api.h:1806
struct GNUNET_CONTAINER_MetaData * meta
Known meta-data for the file (can be NULL).
Definition: fs_api.h:1831
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:1953
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:444
struct GNUNET_FS_Uri * uri
URI that identifies the file that we are downloading.
Definition: fs_api.h:1826
static struct GNUNET_FS_DownloadContext * dc
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
struct GNUNET_FS_QueueEntry * job_queue
Our entry in the job queue.
Definition: fs_api.h:1860
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_unindex_signal_suspend_()

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

Parameters
clsthe struct GNUNET_FS_UnindexContext to signal for

Definition at line 723 of file fs_unindex.c.

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

Referenced by deserialize_unindex_file(), and GNUNET_FS_unindex_start().

724 {
725  struct GNUNET_FS_UnindexContext *uc = cls;
726  struct GNUNET_FS_ProgressInfo pi;
727 
728  /* FIXME: lots of duplication with unindex_stop here! */
729  if (uc->dscan != NULL)
730  {
732  uc->dscan = NULL;
733  }
734  if (NULL != uc->dqe)
735  {
737  uc->dqe = NULL;
738  }
739  if (uc->fhc != NULL)
740  {
742  uc->fhc = NULL;
743  }
744  if (NULL != uc->ksk_uri)
745  {
747  uc->ksk_uri = NULL;
748  }
749  if (NULL != uc->mq)
750  {
751  GNUNET_MQ_destroy (uc->mq);
752  uc->mq = NULL;
753  }
754  if (NULL != uc->dsh)
755  {
757  uc->dsh = NULL;
758  }
759  if (NULL != uc->tc)
760  {
761  GNUNET_FS_tree_encoder_finish (uc->tc, NULL);
762  uc->tc = NULL;
763  }
764  if (uc->fh != NULL)
765  {
767  uc->fh = NULL;
768  }
769  GNUNET_FS_end_top (uc->h, uc->top);
772  (uc->state ==
773  UNINDEX_STATE_COMPLETE) ? uc->file_size : 0);
774  GNUNET_break (NULL == uc->client_info);
775  GNUNET_free (uc->filename);
778  GNUNET_free (uc);
779 }
char * serialization
Short name under which we are serializing the state of this operation.
Definition: fs_api.h:1411
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1817
struct GNUNET_FS_TreeEncoder * tc
Merkle-ish tree encoder context.
Definition: fs_api.h:1433
We&#39;re done.
Definition: fs_api.h:1357
static struct GNUNET_FS_UnindexContext * uc
#define GNUNET_NO
Definition: gnunet_common.h:81
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
Notification that we suspended unindexing a file.
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1484
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
Handle for controlling an unindexing operation.
Definition: fs_api.h:1369
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service, only valid during the UNINDEX_STATE_DS_NOTIFY phase...
Definition: fs_api.h:1423
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
Definition: fs_api.h:1464
struct TopLevelActivity * top
Our top-level activity entry.
Definition: fs_api.h:1386
struct GNUNET_DISK_FileHandle * fh
Handle used to read the file.
Definition: fs_api.h:1438
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:416
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
void GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
Abort the scan.
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:670
struct GNUNET_FS_Uri * ksk_uri
Keywords found (telling us which KBlocks to remove).
Definition: fs_api.h:1396
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1406
struct GNUNET_DATASTORE_QueueEntry * dqe
Handle to datastore &#39;get_key&#39; operation issued for obtaining KBlocks.
Definition: fs_api.h:1444
struct GNUNET_MQ_Handle * mq
Connection to the FS service, only valid during the UNINDEX_STATE_FS_NOTIFY phase.
Definition: fs_api.h:1417
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_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
struct GNUNET_FS_DirScanner * dscan
Directory scanner to find keywords (KBlock removal).
Definition: fs_api.h:1391
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1459
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:444
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:824
void * client_info
Pointer kept for the client.
Definition: fs_api.h:1428
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1381
#define GNUNET_free(ptr)
Wrapper around free.
Argument given to the progress callback with information about what is going on.
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1469
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_make_top()

struct TopLevelActivity* GNUNET_FS_make_top ( struct GNUNET_FS_Handle h,
SuspendSignalFunction  ssf,
void *  ssf_cls 
)

Create a top-level activity entry.

Parameters
hglobal fs handle
ssfsuspend signal function to use
ssf_clsclosure for ssf
Returns
fresh top-level activity handle

Definition at line 393 of file fs_api.c.

References GNUNET_CONTAINER_DLL_insert, GNUNET_new, ret, TopLevelActivity::ssf, TopLevelActivity::ssf_cls, GNUNET_FS_Handle::top_head, and GNUNET_FS_Handle::top_tail.

Referenced by deserialize_download(), deserialize_publish_file(), deserialize_search_file(), deserialize_unindex_file(), GNUNET_FS_download_start(), GNUNET_FS_publish_start(), GNUNET_FS_search_start(), GNUNET_FS_unindex_start(), and search_result_stop().

396 {
397  struct TopLevelActivity *ret;
398 
399  ret = GNUNET_new (struct TopLevelActivity);
400  ret->ssf = ssf;
401  ret->ssf_cls = ssf_cls;
403  h->top_tail,
404  ret);
405  return ret;
406 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static int ret
Final status code.
Definition: gnunet-arm.c:89
struct TopLevelActivity * top_tail
Tail of DLL of top-level activities.
Definition: fs_api.h:1117
struct TopLevelActivity * top_head
Head of DLL of top-level activities.
Definition: fs_api.h:1112
void * ssf_cls
Closure for &#39;ssf&#39; (some struct GNUNET_FS_XXXHandle*)
Definition: fs_api.h:1054
We track all of the top-level activities of FS so that we can signal &#39;suspend&#39; on shutdown...
Definition: fs_api.h:1034
SuspendSignalFunction ssf
Function to call for suspend-signalling and clean up.
Definition: fs_api.h:1049
Here is the caller graph for this function:

◆ GNUNET_FS_end_top()

void GNUNET_FS_end_top ( struct GNUNET_FS_Handle h,
struct TopLevelActivity top 
)

Destroy a top-level activity entry.

Parameters
hglobal fs handle
toptop level activity entry

Definition at line 416 of file fs_api.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_FS_Handle::top_head, and GNUNET_FS_Handle::top_tail.

Referenced by GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_stop(), GNUNET_FS_publish_signal_suspend_(), GNUNET_FS_publish_stop(), GNUNET_FS_search_signal_suspend_(), GNUNET_FS_search_stop(), GNUNET_FS_unindex_signal_suspend_(), and GNUNET_FS_unindex_stop().

418 {
420  h->top_tail,
421  top);
422  GNUNET_free (top);
423 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct TopLevelActivity * top_tail
Tail of DLL of top-level activities.
Definition: fs_api.h:1117
struct TopLevelActivity * top_head
Head of DLL of top-level activities.
Definition: fs_api.h:1112
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ GNUNET_FS_free_download_request_()

void GNUNET_FS_free_download_request_ ( struct DownloadRequest dr)

(recursively) free download request structure

Parameters
drrequest to free

Definition at line 992 of file fs_download.c.

References DownloadRequest::children, GNUNET_free, GNUNET_free_non_null, and DownloadRequest::num_children.

Referenced by free_download_context(), GNUNET_FS_download_signal_suspend_(), GNUNET_FS_download_stop(), process_result_with_request(), and read_download_request().

993 {
994  if (NULL == dr)
995  return;
996  for (unsigned int i = 0; i < dr->num_children; i++)
999  GNUNET_free (dr);
1000 }
struct DownloadRequest ** children
Array (!) of child-requests, or NULL for the bottom of the tree.
Definition: fs_api.h:1709
#define GNUNET_free_non_null(ptr)
Free the memory pointed to by ptr if ptr is not NULL.
unsigned int num_children
Number of entries in children array.
Definition: fs_api.h:1727
void GNUNET_FS_free_download_request_(struct DownloadRequest *dr)
(recursively) free download request structure
Definition: fs_download.c:992
#define GNUNET_free(ptr)
Wrapper around free.
Here is the caller graph for this function:

◆ GNUNET_FS_stop_probe_ping_task_()

void GNUNET_FS_stop_probe_ping_task_ ( struct GNUNET_FS_SearchResult sr)

Stop the ping task for this search result.

Parameters
srresult to start pinging for.

Definition at line 406 of file fs_search.c.

References GNUNET_CONTAINER_DLL_remove, GNUNET_SCHEDULER_cancel(), h, GNUNET_FS_SearchResult::h, GNUNET_FS_Handle::probe_ping_task, GNUNET_FS_Handle::probes_head, and GNUNET_FS_Handle::probes_tail.

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

407 {
408  struct GNUNET_FS_Handle *h = sr->h;
409 
411  h->probes_tail,
412  sr);
413  if (NULL == h->probes_head)
414  {
416  h->probe_ping_task = NULL;
417  }
418 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Master context for most FS operations.
Definition: fs_api.h:1087
static struct GNUNET_ARM_Handle * h
Connection with ARM.
Definition: gnunet-arm.c:94
struct GNUNET_FS_Handle * h
File-sharing context this result belongs to.
Definition: fs_api.h:517
struct GNUNET_SCHEDULER_Task * probe_ping_task
Task we use to report periodically to the application that certain search probes (from probes_head) a...
Definition: fs_api.h:1159
struct GNUNET_FS_SearchResult * probes_head
Head of active probes.
Definition: fs_api.h:1142
struct GNUNET_FS_SearchResult * probes_tail
Tail of active probes.
Definition: fs_api.h:1147
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:965
Here is the call graph for this function:
Here is the caller graph for this function: