GNUnet  0.10.x
Data Structures | Functions | Variables
gnunet-service-fs_indexing.c File Reference

program that provides indexing functions of the file-sharing service More...

#include "platform.h"
#include <float.h>
#include "gnunet_core_service.h"
#include "gnunet_datastore_service.h"
#include "gnunet_peer_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_util_lib.h"
#include "gnunet-service-fs.h"
#include "gnunet-service-fs_indexing.h"
#include "fs.h"
Include dependency graph for gnunet-service-fs_indexing.c:

Go to the source code of this file.

Data Structures

struct  IndexInfo
 In-memory information about indexed files (also available on-disk). More...
 

Functions

static void write_index_list ()
 Write the current index information list to disk. More...
 
static void read_index_list ()
 Read index information from disk. More...
 
static void remove_cont (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
 Continuation called from datastore's remove function. More...
 
int GNUNET_FS_handle_on_demand_block (const struct GNUNET_HashCode *key, uint32_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, GNUNET_DATASTORE_DatumProcessor cont, void *cont_cls)
 We've received an on-demand encoded block from the datastore. More...
 
void GNUNET_FS_indexing_send_list (struct GNUNET_MQ_Handle *mq)
 Transmit information about indexed files to mq. More...
 
int GNUNET_FS_indexing_do_unindex (const struct GNUNET_HashCode *fid)
 Remove a file from the index. More...
 
void GNUNET_FS_add_to_index (const char *filename, const struct GNUNET_HashCode *file_id)
 Add the given file to the list of indexed files. More...
 
void GNUNET_FS_indexing_done ()
 Shutdown the module. More...
 
int GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_DATASTORE_Handle *d)
 Initialize the indexing submodule. More...
 

Variables

static struct IndexInfoindexed_files_head
 Head of linked list of indexed files. More...
 
static struct IndexInfoindexed_files_tail
 Tail of linked list of indexed files. More...
 
static struct GNUNET_CONTAINER_MultiHashMapifm
 Maps hash over content of indexed files to the respective 'struct IndexInfo'. More...
 
static const struct GNUNET_CONFIGURATION_Handlecfg
 Our configuration. More...
 
static struct GNUNET_DATASTORE_Handledsh
 Datastore handle. More...
 

Detailed Description

program that provides indexing functions of the file-sharing service

Author
Christian Grothoff

Definition in file gnunet-service-fs_indexing.c.

Function Documentation

◆ write_index_list()

static void write_index_list ( )
static

Write the current index information list to disk.

Definition at line 111 of file gnunet-service-fs_indexing.c.

References _, IndexInfo::file_id, IndexInfo::filename, fn, GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_open(), GNUNET_BIO_write_string(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_OK, IndexInfo::next, and wh.

Referenced by GNUNET_FS_add_to_index(), and GNUNET_FS_indexing_do_unindex().

112 {
113  struct GNUNET_BIO_WriteHandle *wh;
114  char *fn;
115  struct IndexInfo *pos;
116 
117  if (GNUNET_OK !=
118  GNUNET_CONFIGURATION_get_value_filename(cfg, "FS", "INDEXDB", &fn))
119  {
121  "fs",
122  "INDEXDB");
123  return;
124  }
125  wh = GNUNET_BIO_write_open(fn);
126  if (NULL == wh)
127  {
129  _("Could not open `%s'.\n"),
130  fn);
131  GNUNET_free(fn);
132  return;
133  }
134  for (pos = indexed_files_head; NULL != pos; pos = pos->next)
135  if ((GNUNET_OK != GNUNET_BIO_write(wh,
136  &pos->file_id,
137  sizeof(struct GNUNET_HashCode))) ||
139  break;
141  {
143  _("Error writing `%s'.\n"),
144  fn);
145  GNUNET_free(fn);
146  return;
147  }
148  GNUNET_free(fn);
149 }
struct IndexInfo * next
This is a doubly linked list.
struct GNUNET_HashCode file_id
Hash of the contents of the file.
int GNUNET_BIO_write_string(struct GNUNET_BIO_WriteHandle *h, const char *s)
Write a string to a file.
Definition: bio.c:521
const char * filename
Name of the indexed file.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct IndexInfo * indexed_files_head
Head of linked list of indexed files.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static char * fn
Filename of the unique file.
Handle for buffered writing.
Definition: bio.c:378
A 512-bit hashcode.
In-memory information about indexed files (also available on-disk).
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:436
struct GNUNET_BIO_WriteHandle * GNUNET_BIO_write_open(const char *fn)
Open a file for writing.
Definition: bio.c:408
#define GNUNET_log(kind,...)
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
int GNUNET_BIO_write(struct GNUNET_BIO_WriteHandle *h, const void *buffer, size_t n)
Write a buffer to a file.
Definition: bio.c:481
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
#define GNUNET_free(ptr)
Wrapper around free.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ read_index_list()

static void read_index_list ( )
static

Read index information from disk.

Definition at line 156 of file gnunet-service-fs_indexing.c.

References _, IndexInfo::file_id, IndexInfo::filename, fn, GNUNET_BIO_read(), GNUNET_BIO_read_close(), GNUNET_BIO_read_open(), GNUNET_BIO_read_string(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_DISK_file_test(), GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, and GNUNET_SYSERR.

Referenced by GNUNET_FS_indexing_init().

157 {
158  struct GNUNET_BIO_ReadHandle *rh;
159  char *fn;
160  struct IndexInfo *pos;
161  char *fname;
162  struct GNUNET_HashCode hc;
163  size_t slen;
164  char *emsg;
165 
166  if (GNUNET_OK !=
167  GNUNET_CONFIGURATION_get_value_filename(cfg, "FS", "INDEXDB", &fn))
168  {
170  "fs",
171  "INDEXDB");
172  return;
173  }
174  if (GNUNET_NO == GNUNET_DISK_file_test(fn))
175  {
176  /* no index info yet */
177  GNUNET_free(fn);
178  return;
179  }
180  rh = GNUNET_BIO_read_open(fn);
181  if (NULL == rh)
182  {
184  _("Could not open `%s'.\n"),
185  fn);
186  GNUNET_free(fn);
187  return;
188  }
189  while (
190  (GNUNET_OK == GNUNET_BIO_read(rh,
191  "Hash of indexed file",
192  &hc,
193  sizeof(struct GNUNET_HashCode))) &&
194  (GNUNET_OK ==
195  GNUNET_BIO_read_string(rh, "Name of indexed file", &fname, 1024 * 16)) &&
196  (fname != NULL))
197  {
198  slen = strlen(fname) + 1;
199  pos = GNUNET_malloc(sizeof(struct IndexInfo) + slen);
200  pos->file_id = hc;
201  pos->filename = (const char *)&pos[1];
202  GNUNET_memcpy(&pos[1], fname, slen);
204  ifm,
205  &pos->file_id,
206  pos,
208  {
209  GNUNET_free(pos);
210  }
211  else
212  {
214  }
215  GNUNET_free(fname);
216  }
217  if (GNUNET_OK != GNUNET_BIO_read_close(rh, &emsg))
218  GNUNET_free(emsg);
219  GNUNET_free(fn);
220 }
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:541
struct GNUNET_HashCode file_id
Hash of the contents of the file.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static struct GNUNET_CONTAINER_MultiHashMap * ifm
Maps hash over content of indexed files to the respective &#39;struct IndexInfo&#39;.
const char * filename
Name of the indexed file.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct IndexInfo * indexed_files_head
Head of linked list of indexed files.
int GNUNET_BIO_read_close(struct GNUNET_BIO_ReadHandle *h, char **emsg)
Close an open file.
Definition: bio.c:118
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_BIO_ReadHandle * GNUNET_BIO_read_open(const char *fn)
Open a file for reading.
Definition: bio.c:93
int GNUNET_BIO_read(struct GNUNET_BIO_ReadHandle *h, const char *what, void *result, size_t len)
Read the contents of a binary file into a buffer.
Definition: bio.c:143
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
static char * fn
Filename of the unique file.
A 512-bit hashcode.
In-memory information about indexed files (also available on-disk).
int GNUNET_BIO_read_string(struct GNUNET_BIO_ReadHandle *h, const char *what, char **result, size_t max_length)
Read 0-terminated string from a file.
Definition: bio.c:232
There must only be one value per key; storing a value should fail if a value under the same key alrea...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_log(kind,...)
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
#define GNUNET_malloc(size)
Wrapper around malloc.
Handle for buffered reading.
Definition: bio.c:53
#define GNUNET_free(ptr)
Wrapper around free.
static struct IndexInfo * indexed_files_tail
Tail of linked list of indexed files.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ remove_cont()

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

Continuation called from datastore's remove function.

Parameters
clsunused
successdid the deletion work?
min_expirationminimum expiration time required for content to be stored
msgerror message

Definition at line 233 of file gnunet-service-fs_indexing.c.

References _, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, and GNUNET_OK.

Referenced by GNUNET_FS_handle_on_demand_block().

237 {
238  if (GNUNET_OK != success)
240  _("Failed to delete bogus block: %s\n"),
241  msg);
242 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
#define GNUNET_log(kind,...)
Here is the caller graph for this function:

◆ GNUNET_FS_handle_on_demand_block()

int GNUNET_FS_handle_on_demand_block ( const struct GNUNET_HashCode key,
uint32_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,
GNUNET_DATASTORE_DatumProcessor  cont,
void *  cont_cls 
)

We've received an on-demand encoded block from the datastore.

Attempt to do on-demand encoding and (if successful), call the continuation with the resulting block. On error, clean up and ask the datastore for more results.

Parameters
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
contfunction to call with the actual block (at most once, on success)
cont_clsclosure for cont
Returns
GNUNET_OK on success

Definition at line 266 of file gnunet-service-fs_indexing.c.

References _, DBLOCK_SIZE, fh, OnDemandBlock::file_id, IndexInfo::filename, fn, gettext_noop, GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_hash_to_aes_key(), GNUNET_CRYPTO_symmetric_encrypt(), GNUNET_DATASTORE_remove(), 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_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_log, GNUNET_ntohll(), GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_YES, GSF_stats, OnDemandBlock::offset, and remove_cont().

Referenced by handle_datastore_reply(), process_local_reply(), and process_migration_content().

277 {
278  const struct OnDemandBlock *odb;
279  struct GNUNET_HashCode nkey;
282  struct GNUNET_HashCode query;
283  ssize_t nsize;
284  char ndata[DBLOCK_SIZE];
285  char edata[DBLOCK_SIZE];
286  const char *fn;
287  struct GNUNET_DISK_FileHandle *fh;
288  uint64_t off;
289  struct IndexInfo *ii;
290 
291  if (size != sizeof(struct OnDemandBlock))
292  {
293  GNUNET_break(0);
294  GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
295  return GNUNET_SYSERR;
296  }
297  odb = (const struct OnDemandBlock *)data;
298  off = GNUNET_ntohll(odb->offset);
300  if (NULL == ii)
301  {
302  GNUNET_break(0);
304  "Failed to find index %s\n",
305  GNUNET_h2s(&odb->file_id));
306  return GNUNET_SYSERR;
307  }
308  fn = ii->filename;
309  if ((NULL == fn) || (0 != access(fn, R_OK)))
310  {
312  GSF_stats,
313  gettext_noop("# index blocks removed: original file inaccessible"),
314  1,
315  GNUNET_YES);
316  GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
317  return GNUNET_SYSERR;
318  }
319  if ((NULL == (fh = GNUNET_DISK_file_open(fn,
322  (off != GNUNET_DISK_file_seek(fh, off, GNUNET_DISK_SEEK_SET)) ||
323  (-1 == (nsize = GNUNET_DISK_file_read(fh, ndata, sizeof(ndata)))))
324  {
326  _(
327  "Could not access indexed file `%s' (%s) at offset %llu: %s\n"),
328  GNUNET_h2s(&odb->file_id),
329  fn,
330  (unsigned long long)off,
331  (fn == NULL) ? _("not indexed") : strerror(errno));
332  if (fh != NULL)
334  GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
335  return GNUNET_SYSERR;
336  }
338  GNUNET_CRYPTO_hash(ndata, nsize, &nkey);
339  GNUNET_CRYPTO_hash_to_aes_key(&nkey, &skey, &iv);
340  GNUNET_CRYPTO_symmetric_encrypt(ndata, nsize, &skey, &iv, edata);
341  GNUNET_CRYPTO_hash(edata, nsize, &query);
342  if (0 != memcmp(&query, key, sizeof(struct GNUNET_HashCode)))
343  {
345  _("Indexed file `%s' changed at offset %llu\n"),
346  fn,
347  (unsigned long long)off);
348  GNUNET_DATASTORE_remove(dsh, key, size, data, -1, -1, &remove_cont, NULL);
349  return GNUNET_SYSERR;
350  }
352  "On-demand encoded block for query `%s'\n",
353  GNUNET_h2s(key));
354  cont(cont_cls,
355  key,
356  nsize,
357  edata,
359  priority,
360  anonymity,
361  replication,
362  expiration,
363  uid);
364  return GNUNET_OK;
365 }
Open the file for reading.
int GNUNET_DISK_file_close(struct GNUNET_DISK_FileHandle *h)
Close an open file.
Definition: disk.c:1339
static void remove_cont(void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
Continuation called from datastore&#39;s remove function.
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:729
static struct GNUNET_CONTAINER_MultiHashMap * ifm
Maps hash over content of indexed files to the respective &#39;struct IndexInfo&#39;.
const char * filename
Name of the indexed file.
static unsigned int replication
Nobody is allowed to do anything to the file.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
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:223
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static char * fn
Filename of the unique file.
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
ssize_t GNUNET_CRYPTO_symmetric_encrypt(const void *block, size_t size, const struct GNUNET_CRYPTO_SymmetricSessionKey *sessionkey, const struct GNUNET_CRYPTO_SymmetricInitializationVector *iv, void *result)
Encrypt a block using a symmetric sessionkey.
static int fh
Handle to the unique file.
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.
A 512-bit hashcode.
In-memory information about indexed files (also available on-disk).
void GNUNET_CRYPTO_hash_to_aes_key(const struct GNUNET_HashCode *hc, struct GNUNET_CRYPTO_SymmetricSessionKey *skey, struct GNUNET_CRYPTO_SymmetricInitializationVector *iv)
Convert a hashcode into a key.
Definition: crypto_hash.c:212
#define DBLOCK_SIZE
Size of the individual blocks used for file-sharing.
Definition: fs.h:40
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static unsigned int size
Size of the "table".
Definition: peer.c:66
struct GNUNET_HashCode file_id
Hash code of the entire content of the file that was indexed (used to uniquely identify the plaintext...
Definition: block_fs.h:87
Seek an absolute position (from the start of the file).
static struct GNUNET_DATASTORE_Handle * dsh
Datastore handle.
#define GNUNET_log(kind,...)
uint64_t offset
At which offset should we be able to find this on-demand encoded block? (in NBO)
Definition: block_fs.h:93
Data block (leaf) in the CHK tree.
#define GNUNET_YES
Definition: gnunet_common.h:77
static unsigned int anonymity
uint32_t data
The data value.
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:1262
Handle used to access files (and pipes).
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
index block (indexing a DBlock that can be obtained directly from reading the plaintext file) ...
Definition: block_fs.h:81
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_indexing_send_list()

void GNUNET_FS_indexing_send_list ( struct GNUNET_MQ_Handle mq)

Transmit information about indexed files to mq.

Parameters
mqmessage queue to send information to

Definition at line 374 of file gnunet-service-fs_indexing.c.

References env, IndexInfo::file_id, IndexInfoMessage::file_id, IndexInfo::filename, fn, GNUNET_break, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY, GNUNET_MQ_msg, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), IndexInfo::next, and IndexInfoMessage::reserved.

Referenced by handle_client_index_list_get().

375 {
376  struct GNUNET_MQ_Envelope *env;
377  struct IndexInfoMessage *iim;
378  struct GNUNET_MessageHeader *iem;
379  size_t slen;
380  const char *fn;
381  struct IndexInfo *pos;
382 
383  for (pos = indexed_files_head; NULL != pos; pos = pos->next)
384  {
385  fn = pos->filename;
386  slen = strlen(fn) + 1;
387  if (slen + sizeof(struct IndexInfoMessage) >= GNUNET_MAX_MESSAGE_SIZE)
388  {
389  GNUNET_break(0);
390  break;
391  }
392  env =
394  iim->reserved = 0;
395  iim->file_id = pos->file_id;
396  GNUNET_memcpy(&iim[1], fn, slen);
397  GNUNET_MQ_send(mq, env);
398  }
400  GNUNET_MQ_send(mq, env);
401 }
struct IndexInfo * next
This is a doubly linked list.
struct GNUNET_HashCode file_id
Hash of the contents of the file.
const char * filename
Name of the indexed file.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
Message send by FS service in response to a request asking for a list of all indexed files...
Definition: fs.h:191
static struct IndexInfo * indexed_files_head
Head of linked list of indexed files.
struct GNUNET_HashCode file_id
Hash of the indexed file.
Definition: fs.h:206
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY
Reply to client with an indexed file name.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
static char * fn
Filename of the unique file.
In-memory information about indexed files (also available on-disk).
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message...
#define GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END
Reply to client indicating end of list.
Header for all communications.
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:351
uint32_t reserved
Always zero.
Definition: fs.h:201
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_indexing_do_unindex()

int GNUNET_FS_indexing_do_unindex ( const struct GNUNET_HashCode fid)

Remove a file from the index.

Parameters
fididentifier of the file to remove
Returns
GNUNET_YES if the fid was found

Definition at line 411 of file gnunet-service-fs_indexing.c.

References IndexInfo::file_id, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_YES, IndexInfo::next, and write_index_list().

Referenced by handle_client_unindex().

412 {
413  struct IndexInfo *pos;
414 
415  for (pos = indexed_files_head; NULL != pos; pos = pos->next)
416  {
417  if (0 == memcmp(&pos->file_id, fid, sizeof(struct GNUNET_HashCode)))
418  {
420  GNUNET_break(
421  GNUNET_OK ==
423  GNUNET_free(pos);
425  return GNUNET_YES;
426  }
427  }
428  return GNUNET_NO;
429 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct IndexInfo * next
This is a doubly linked list.
struct GNUNET_HashCode file_id
Hash of the contents of the file.
static struct GNUNET_CONTAINER_MultiHashMap * ifm
Maps hash over content of indexed files to the respective &#39;struct IndexInfo&#39;.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct IndexInfo * indexed_files_head
Head of linked list of indexed files.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
static void write_index_list()
Write the current index information list to disk.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
A 512-bit hashcode.
In-memory information about indexed files (also available on-disk).
#define GNUNET_YES
Definition: gnunet_common.h:77
#define GNUNET_free(ptr)
Wrapper around free.
static struct IndexInfo * indexed_files_tail
Tail of linked list of indexed files.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_add_to_index()

void GNUNET_FS_add_to_index ( const char *  filename,
const struct GNUNET_HashCode file_id 
)

Add the given file to the list of indexed files.

Parameters
filenamename of the file
file_idhash identifier for filename

Definition at line 439 of file gnunet-service-fs_indexing.c.

References _, IndexInfo::file_id, IndexInfo::filename, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, and write_index_list().

Referenced by signal_index_ok().

441 {
442  struct IndexInfo *ii;
443  size_t slen;
444 
445  ii = GNUNET_CONTAINER_multihashmap_get(ifm, file_id);
446  if (NULL != ii)
447  {
448  GNUNET_log(
450  _(
451  "Index request received for file `%s' is already indexed as `%s'. Permitting anyway.\n"),
452  filename,
453  ii->filename);
454  return;
455  }
457  "Adding file %s to index as %s\n",
458  filename,
459  GNUNET_h2s(file_id));
460  slen = strlen(filename) + 1;
461  ii = GNUNET_malloc(sizeof(struct IndexInfo) + slen);
462  ii->file_id = *file_id;
463  ii->filename = (const char *)&ii[1];
464  GNUNET_memcpy(&ii[1], filename, slen);
468  ifm,
469  &ii->file_id,
470  ii,
473 }
struct GNUNET_HashCode file_id
Hash of the contents of the file.
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
static struct GNUNET_CONTAINER_MultiHashMap * ifm
Maps hash over content of indexed files to the respective &#39;struct IndexInfo&#39;.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
const char * filename
Name of the indexed file.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
static struct IndexInfo * indexed_files_head
Head of linked list of indexed files.
void * GNUNET_CONTAINER_multihashmap_get(const struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key)
Given a key find a value in the map matching the key.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static void write_index_list()
Write the current index information list to disk.
static char * filename
In-memory information about indexed files (also available on-disk).
There must only be one value per key; storing a value should fail if a value under the same key alrea...
int GNUNET_CONTAINER_multihashmap_put(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
#define GNUNET_log(kind,...)
#define GNUNET_malloc(size)
Wrapper around malloc.
static struct IndexInfo * indexed_files_tail
Tail of linked list of indexed files.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_indexing_done()

void GNUNET_FS_indexing_done ( void  )

Shutdown the module.

Definition at line 480 of file gnunet-service-fs_indexing.c.

References IndexInfo::fhc, IndexInfo::file_id, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CRYPTO_hash_file_cancel(), GNUNET_free, and GNUNET_OK.

Referenced by shutdown_task().

481 {
482  struct IndexInfo *pos;
483 
484  while (NULL != (pos = indexed_files_head))
485  {
487  if (pos->fhc != NULL)
489  GNUNET_break(
490  GNUNET_OK ==
492  GNUNET_free(pos);
493  }
495  ifm = NULL;
496  cfg = NULL;
497 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_HashCode file_id
Hash of the contents of the file.
static struct GNUNET_CONTAINER_MultiHashMap * ifm
Maps hash over content of indexed files to the respective &#39;struct IndexInfo&#39;.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct IndexInfo * indexed_files_head
Head of linked list of indexed files.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
void GNUNET_CONTAINER_multihashmap_destroy(struct GNUNET_CONTAINER_MultiHashMap *map)
Destroy a hash map.
int GNUNET_CONTAINER_multihashmap_remove(struct GNUNET_CONTAINER_MultiHashMap *map, const struct GNUNET_HashCode *key, const void *value)
Remove the given key-value pair from the map.
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
In-memory information about indexed files (also available on-disk).
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
#define GNUNET_free(ptr)
Wrapper around free.
static struct IndexInfo * indexed_files_tail
Tail of linked list of indexed files.
Here is the call graph for this function:
Here is the caller graph for this function:

◆ GNUNET_FS_indexing_init()

int GNUNET_FS_indexing_init ( const struct GNUNET_CONFIGURATION_Handle c,
struct GNUNET_DATASTORE_Handle d 
)

Initialize the indexing submodule.

Parameters
cconfiguration to use
ddatastore to use

Definition at line 507 of file gnunet-service-fs_indexing.c.

References GNUNET_CONTAINER_multihashmap_create(), GNUNET_OK, GNUNET_YES, and read_index_list().

Referenced by run().

509 {
510  cfg = c;
511  dsh = d;
513  read_index_list();
514  return GNUNET_OK;
515 }
static struct GNUNET_CONTAINER_MultiHashMap * ifm
Maps hash over content of indexed files to the respective &#39;struct IndexInfo&#39;.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static void read_index_list()
Read index information from disk.
static struct GNUNET_DATASTORE_Handle * dsh
Datastore handle.
struct GNUNET_CONTAINER_MultiHashMap * GNUNET_CONTAINER_multihashmap_create(unsigned int len, int do_not_copy_keys)
Create a multi hash map.
#define GNUNET_YES
Definition: gnunet_common.h:77
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
Here is the call graph for this function:
Here is the caller graph for this function:

Variable Documentation

◆ indexed_files_head

struct IndexInfo* indexed_files_head
static

Head of linked list of indexed files.

FIXME: we don't need both a DLL and a hashmap here!

Definition at line 81 of file gnunet-service-fs_indexing.c.

◆ indexed_files_tail

struct IndexInfo* indexed_files_tail
static

Tail of linked list of indexed files.

Definition at line 86 of file gnunet-service-fs_indexing.c.

◆ ifm

struct GNUNET_CONTAINER_MultiHashMap* ifm
static

Maps hash over content of indexed files to the respective 'struct IndexInfo'.

The filenames are pointers into the indexed_files linked list and do not need to be freed.

Definition at line 93 of file gnunet-service-fs_indexing.c.

◆ cfg

const struct GNUNET_CONFIGURATION_Handle* cfg
static

Our configuration.

Definition at line 98 of file gnunet-service-fs_indexing.c.

◆ dsh

struct GNUNET_DATASTORE_Handle* dsh
static

Datastore handle.

Created and destroyed by code in gnunet-service-fs (this is an alias).

Definition at line 104 of file gnunet-service-fs_indexing.c.

Referenced by GNUNET_FS_publish_start().