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_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.
static void	read_index_list ()
	Read index information from disk.
static void	remove_cont (void *cls, int success, struct GNUNET_TIME_Absolute min_expiration, const char *msg)
	Continuation called from datastore's remove function.
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.
void	GNUNET_FS_indexing_send_list (struct GNUNET_MQ_Handle *mq)
	Transmit information about indexed files to mq.
int	GNUNET_FS_indexing_do_unindex (const struct GNUNET_HashCode *fid)
	Remove a file from the 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.
void	GNUNET_FS_indexing_done ()
	Shutdown the module.
int	GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_DATASTORE_Handle *d)
	Initialize the indexing submodule.

Variables
static struct IndexInfo *	indexed_files_head
	Head of linked list of indexed files.
static struct IndexInfo *	indexed_files_tail
	Tail of linked list of indexed files.
static struct GNUNET_CONTAINER_MultiHashMap *	ifm
	Maps hash over content of indexed files to the respective 'struct IndexInfo'.
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration.
static struct GNUNET_DATASTORE_Handle *	dsh
	Datastore handle.

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.

{
  struct GNUNET_BIO_WriteHandle *wh;
  char *fn;
  struct IndexInfo *pos;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                               "fs",
                               "INDEXDB");
    return;
  }
  wh = GNUNET_BIO_write_open_file (fn);
  if (NULL == wh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                _ ("Could not open `%s'.\n"),
                fn);
    GNUNET_free (fn);
    return;
  }
  for (pos = indexed_files_head; NULL != pos; pos = pos->next)
    if ((GNUNET_OK != GNUNET_BIO_write (wh,
                                        "fs-indexing-file-id",
                                        &pos->file_id,
                                        sizeof(struct GNUNET_HashCode))) ||
        (GNUNET_OK != GNUNET_BIO_write_string (wh,
                                               "fs-indexing-filename",
                                               pos->filename)))
      break;
  if (GNUNET_OK != GNUNET_BIO_write_close (wh, NULL))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                _ ("Error writing `%s'.\n"),
                fn);
    GNUNET_free (fn);
    return;
  }
  GNUNET_free (fn);
}

References _, cfg, IndexInfo::file_id, IndexInfo::filename, GNUNET_BIO_write(), GNUNET_BIO_write_close(), GNUNET_BIO_write_open_file(), 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, indexed_files_head, and IndexInfo::next.

Referenced by GNUNET_FS_add_to_index(), and GNUNET_FS_indexing_do_unindex().

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 159 of file gnunet-service-fs_indexing.c.

{
  struct GNUNET_BIO_ReadHandle *rh;
  char *fn;
  struct IndexInfo *pos;
  char *fname;
  struct GNUNET_HashCode hc;
  size_t slen;
  char *emsg;
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                               "fs",
                               "INDEXDB");
    return;
  }
  if (GNUNET_NO == GNUNET_DISK_file_test (fn))
  {
    /* no index info yet */
    GNUNET_free (fn);
    return;
  }
  rh = GNUNET_BIO_read_open_file (fn);
  if (NULL == rh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                _ ("Could not open `%s'.\n"),
                fn);
    GNUNET_free (fn);
    return;
  }
  while (
    (GNUNET_OK == GNUNET_BIO_read (rh,
                                   "Hash of indexed file",
                                   &hc,
                                   sizeof(struct GNUNET_HashCode))) &&
    (GNUNET_OK ==
     GNUNET_BIO_read_string (rh, "Name of indexed file", &fname, 1024 * 16)) &&
    (fname != NULL))
  {
    slen = strlen (fname) + 1;
    pos = GNUNET_malloc (sizeof(struct IndexInfo) + slen);
    pos->file_id = hc;
    pos->filename = (const char *) &pos[1];
    GNUNET_memcpy (&pos[1], fname, slen);
    if (GNUNET_SYSERR == GNUNET_CONTAINER_multihashmap_put (
          ifm,
          &pos->file_id,
          pos,
          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
    {
      GNUNET_free (pos);
    }
    else
    {
      GNUNET_CONTAINER_DLL_insert (indexed_files_head, indexed_files_tail, pos);
    }
    GNUNET_free (fname);
  }
  if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
    GNUNET_free (emsg);
  GNUNET_free (fn);
}

References _, cfg, IndexInfo::file_id, IndexInfo::filename, GNUNET_BIO_read(), GNUNET_BIO_read_close(), GNUNET_BIO_read_open_file(), 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, GNUNET_SYSERR, ifm, indexed_files_head, and indexed_files_tail.

Referenced by GNUNET_FS_indexing_init().

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

cls	unused
success	did the deletion work?
min_expiration	minimum expiration time required for content to be stored
msg	error message

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

{
  if (GNUNET_OK != success)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to delete bogus block: %s\n"),
                msg);
}

References _, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_OK, and msg.

Referenced by GNUNET_FS_handle_on_demand_block().

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

key	key for the content
size	number of bytes in data
data	content stored
type	type of the content
priority	priority of the content
anonymity	anonymity-level for the content
replication	replication-level for the content
expiration	expiration time for the content
uid	unique identifier for the datum; maybe 0 if no unique identifier is available
cont	function to call with the actual block (at most once, on success)
cont_cls	closure for cont

Returns

GNUNET_OK on success

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

{
  const struct OnDemandBlock *odb;
  struct GNUNET_HashCode nkey;
  struct GNUNET_CRYPTO_SymmetricSessionKey skey;
  struct GNUNET_CRYPTO_SymmetricInitializationVector iv;
  struct GNUNET_HashCode query;
  ssize_t nsize;
  char ndata[DBLOCK_SIZE];
  char edata[DBLOCK_SIZE];
  const char *fn;
  struct GNUNET_DISK_FileHandle *fh;
  uint64_t off;
  struct IndexInfo *ii;
 
  if (size != sizeof(struct OnDemandBlock))
  {
    GNUNET_break (0);
    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
    return GNUNET_SYSERR;
  }
  odb = (const struct OnDemandBlock *) data;
  off = GNUNET_ntohll (odb->offset);
  ii = GNUNET_CONTAINER_multihashmap_get (ifm, &odb->file_id);
  if (NULL == ii)
  {
    GNUNET_break (0);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to find index %s\n",
                GNUNET_h2s (&odb->file_id));
    return GNUNET_SYSERR;
  }
  fn = ii->filename;
  if ((NULL == fn) || (0 != access (fn, R_OK)))
  {
    GNUNET_STATISTICS_update (
      GSF_stats,
      gettext_noop ("# index blocks removed: original file inaccessible"),
      1,
      GNUNET_YES);
    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
    return GNUNET_SYSERR;
  }
  if ((NULL == (fh = GNUNET_DISK_file_open (fn,
                                            GNUNET_DISK_OPEN_READ,
                                            GNUNET_DISK_PERM_NONE))) ||
      (off != GNUNET_DISK_file_seek (fh, off, GNUNET_DISK_SEEK_SET)) ||
      (-1 == (nsize = GNUNET_DISK_file_read (fh, ndata, sizeof(ndata)))))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ (
                  "Could not access indexed file `%s' (%s) at offset %llu: %s\n"),
                GNUNET_h2s (&odb->file_id),
                fn,
                (unsigned long long) off,
                (fn == NULL) ? _ ("not indexed") : strerror (errno));
    if (fh != NULL)
      GNUNET_DISK_file_close (fh);
    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
    return GNUNET_SYSERR;
  }
  GNUNET_DISK_file_close (fh);
  GNUNET_CRYPTO_hash (ndata, nsize, &nkey);
  GNUNET_CRYPTO_hash_to_aes_key (&nkey, &skey, &iv);
  GNUNET_CRYPTO_symmetric_encrypt (ndata, nsize, &skey, &iv, edata);
  GNUNET_CRYPTO_hash (edata, nsize, &query);
  if (0 != memcmp (&query, key, sizeof(struct GNUNET_HashCode)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Indexed file `%s' changed at offset %llu\n"),
                fn,
                (unsigned long long) off);
    GNUNET_DATASTORE_remove (dsh, key, size, data, -1, -1, &remove_cont, NULL);
    return GNUNET_SYSERR;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "On-demand encoded block for query `%s'\n",
              GNUNET_h2s (key));
  cont (cont_cls,
        key,
        nsize,
        edata,
        GNUNET_BLOCK_TYPE_FS_DBLOCK,
        priority,
        anonymity,
        replication,
        expiration,
        uid);
  return GNUNET_OK;
}

References _, anonymity, data, DBLOCK_SIZE, dsh, expiration, OnDemandBlock::file_id, IndexInfo::filename, 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, ifm, key, OnDemandBlock::offset, remove_cont(), replication, and size.

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

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

mq	message queue to send information to

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

{
  struct GNUNET_MQ_Envelope *env;
  struct IndexInfoMessage *iim;
  struct GNUNET_MessageHeader *iem;
  size_t slen;
  const char *fn;
  struct IndexInfo *pos;
 
  for (pos = indexed_files_head; NULL != pos; pos = pos->next)
  {
    fn = pos->filename;
    slen = strlen (fn) + 1;
    if (slen + sizeof(struct IndexInfoMessage) >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break (0);
      break;
    }
    env =
      GNUNET_MQ_msg_extra (iim, slen, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_ENTRY);
    iim->reserved = 0;
    iim->file_id = pos->file_id;
    GNUNET_memcpy (&iim[1], fn, slen);
    GNUNET_MQ_send (mq, env);
  }
  env = GNUNET_MQ_msg (iem, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_END);
  GNUNET_MQ_send (mq, env);
}

References env, IndexInfoMessage::file_id, IndexInfo::file_id, IndexInfo::filename, 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(), indexed_files_head, mq, IndexInfo::next, and IndexInfoMessage::reserved.

Referenced by handle_client_index_list_get().

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

fid	identifier of the file to remove

Returns

GNUNET_YES if the fid was found

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

{
  struct IndexInfo *pos;
 
  for (pos = indexed_files_head; NULL != pos; pos = pos->next)
  {
    if (0 == memcmp (&pos->file_id, fid, sizeof(struct GNUNET_HashCode)))
    {
      GNUNET_CONTAINER_DLL_remove (indexed_files_head, indexed_files_tail, pos);
      GNUNET_break (
        GNUNET_OK ==
        GNUNET_CONTAINER_multihashmap_remove (ifm, &pos->file_id, pos));
      GNUNET_free (pos);
      write_index_list ();
      return GNUNET_YES;
    }
  }
  return GNUNET_NO;
}

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

Referenced by handle_client_unindex().

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

filename	name of the file
file_id	hash identifier for filename

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

{
  struct IndexInfo *ii;
  size_t slen;
 
  ii = GNUNET_CONTAINER_multihashmap_get (ifm, file_id);
  if (NULL != ii)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_INFO,
      _ (
        "Index request received for file `%s' is already indexed as `%s'.  Permitting anyway.\n"),
      filename,
      ii->filename);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding file %s to index as %s\n",
              filename,
              GNUNET_h2s (file_id));
  slen = strlen (filename) + 1;
  ii = GNUNET_malloc (sizeof(struct IndexInfo) + slen);
  ii->file_id = *file_id;
  ii->filename = (const char *) &ii[1];
  GNUNET_memcpy (&ii[1], filename, slen);
  GNUNET_CONTAINER_DLL_insert (indexed_files_head, indexed_files_tail, ii);
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_put (
                   ifm,
                   &ii->file_id,
                   ii,
                   GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY));
  write_index_list ();
}

References _, IndexInfo::file_id, filename, 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, ifm, indexed_files_head, indexed_files_tail, and write_index_list().

Referenced by signal_index_ok().

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 463 of file gnunet-service-fs_indexing.c.

{
  struct IndexInfo *pos;
 
  while (NULL != (pos = indexed_files_head))
  {
    GNUNET_CONTAINER_DLL_remove (indexed_files_head, indexed_files_tail, pos);
    if (pos->fhc != NULL)
      GNUNET_CRYPTO_hash_file_cancel (pos->fhc);
    GNUNET_break (
      GNUNET_OK ==
      GNUNET_CONTAINER_multihashmap_remove (ifm, &pos->file_id, pos));
    GNUNET_free (pos);
  }
  GNUNET_CONTAINER_multihashmap_destroy (ifm);
  ifm = NULL;
  cfg = NULL;
}

References cfg, 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, GNUNET_OK, ifm, indexed_files_head, and indexed_files_tail.

Referenced by shutdown_task().

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

c	configuration to use
d	datastore to use

Returns

GNUNET_OK on success

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

{
  cfg = c;
  dsh = d;
  ifm = GNUNET_CONTAINER_multihashmap_create (128, GNUNET_YES);
  read_index_list ();
  return GNUNET_OK;
}

References cfg, d, dsh, GNUNET_CONTAINER_multihashmap_create(), GNUNET_OK, GNUNET_YES, ifm, and read_index_list().

Referenced by run().

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.

Referenced by GNUNET_FS_add_to_index(), GNUNET_FS_indexing_do_unindex(), GNUNET_FS_indexing_done(), GNUNET_FS_indexing_send_list(), read_index_list(), and write_index_list().

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.

Referenced by GNUNET_FS_add_to_index(), GNUNET_FS_indexing_do_unindex(), GNUNET_FS_indexing_done(), and read_index_list().

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.

Referenced by GNUNET_FS_add_to_index(), GNUNET_FS_handle_on_demand_block(), GNUNET_FS_indexing_do_unindex(), GNUNET_FS_indexing_done(), GNUNET_FS_indexing_init(), and read_index_list().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

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

Referenced by GNUNET_FS_indexing_done(), GNUNET_FS_indexing_init(), read_index_list(), and write_index_list().

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_handle_on_demand_block(), GNUNET_FS_indexing_init(), GNUNET_FS_publish_start(), and GNUNET_FS_publish_ublock_().