gnunet-service-fs_indexing.h File Reference

indexing for the file-sharing service More...

#include "gnunet_block_lib.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 dependency graph for gnunet-service-fs_indexing.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
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...
int	GNUNET_FS_indexing_init (const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_DATASTORE_Handle *d)
	Initialize the indexing submodule. More...
void	GNUNET_FS_indexing_done (void)
	Shutdown the module. More...

Detailed Description

indexing for the file-sharing service

Author

Christian Grothoff

Definition in file gnunet-service-fs_indexing.h.

Function Documentation

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, fh, 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_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, 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:

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: