GNUnet  0.19.2
fs_unindex.c File Reference

Unindex file. More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_fs_service.h"
#include "gnunet_protocols.h"
#include "fs_api.h"
#include "fs_tree.h"
#include "block_fs.h"
#include "fs_publish_ublock.h"
Include dependency graph for fs_unindex.c:

Go to the source code of this file.

Functions

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 tree). 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...
 
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. More...
 
static void signal_unindex_error (struct GNUNET_FS_UnindexContext *uc)
 We've encountered an error during unindexing. More...
 
static void process_cont (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
 Continuation called to notify client about result of the datastore removal operation. More...
 
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. More...
 
static void handle_unindex_response (void *cls, const struct GNUNET_MessageHeader *msg)
 Function called with the response from the FS service to our unindexing request. More...
 
static void unindex_mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
 Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
 
static void unindex_finish (struct GNUNET_FS_UnindexContext *uc)
 Function called when we are done with removing UBlocks. More...
 
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. More...
 
void GNUNET_FS_unindex_do_extract_keywords_ (struct GNUNET_FS_UnindexContext *uc)
 If necessary, connect to the datastore and remove the UBlocks. More...
 
static void continue_after_remove (void *cls, int32_t success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
 Continuation called to notify client about result of the remove operation for the UBlock. More...
 
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. More...
 
void GNUNET_FS_unindex_do_remove_kblocks_ (struct GNUNET_FS_UnindexContext *uc)
 If necessary, connect to the datastore and remove the KBlocks. More...
 
static void unindex_extract_keywords (void *cls)
 Function called when the tree encoder has processed all blocks. More...
 
void GNUNET_FS_unindex_do_remove_ (struct GNUNET_FS_UnindexContext *uc)
 Connect to the datastore and remove the blocks. 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_signal_suspend_ (void *cls)
 Create SUSPEND event for the given unindex operation and then clean up our state (without stop signal). More...
 
struct GNUNET_FS_UnindexContextGNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h, const char *filename, void *cctx)
 Unindex a file. More...
 
void GNUNET_FS_unindex_stop (struct GNUNET_FS_UnindexContext *uc)
 Clean up after completion of an unindex operation. More...
 

Detailed Description

Unindex file.

Author
Krista Grothoff
Christian Grothoff

Definition in file fs_unindex.c.

Function Documentation

◆ unindex_reader()

static size_t unindex_reader ( void *  cls,
uint64_t  offset,
size_t  max,
void *  buf,
char **  emsg 
)
static

Function called by the tree encoder to obtain a block of plaintext data (for the lowest level of the tree).

Parameters
clsour publishing context
offsetidentifies which block to get
max(maximum) number of bytes to get; returning fewer will also cause errors
bufwhere to copy the plaintext buffer
emsglocation to store an error message (on error)
Returns
number of bytes copied to buf, 0 on error

Definition at line 52 of file fs_unindex.c.

57 {
58  struct GNUNET_FS_UnindexContext *uc = cls;
59  size_t pt_size;
60 
61  pt_size = GNUNET_MIN (max, uc->file_size - offset);
62  if (offset != GNUNET_DISK_file_seek (uc->fh, offset, GNUNET_DISK_SEEK_SET))
63  {
64  *emsg = GNUNET_strdup (_ ("Failed to find given position in file"));
65  return 0;
66  }
67  if (pt_size != GNUNET_DISK_file_read (uc->fh, buf, pt_size))
68  {
69  *emsg = GNUNET_strdup (_ ("Failed to read file"));
70  return 0;
71  }
72  return pt_size;
73 }
static char buf[2048]
static struct GNUNET_FS_UnindexContext * uc
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:205
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:621
@ GNUNET_DISK_SEEK_SET
Seek an absolute position (from the start of the file).
#define GNUNET_MIN(a, b)
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define max(x, y)
#define _(String)
GNU gettext support macro.
Definition: platform.h:177
Handle for controlling an unindexing operation.
Definition: fs_api.h:1351
char * emsg
Error message, NULL on success.
Definition: fs_api.h:1439
struct GNUNET_DISK_FileHandle * fh
Handle used to read the file.
Definition: fs_api.h:1418
uint64_t file_size
Overall size of the file.
Definition: fs_api.h:1449

References _, buf, GNUNET_FS_UnindexContext::emsg, GNUNET_FS_UnindexContext::fh, GNUNET_FS_UnindexContext::file_size, GNUNET_DISK_file_read(), GNUNET_DISK_file_seek(), GNUNET_DISK_SEEK_SET, GNUNET_MIN, GNUNET_strdup, max, and uc.

Referenced by GNUNET_FS_unindex_do_remove_().

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

88 {
89  pi->value.unindex.uc = uc;
90  pi->value.unindex.cctx = uc->client_info;
91  pi->value.unindex.filename = uc->filename;
92  pi->value.unindex.size = uc->file_size;
93  pi->value.unindex.eta =
95  pi->value.unindex.duration =
97  pi->value.unindex.completed = offset;
98  pi->fsh = uc->h;
99  uc->client_info = uc->h->upcb (uc->h->upcb_cls, pi);
100 }
static struct GNUNET_PEERINFO_Handle * pi
Handle to peerinfo service.
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:436
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:564
void * upcb_cls
Closure for upcb.
Definition: fs_api.h:1089
GNUNET_FS_ProgressCallback upcb
Function to call with updates on our progress.
Definition: fs_api.h:1084
void * client_info
Pointer kept for the client.
Definition: fs_api.h:1408
struct GNUNET_TIME_Absolute start_time
When did we start?
Definition: fs_api.h:1454
char * filename
Name of the file that we are unindexing.
Definition: fs_api.h:1386
struct GNUNET_FS_Handle * h
Global FS context.
Definition: fs_api.h:1361

References GNUNET_FS_UnindexContext::client_info, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_calculate_eta(), GNUNET_FS_UnindexContext::h, pi, GNUNET_FS_UnindexContext::start_time, uc, GNUNET_FS_Handle::upcb, and GNUNET_FS_Handle::upcb_cls.

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

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

◆ unindex_progress()

static void unindex_progress ( void *  cls,
uint64_t  offset,
const void *  pt_block,
size_t  pt_size,
unsigned int  depth 
)
static

Function called with information about our progress in computing the tree encoding.

Parameters
clsclosure
offsetwhere are we in the file
pt_blockplaintext of the currently processed block
pt_sizesize of pt_block
depthdepth of the block in the tree, 0 for DBLOCK

Definition at line 114 of file fs_unindex.c.

119 {
120  struct GNUNET_FS_UnindexContext *uc = cls;
121  struct GNUNET_FS_ProgressInfo pi;
122 
124  pi.value.unindex.specifics.progress.data = pt_block;
125  pi.value.unindex.specifics.progress.offset = offset;
126  pi.value.unindex.specifics.progress.data_len = pt_size;
127  pi.value.unindex.specifics.progress.depth = depth;
129 }
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:85
@ GNUNET_FS_STATUS_UNINDEX_PROGRESS
Notification that we made progress unindexing a file.
Argument given to the progress callback with information about what is going on.
unsigned int depth
Depth of the given block in the tree; 0 would be the lowest level (DBLOCKs).
uint64_t offset
At what offset in the file is "data"?

References GNUNET_FS_ProgressInfo::depth, GNUNET_FS_STATUS_UNINDEX_PROGRESS, GNUNET_FS_unindex_make_status_(), GNUNET_FS_ProgressInfo::offset, pi, and uc.

Referenced by GNUNET_FS_unindex_do_remove_(), and unindex_finish().

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

◆ signal_unindex_error()

static void signal_unindex_error ( struct GNUNET_FS_UnindexContext uc)
static

We've encountered an error during unindexing.

Signal the client.

Parameters
uccontext for the failed unindexing operation

Definition at line 139 of file fs_unindex.c.

140 {
141  struct GNUNET_FS_ProgressInfo pi;
142 
144  pi.value.unindex.eta = GNUNET_TIME_UNIT_FOREVER_REL;
145  pi.value.unindex.specifics.error.message = uc->emsg;
147 }
@ GNUNET_FS_STATUS_UNINDEX_ERROR
Notification that we encountered an error unindexing a file.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".

References GNUNET_FS_UnindexContext::emsg, GNUNET_FS_STATUS_UNINDEX_ERROR, GNUNET_FS_unindex_make_status_(), GNUNET_TIME_UNIT_FOREVER_REL, pi, and uc.

Referenced by GNUNET_FS_unindex_do_remove_(), GNUNET_FS_unindex_do_remove_kblocks_(), GNUNET_FS_unindex_process_hash_(), process_cont(), unindex_finish(), and unindex_mq_error_handler().

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

◆ process_cont()

static void process_cont ( void *  cls,
int  success,
struct GNUNET_TIME_Absolute  min_expiration,
const char *  msg 
)
static

Continuation called to notify client about result of the datastore removal operation.

Parameters
clsclosure
successGNUNET_SYSERR on failure
min_expirationminimum expiration time required for content to be stored
msgNULL on success, otherwise an error message

Definition at line 160 of file fs_unindex.c.

164 {
165  struct GNUNET_FS_UnindexContext *uc = cls;
166 
167  if (success == GNUNET_SYSERR)
168  {
169  uc->emsg = GNUNET_strdup (msg);
171  return;
172  }
174  "Datastore REMOVE operation succeeded\n");
176 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
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:320
static void signal_unindex_error(struct GNUNET_FS_UnindexContext *uc)
We've encountered an error during unindexing.
Definition: fs_unindex.c:139
#define GNUNET_log(kind,...)
@ GNUNET_SYSERR
@ GNUNET_ERROR_TYPE_DEBUG
struct GNUNET_FS_TreeEncoder * tc
Merkle-ish tree encoder context.
Definition: fs_api.h:1413

References GNUNET_FS_UnindexContext::emsg, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_tree_encoder_next(), GNUNET_log, GNUNET_strdup, GNUNET_SYSERR, msg, signal_unindex_error(), GNUNET_FS_UnindexContext::tc, and uc.

Referenced by unindex_process().

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

◆ unindex_process()

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

Function called asking for the current (encoded) block to be processed.

After processing the client should either call "GNUNET_FS_tree_encode_next" or (on error) "GNUNET_FS_tree_encode_finish".

Parameters
clsclosure
chkcontent hash key for the block (key for lookup in the datastore)
offsetoffset of the block
depthdepth of the block, 0 for DBLOCK
typetype of the block (IBLOCK or DBLOCK)
blockthe (encrypted) block
block_sizesize of block (in bytes)

Definition at line 194 of file fs_unindex.c.

201 {
202  struct GNUNET_FS_UnindexContext *uc = cls;
203  uint32_t size;
204  const void *data;
205  struct OnDemandBlock odb;
206 
208  {
209  size = block_size;
210  data = block;
211  }
212  else /* on-demand encoded DBLOCK */
213  {
214  size = sizeof(struct OnDemandBlock);
215  odb.offset = GNUNET_htonll (offset);
216  odb.file_id = uc->file_id;
217  data = &odb;
218  }
220  "Sending REMOVE request to DATASTORE service\n");
221  GNUNET_DATASTORE_remove (uc->dsh, &chk->query, size, data, -2, 1,
222  &process_cont, uc);
223  uc->chk = *chk;
224 }
@ GNUNET_BLOCK_TYPE_FS_DBLOCK
Data block (leaf) in the CHK tree.
static void process_cont(void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Continuation called to notify client about result of the datastore removal operation.
Definition: fs_unindex.c:160
uint32_t data
The data value.
struct GNUNET_DATASTORE_QueueEntry * GNUNET_DATASTORE_remove(struct GNUNET_DATASTORE_Handle *h, const struct GNUNET_HashCode *key, size_t size, const void *data, unsigned int queue_priority, unsigned int max_queue_size, GNUNET_DATASTORE_ContinuationWithStatus cont, void *cont_cls)
Explicitly remove some content from the database.
uint64_t GNUNET_htonll(uint64_t n)
Convert unsigned 64-bit integer to network byte order.
Definition: common_endian.c:37
static unsigned int size
Size of the "table".
Definition: peer.c:68
struct GNUNET_HashCode query
Hash of the encrypted content, used for querying.
Definition: fs.h:64
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:1356
struct GNUNET_DATASTORE_Handle * dsh
Connection to the datastore service, only valid during the UNINDEX_STATE_DS_NOTIFY phase.
Definition: fs_api.h:1403
struct GNUNET_HashCode file_id
Hash of the file's contents (once computed).
Definition: fs_api.h:1459
index block (indexing a DBlock that can be obtained directly from reading the plaintext file)
Definition: block_fs.h:86
uint64_t offset
At which offset should we be able to find this on-demand encoded block? (in NBO)
Definition: block_fs.h:98
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

References GNUNET_FS_UnindexContext::chk, data, GNUNET_FS_UnindexContext::dsh, GNUNET_FS_UnindexContext::file_id, OnDemandBlock::file_id, GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_DATASTORE_remove(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_log, OnDemandBlock::offset, process_cont(), ContentHashKey::query, size, type, and uc.

Referenced by GNUNET_FS_unindex_do_remove_().

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

◆ handle_unindex_response()

static void handle_unindex_response ( void *  cls,
const struct GNUNET_MessageHeader msg 
)
static

Function called with the response from the FS service to our unindexing request.

Parameters
clsclosure, unindex context
msgthe response

Definition at line 235 of file fs_unindex.c.

237 {
238  struct GNUNET_FS_UnindexContext *uc = cls;
239  struct GNUNET_FS_ProgressInfo pi;
240 
241  if (NULL != uc->mq)
242  {
244  uc->mq = NULL;
245  }
248  pi.value.unindex.eta = GNUNET_TIME_UNIT_ZERO;
251  uc,
252  uc->file_size);
253 }
void GNUNET_FS_unindex_sync_(struct GNUNET_FS_UnindexContext *uc)
Synchronize this unindex struct with its mirror on disk.
Definition: fs_api.c:1823
@ UNINDEX_STATE_COMPLETE
We're done.
Definition: fs_api.h:1338
@ GNUNET_FS_STATUS_UNINDEX_COMPLETED
Notification that the unindexing of this file was completed.
void GNUNET_MQ_destroy(struct GNUNET_MQ_Handle *mq)
Destroy the message queue.
Definition: mq.c:683
#define GNUNET_TIME_UNIT_ZERO
Relative time zero.
enum UnindexState state
Current operatinonal phase.
Definition: fs_api.h:1464
struct GNUNET_MQ_Handle * mq
Connection to the FS service, only valid during the UNINDEX_STATE_FS_NOTIFY phase.
Definition: fs_api.h:1397

References GNUNET_FS_UnindexContext::file_size, GNUNET_FS_STATUS_UNINDEX_COMPLETED, GNUNET_FS_unindex_make_status_(), GNUNET_FS_unindex_sync_(), GNUNET_MQ_destroy(), GNUNET_TIME_UNIT_ZERO, GNUNET_FS_UnindexContext::mq, pi, GNUNET_FS_UnindexContext::state, uc, and UNINDEX_STATE_COMPLETE.

Here is the call graph for this function:

◆ unindex_mq_error_handler()

static void unindex_mq_error_handler ( void *  cls,
enum GNUNET_MQ_Error  error 
)
static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters
clsclosure with the struct GNUNET_FS_UnindexContext *
errorerror code

Definition at line 265 of file fs_unindex.c.

267 {
268  struct GNUNET_FS_UnindexContext *uc = cls;
269 
270  if (NULL != uc->mq)
271  {
273  uc->mq = NULL;
274  }
276  uc->emsg = GNUNET_strdup (_ ("Error communicating with `fs' service."));
279 }
@ UNINDEX_STATE_ERROR
We've encountered a fatal error.
Definition: fs_api.h:1343

References _, GNUNET_FS_UnindexContext::emsg, GNUNET_FS_unindex_sync_(), GNUNET_MQ_destroy(), GNUNET_strdup, GNUNET_FS_UnindexContext::mq, signal_unindex_error(), GNUNET_FS_UnindexContext::state, uc, and UNINDEX_STATE_ERROR.

Referenced by unindex_finish().

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

◆ unindex_finish()

static void unindex_finish ( struct GNUNET_FS_UnindexContext uc)
static

Function called when we are done with removing UBlocks.

Disconnect from datastore and notify FS service about the unindex event.

Parameters
ucour unindexing context

Definition at line 290 of file fs_unindex.c.

291 {
293  GNUNET_MQ_hd_fixed_size (unindex_response,
295  struct GNUNET_MessageHeader,
296  uc),
298  };
299  char *emsg;
300  struct GNUNET_MQ_Envelope *env;
301  struct UnindexMessage *req;
302 
303  /* generate final progress message */
305  uc->file_size,
306  NULL,
307  0,
308  0);
310  &emsg);
311  uc->tc = NULL;
313  uc->fh = NULL;
315  uc->dsh = NULL;
319  "fs",
320  handlers,
322  uc);
323  if (NULL == uc->mq)
324  {
326  uc->emsg =
327  GNUNET_strdup (_ ("Failed to connect to FS service for unindexing."));
330  return;
331  }
333  "Sending UNINDEX message to FS service\n");
334  env = GNUNET_MQ_msg (req,
336  req->reserved = 0;
337  req->file_id = uc->file_id;
338  GNUNET_MQ_send (uc->mq,
339  env);
340 }
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
@ UNINDEX_STATE_FS_NOTIFY
We're notifying the FS service about the unindexing.
Definition: fs_api.h:1333
void GNUNET_FS_tree_encoder_finish(struct GNUNET_FS_TreeEncoder *te, char **emsg)
Clean up a tree encoder and return information about possible errors.
Definition: fs_tree.c:432
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:114
static void unindex_mq_error_handler(void *cls, enum GNUNET_MQ_Error error)
Generic error handler, called with the appropriate error code and the same closure specified at the c...
Definition: fs_unindex.c:265
static struct GNUNET_CADET_MessageHandler handlers[]
Handlers, for diverse services.
struct GNUNET_MQ_Handle * GNUNET_CLIENT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *service_name, const struct GNUNET_MQ_MessageHandler *handlers, GNUNET_MQ_ErrorHandler error_handler, void *error_handler_cls)
Create a message queue to connect to a GNUnet service.
Definition: client.c:1057
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
enum GNUNET_GenericReturnValue GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1305
@ GNUNET_NO
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:304
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:77
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK
Reply to client indicating unindex receipt.
#define GNUNET_MESSAGE_TYPE_FS_UNINDEX
Request from client to unindex a file.
const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration to use.
Definition: fs_api.h:1074
Message handler for a specific message type.
Header for all communications.
Message sent from a GNUnet (fs) unindexing activity to the gnunet-service-fs to indicate that a file ...
Definition: fs.h:228
struct GNUNET_HashCode file_id
Hash of the file that we will unindex.
Definition: fs.h:242
uint32_t reserved
Always zero.
Definition: fs.h:237

References _, GNUNET_FS_Handle::cfg, GNUNET_FS_UnindexContext::dsh, GNUNET_FS_UnindexContext::emsg, env, GNUNET_FS_UnindexContext::fh, UnindexMessage::file_id, GNUNET_FS_UnindexContext::file_id, GNUNET_FS_UnindexContext::file_size, GNUNET_CLIENT_connect(), GNUNET_DATASTORE_disconnect(), GNUNET_DISK_file_close(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_tree_encoder_finish(), GNUNET_FS_unindex_sync_(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_UNINDEX, GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_NO, GNUNET_strdup, GNUNET_FS_UnindexContext::h, handlers, GNUNET_FS_UnindexContext::mq, UnindexMessage::reserved, signal_unindex_error(), GNUNET_FS_UnindexContext::state, GNUNET_FS_UnindexContext::tc, uc, unindex_mq_error_handler(), unindex_progress(), UNINDEX_STATE_ERROR, and UNINDEX_STATE_FS_NOTIFY.

Referenced by GNUNET_FS_unindex_do_remove_kblocks_(), and unindex_directory_scan_cb().

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

◆ unindex_directory_scan_cb()

static void unindex_directory_scan_cb ( void *  cls,
const char *  filename,
int  is_directory,
enum GNUNET_FS_DirScannerProgressUpdateReason  reason 
)
static

Function called by the directory scanner as we extract keywords that we will need to remove UBlocks.

Parameters
clsthe 'struct GNUNET_FS_UnindexContext *'
filenamewhich file we are making progress on
is_directoryGNUNET_YES if this is a directory, GNUNET_NO if this is a file GNUNET_SYSERR if it is neither (or unknown)
reasonkind of progress we are making

Definition at line 355 of file fs_unindex.c.

359 {
360  struct GNUNET_FS_UnindexContext *uc = cls;
361  static struct GNUNET_FS_ShareTreeItem *directory_scan_result;
362 
363  switch (reason)
364  {
366  directory_scan_result = GNUNET_FS_directory_scan_get_result (uc->dscan);
367  uc->dscan = NULL;
368  if (NULL != directory_scan_result->ksk_uri)
369  {
370  uc->ksk_uri = GNUNET_FS_uri_dup (directory_scan_result->ksk_uri);
374  }
375  else
376  {
377  uc->emsg = GNUNET_strdup (_ ("Failed to get KSKs from directory scan."));
379  unindex_finish (uc);
380  }
381  GNUNET_FS_share_tree_free (directory_scan_result);
382  break;
383 
386  _ ("Internal error scanning `%s'.\n"),
387  uc->filename);
389  uc->dscan = NULL;
390  uc->emsg = GNUNET_strdup (_ ("Failed to get KSKs from directory scan."));
392  unindex_finish (uc);
393  break;
394 
395  default:
396  break;
397  }
398 }
@ UNINDEX_STATE_DS_REMOVE_KBLOCKS
We're telling the datastore to remove KBlocks.
Definition: fs_api.h:1327
void GNUNET_FS_unindex_do_remove_kblocks_(struct GNUNET_FS_UnindexContext *uc)
If necessary, connect to the datastore and remove the KBlocks.
Definition: fs_unindex.c:581
static void unindex_finish(struct GNUNET_FS_UnindexContext *uc)
Function called when we are done with removing UBlocks.
Definition: fs_unindex.c:290
void GNUNET_FS_share_tree_free(struct GNUNET_FS_ShareTreeItem *toplevel)
Release memory of a share item tree.
Definition: fs_sharetree.c:437
struct GNUNET_FS_Uri * GNUNET_FS_uri_dup(const struct GNUNET_FS_Uri *uri)
Duplicate URI.
Definition: fs_uri.c:987
void GNUNET_FS_directory_scan_abort(struct GNUNET_FS_DirScanner *ds)
Abort the scan.
struct GNUNET_FS_ShareTreeItem * GNUNET_FS_directory_scan_get_result(struct GNUNET_FS_DirScanner *ds)
Obtain the result of the scan after the scan has signalled completion.
@ GNUNET_FS_DIRSCANNER_INTERNAL_ERROR
There was an internal error.
@ GNUNET_FS_DIRSCANNER_FINISHED
Last call to the progress function: we have finished scanning the directory.
@ GNUNET_ERROR_TYPE_WARNING
A node of a directory tree (produced by dirscanner)
struct GNUNET_FS_Uri * ksk_uri
Keywords for this file or directory (derived from metadata).
struct GNUNET_FS_DirScanner * dscan
Directory scanner to find keywords (KBlock removal).
Definition: fs_api.h:1371
struct GNUNET_FS_Uri * ksk_uri
Keywords found (telling us which KBlocks to remove).
Definition: fs_api.h:1376

References _, GNUNET_FS_UnindexContext::dscan, GNUNET_FS_UnindexContext::emsg, GNUNET_FS_UnindexContext::filename, GNUNET_ERROR_TYPE_WARNING, GNUNET_FS_directory_scan_abort(), GNUNET_FS_directory_scan_get_result(), GNUNET_FS_DIRSCANNER_FINISHED, GNUNET_FS_DIRSCANNER_INTERNAL_ERROR, GNUNET_FS_share_tree_free(), GNUNET_FS_unindex_do_remove_kblocks_(), GNUNET_FS_unindex_sync_(), GNUNET_FS_uri_dup(), GNUNET_log, GNUNET_strdup, GNUNET_FS_UnindexContext::ksk_uri, GNUNET_FS_ShareTreeItem::ksk_uri, GNUNET_FS_UnindexContext::state, uc, unindex_finish(), and UNINDEX_STATE_DS_REMOVE_KBLOCKS.

Referenced by GNUNET_FS_unindex_do_extract_keywords_().

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)

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

Extract the keywords for KBlock removal.

Parameters
uccontext for the unindex operation.

Definition at line 407 of file fs_unindex.c.

408 {
409  char *ex;
410 
411  if (GNUNET_OK !=
412  GNUNET_CONFIGURATION_get_value_string (uc->h->cfg, "FS", "EXTRACTORS",
413  &ex))
414  ex = NULL;
416  GNUNET_NO, ex,
418  uc);
419  GNUNET_free (ex);
420 }
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:355
enum GNUNET_GenericReturnValue 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.
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.
@ GNUNET_OK
#define GNUNET_free(ptr)
Wrapper around free.

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

Referenced by deserialize_unindex_file(), and unindex_extract_keywords().

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

◆ continue_after_remove()

static void continue_after_remove ( void *  cls,
int32_t  success,
struct GNUNET_TIME_Absolute  min_expiration,
const char *  msg 
)
static

Continuation called to notify client about result of the remove operation for the UBlock.

Parameters
clsthe 'struct GNUNET_FS_UnindexContext *'
successGNUNET_SYSERR on failure (including timeout/queue drop) GNUNET_NO if content was already there GNUNET_YES (or other positive value) on success
min_expirationminimum expiration time required for 0-priority content to be stored by the datacache at this time, zero for unknown, forever if we have no space for 0-priority content
msgNULL on success, otherwise an error message

Definition at line 437 of file fs_unindex.c.

441 {
442  struct GNUNET_FS_UnindexContext *uc = cls;
443 
444  uc->dqe = NULL;
445  if (success != GNUNET_YES)
447  _ ("Failed to remove UBlock: %s\n"),
448  msg);
449  uc->ksk_offset++;
451 }
@ GNUNET_YES
struct GNUNET_DATASTORE_QueueEntry * dqe
Handle to datastore 'get_key' operation issued for obtaining KBlocks.
Definition: fs_api.h:1424
uint32_t ksk_offset
Current offset in KSK removal.
Definition: fs_api.h:1381

References _, GNUNET_FS_UnindexContext::dqe, GNUNET_ERROR_TYPE_WARNING, GNUNET_FS_unindex_do_remove_kblocks_(), GNUNET_log, GNUNET_YES, GNUNET_FS_UnindexContext::ksk_offset, msg, and uc.

Referenced by process_kblock_for_unindex().

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

◆ process_kblock_for_unindex()

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

Function called from datastore with result from us looking for a UBlock.

There are four cases: 1) no result, means we move on to the next keyword 2) data hash is the same as an already seen data hash, means we move on to next keyword 3) UBlock for a different CHK, means we keep looking for more 4) UBlock is for our CHK, means we remove the block and then move on to the next keyword

Parameters
clsthe 'struct GNUNET_FS_UnindexContext *'
keykey for the content
sizenumber of bytes in data
datacontent stored
typetype of the content
prioritypriority of the content
anonymityanonymity-level for the content
replicationreplication-level for the content
expirationexpiration time for the content
uidunique identifier for the datum; maybe 0 if no unique identifier is available

Definition at line 477 of file fs_unindex.c.

487 {
488  struct GNUNET_FS_UnindexContext *uc = cls;
489  const struct UBlock *ub;
490  struct GNUNET_FS_Uri *chk_uri;
491  struct GNUNET_HashCode query;
492 
493  uc->dqe = NULL;
494  if (NULL == data)
495  {
496  /* no result */
497  uc->ksk_offset++;
499  return;
500  }
502  if (size < sizeof(struct UBlock))
503  {
504  GNUNET_break (0);
505  goto get_next;
506  }
507  ub = data;
509  sizeof(ub->verification_key),
510  &query);
511  if (0 != memcmp (&query,
512  key,
513  sizeof(struct GNUNET_HashCode)))
514  {
515  /* result does not match our keyword, skip */
516  goto get_next;
517  }
518  {
519  char pt[size - sizeof(struct UBlock)];
520  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
521  const char *keyword;
522 
525  &anon_pub);
526  keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
527  GNUNET_FS_ublock_decrypt_ (&ub[1], size - sizeof(struct UBlock),
528  &anon_pub,
529  keyword,
530  pt);
531  if (NULL == memchr (&pt[1], 0, sizeof(pt) - 1))
532  {
533  GNUNET_break_op (0); /* malformed UBlock */
534  goto get_next;
535  }
536  chk_uri = GNUNET_FS_uri_parse (&pt[1], NULL);
537  if (NULL == chk_uri)
538  {
539  GNUNET_break_op (0); /* malformed UBlock */
540  goto get_next;
541  }
542  }
543  if (0 != memcmp (&uc->chk,
544  &chk_uri->data.chk.chk,
545  sizeof(struct ContentHashKey)))
546  {
547  /* different CHK, ignore */
548  GNUNET_FS_uri_destroy (chk_uri);
549  goto get_next;
550  }
551  GNUNET_FS_uri_destroy (chk_uri);
552  /* matches! */
554  key,
555  size,
556  data,
557  0 /* priority */,
558  1 /* queue size */,
560  uc);
561  return;
562 get_next:
564  uid + 1 /* next_uid */,
565  false /* random */,
566  &uc->uquery,
568  0 /* priority */,
569  1 /* queue size */,
571  uc);
572 }
@ GNUNET_BLOCK_TYPE_FS_UBLOCK
Type of a block representing any type of search result (universal).
void GNUNET_FS_ublock_decrypt_(const void *input, size_t input_len, const struct GNUNET_CRYPTO_EcdsaPublicKey *ns, const char *label, void *output)
Decrypt the given UBlock, storing the result in output.
static void continue_after_remove(void *cls, int32_t success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Continuation called to notify client about result of the remove operation for the UBlock.
Definition: fs_unindex.c:437
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:477
struct GNUNET_HashCode key
The key used in the DHT.
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:481
void GNUNET_CRYPTO_ecdsa_key_get_public(const struct GNUNET_CRYPTO_EcdsaPrivateKey *priv, struct GNUNET_CRYPTO_EcdsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:186
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_Uri * GNUNET_FS_uri_parse(const char *uri, char **emsg)
Convert a UTF-8 String to a URI.
Definition: fs_uri.c:637
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:677
void GNUNET_CRYPTO_hash(const void *block, size_t size, struct GNUNET_HashCode *ret)
Compute hash of a given block.
Definition: crypto_hash.c:41
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
content hash key
Definition: fs.h:55
struct ContentHashKey chk
Query and key of the top GNUNET_EC_IBlock.
Definition: fs_api.h:104
Public ECC key (always for Curve25519) encoded in a format suitable for network transmission and ECDS...
struct GNUNET_HashCode uquery
Current query of 'get_key' operation.
Definition: fs_api.h:1434
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:167
struct GNUNET_FS_Uri::@13::@14 ksk
union GNUNET_FS_Uri::@13 data
struct FileIdentifier chk
Information needed to retrieve a file (content-hash-key plus file size).
Definition: fs_api.h:212
A 512-bit hashcode.
universal block for keyword and namespace search results
Definition: block_fs.h:54
struct GNUNET_CRYPTO_EcdsaPublicKey verification_key
Public key used to sign this block.
Definition: block_fs.h:68

References FileIdentifier::chk, GNUNET_FS_Uri::chk, GNUNET_FS_UnindexContext::chk, continue_after_remove(), GNUNET_FS_Uri::data, data, GNUNET_FS_UnindexContext::dqe, GNUNET_FS_UnindexContext::dsh, GNUNET_assert, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break, GNUNET_break_op, GNUNET_CRYPTO_ecdsa_key_get_anonymous(), GNUNET_CRYPTO_ecdsa_key_get_public(), GNUNET_CRYPTO_hash(), GNUNET_DATASTORE_get_key(), GNUNET_DATASTORE_remove(), GNUNET_FS_ublock_decrypt_(), GNUNET_FS_unindex_do_remove_kblocks_(), GNUNET_FS_uri_destroy(), GNUNET_FS_uri_parse(), key, GNUNET_FS_Uri::ksk, GNUNET_FS_UnindexContext::ksk_offset, GNUNET_FS_UnindexContext::ksk_uri, size, type, uc, GNUNET_FS_UnindexContext::uquery, and UBlock::verification_key.

Referenced by GNUNET_FS_unindex_do_remove_kblocks_().

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

582 {
583  const char *keyword;
584  const struct GNUNET_CRYPTO_EcdsaPrivateKey *anon;
585  struct GNUNET_CRYPTO_EcdsaPublicKey anon_pub;
586  struct GNUNET_CRYPTO_EcdsaPublicKey dpub;
587 
588  if (NULL == uc->dsh)
590  if (NULL == uc->dsh)
591  {
593  uc->emsg = GNUNET_strdup (_ ("Failed to connect to `datastore' service."));
596  return;
597  }
598  if ((NULL == uc->ksk_uri) ||
599  (uc->ksk_offset >= uc->ksk_uri->data.ksk.keywordCount))
600  {
601  unindex_finish (uc);
602  return;
603  }
606  &anon_pub);
607  keyword = &uc->ksk_uri->data.ksk.keywords[uc->ksk_offset][1];
609  keyword,
610  "fs-ublock",
611  &dpub);
612  GNUNET_CRYPTO_hash (&dpub,
613  sizeof(dpub),
614  &uc->uquery);
616  0 /* next_uid */,
617  false /* random */,
618  &uc->uquery,
620  0 /* priority */,
621  1 /* queue size */,
623  uc);
624 }
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.
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
Private ECC key encoded for transmission.

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

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

◆ unindex_extract_keywords()

static void unindex_extract_keywords ( void *  cls)
static

Function called when the tree encoder has processed all blocks.

Clean up.

Parameters
clsour unindexing context

Definition at line 634 of file fs_unindex.c.

635 {
636  struct GNUNET_FS_UnindexContext *uc = cls;
637 
641 }
@ UNINDEX_STATE_EXTRACT_KEYWORDS
Find out which keywords apply.
Definition: fs_api.h:1322
void GNUNET_FS_unindex_do_extract_keywords_(struct GNUNET_FS_UnindexContext *uc)
If necessary, connect to the datastore and remove the UBlocks.
Definition: fs_unindex.c:407

References GNUNET_FS_unindex_do_extract_keywords_(), GNUNET_FS_unindex_sync_(), GNUNET_FS_UnindexContext::state, uc, and UNINDEX_STATE_EXTRACT_KEYWORDS.

Referenced by GNUNET_FS_unindex_do_remove_().

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

651 {
652  if (NULL == uc->dsh)
654  if (NULL == uc->dsh)
655  {
657  uc->emsg = GNUNET_strdup (_ ("Failed to connect to `datastore' service."));
660  return;
661  }
662  uc->fh =
665  if (NULL == uc->fh)
666  {
668  uc->dsh = NULL;
670  uc->emsg = GNUNET_strdup (_ ("Failed to open file for unindexing."));
673  return;
674  }
675  uc->tc =
677  uc->file_size,
678  uc,
684 }
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:258
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:52
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:194
static void unindex_extract_keywords(void *cls)
Function called when the tree encoder has processed all blocks.
Definition: fs_unindex.c:634
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:1234
@ GNUNET_DISK_OPEN_READ
Open the file for reading.
@ GNUNET_DISK_PERM_NONE
Nobody is allowed to do anything to the file.

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, uc, unindex_extract_keywords(), unindex_process(), unindex_progress(), unindex_reader(), and UNINDEX_STATE_ERROR.

Referenced by deserialize_unindex_file(), and GNUNET_FS_unindex_process_hash_().

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

697 {
698  struct GNUNET_FS_UnindexContext *uc = cls;
699 
700  uc->fhc = NULL;
702  {
704  return;
705  }
706  if (file_id == NULL)
707  {
709  uc->emsg = GNUNET_strdup (_ ("Failed to compute hash of file."));
712  return;
713  }
714  uc->file_id = *file_id;
718 }
@ UNINDEX_STATE_DS_REMOVE
We're telling the datastore to delete the respective DBlocks and IBlocks.
Definition: fs_api.h:1317
@ UNINDEX_STATE_HASHING
We're currently hashing the file.
Definition: fs_api.h:1311
void GNUNET_FS_unindex_do_remove_(struct GNUNET_FS_UnindexContext *uc)
Connect to the datastore and remove the blocks.
Definition: fs_unindex.c:650
void GNUNET_FS_unindex_stop(struct GNUNET_FS_UnindexContext *uc)
Clean up after completion of an unindex operation.
Definition: fs_unindex.c:838
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
Definition: fs_api.h:1444

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

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

729 {
730  struct GNUNET_FS_UnindexContext *uc = cls;
731  struct GNUNET_FS_ProgressInfo pi;
732 
733  /* FIXME: lots of duplication with unindex_stop here! */
734  if (uc->dscan != NULL)
735  {
737  uc->dscan = NULL;
738  }
739  if (NULL != uc->dqe)
740  {
742  uc->dqe = NULL;
743  }
744  if (uc->fhc != NULL)
745  {
747  uc->fhc = NULL;
748  }
749  if (NULL != uc->ksk_uri)
750  {
752  uc->ksk_uri = NULL;
753  }
754  if (NULL != uc->mq)
755  {
757  uc->mq = NULL;
758  }
759  if (NULL != uc->dsh)
760  {
762  uc->dsh = NULL;
763  }
764  if (NULL != uc->tc)
765  {
767  uc->tc = NULL;
768  }
769  if (uc->fh != NULL)
770  {
772  uc->fh = NULL;
773  }
774  GNUNET_FS_end_top (uc->h, uc->top);
777  (uc->state ==
779  GNUNET_break (NULL == uc->client_info);
782  GNUNET_free (uc->emsg);
783  GNUNET_free (uc);
784 }
void GNUNET_FS_end_top(struct GNUNET_FS_Handle *h, struct TopLevelActivity *top)
Destroy a top-level activity entry.
Definition: fs_api.c:402
void GNUNET_DATASTORE_cancel(struct GNUNET_DATASTORE_QueueEntry *qe)
Cancel a datastore operation.
@ GNUNET_FS_STATUS_UNINDEX_SUSPEND
Notification that we suspended unindexing a file.
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
struct TopLevelActivity * top
Our top-level activity entry.
Definition: fs_api.h:1366
char * serialization
Short name under which we are serializing the state of this operation.
Definition: fs_api.h:1391

References GNUNET_FS_UnindexContext::client_info, GNUNET_FS_UnindexContext::dqe, GNUNET_FS_UnindexContext::dscan, GNUNET_FS_UnindexContext::dsh, GNUNET_FS_UnindexContext::emsg, GNUNET_FS_UnindexContext::fh, GNUNET_FS_UnindexContext::fhc, GNUNET_FS_UnindexContext::file_size, GNUNET_FS_UnindexContext::filename, GNUNET_break, GNUNET_CRYPTO_hash_file_cancel(), GNUNET_DATASTORE_cancel(), GNUNET_DATASTORE_disconnect(), GNUNET_DISK_file_close(), GNUNET_free, GNUNET_FS_directory_scan_abort(), GNUNET_FS_end_top(), GNUNET_FS_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, pi, GNUNET_FS_UnindexContext::serialization, GNUNET_FS_UnindexContext::state, GNUNET_FS_UnindexContext::tc, GNUNET_FS_UnindexContext::top, uc, and UNINDEX_STATE_COMPLETE.

Referenced by deserialize_unindex_file(), and GNUNET_FS_unindex_start().

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