gnunet-service-fs.c File Reference

gnunet anonymity protocol implementation More...

#include "platform.h"
#include <float.h>
#include "gnunet_core_service.h"
#include "gnunet_pils_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_datastore_service.h"
#include "gnunet_load_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_statistics_service.h"
#include "gnunet_util_lib.h"
#include "gnunet-service-fs_cp.h"
#include "gnunet-service-fs_indexing.h"
#include "gnunet-service-fs_pe.h"
#include "gnunet-service-fs_pr.h"
#include "gnunet-service-fs_push.h"
#include "gnunet-service-fs_put.h"
#include "gnunet-service-fs_cadet.h"
#include "fs.h"
#include "fs_api.h"

Include dependency graph for gnunet-service-fs.c:

Go to the source code of this file.

Data Structures
struct	ClientRequest
	Doubly-linked list of requests we are performing on behalf of the same client. More...
struct	ClientResponse
	Replies to be transmitted to the client. More...
struct	IndexStartContext
	Information we track while handling an index start request from a client. More...
struct	GSF_LocalClient
	A local client. More...

Macros
#define	FS_DHT_HT_SIZE   1024
	Size for the hash map for DHT requests from the FS service.
#define	COVER_AGE_FREQUENCY
	How quickly do we age cover traffic? At the given time interval, remaining cover traffic counters are decremented by 1/16th.
#define	INSANE_STATISTICS   GNUNET_NO
	Collect an instance number of statistics? May cause excessive IPC.

Functions
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Creates a fresh local client handle.
static void	client_request_destroy (void *cls)
	Free the given client request.
static void	client_response_handler (void *cls, enum GNUNET_BLOCK_ReplyEvaluationResult eval, struct GSF_PendingRequest *pr, uint32_t reply_anonymity_level, struct GNUNET_TIME_Absolute expiration, struct GNUNET_TIME_Absolute last_transmission, enum GNUNET_BLOCK_Type type, const void *data, size_t data_len)
	Handle a reply to a pending request.
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	A client disconnected from us.
static void	age_cover_counters (void *cls)
	Task that periodically ages our cover traffic statistics.
void	GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start)
	We've just now completed a datastore request.
int	GSF_test_get_load_too_high_ (uint32_t priority)
	Test if the DATABASE (GET) load on this peer is too high to even consider processing the query at all.
static int	check_p2p_put (void *cls, const struct PutMessage *put)
	Check P2P "PUT" message.
static void	consider_request_for_forwarding (void *cls, const struct GNUNET_PeerIdentity *peer, struct GSF_ConnectedPeer *cp, const struct GSF_PeerPerformanceData *ppd)
	We have a new request, consider forwarding it to the given peer.
void	GSF_consider_forwarding (void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_ReplyEvaluationResult result)
	Function to be called after we're done processing replies from the local lookup.
static int	check_p2p_get (void *cls, const struct GetMessage *gm)
	Check P2P "GET" request.
static void	start_p2p_processing (void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_ReplyEvaluationResult result)
	We're done with the local lookup, now consider P2P processing (depending on request options and result status).
static int	check_client_start_search (void *cls, const struct SearchMessage *sm)
	Check GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).
static void	handle_client_start_search (void *cls, const struct SearchMessage *sm)
	Handle GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).
static void	handle_client_loc_sign (void *cls, const struct RequestLocSignatureMessage *msg)
	Handle request to sign a LOC URI (from client).
static int	check_client_index_start (void *cls, const struct IndexStartMessage *ism)
	Check INDEX_START-message.
static void	signal_index_ok (struct IndexStartContext *isc)
	We've validated the hash of the file we're about to index.
static void	hash_for_index_val (void *cls, const struct GNUNET_HashCode *res)
	Function called once the hash computation over an indexed file has completed.
static void	handle_client_index_start (void *cls, const struct IndexStartMessage *ism)
	Handle INDEX_START-message.
static void	handle_client_index_list_get (void *cls, const struct GNUNET_MessageHeader *message)
	Handle INDEX_LIST_GET-message.
static void	handle_client_unindex (void *cls, const struct UnindexMessage *um)
	Handle UNINDEX-message.
static void	shutdown_task (void *cls)
	Task run during shutdown.
static void	pils_pid_change_cb (void *cls, const struct GNUNET_HELLO_Parser *parser, const struct GNUNET_HashCode *hash)
	Function called after GNUNET_PILS_connect has succeeded (or failed for good).
static int	main_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Process fs requests.
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Process fs requests.
	GNUNET_SERVICE_MAIN (GNUNET_OS_project_data_gnunet(), "fs", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(client_index_start, GNUNET_MESSAGE_TYPE_FS_INDEX_START, struct IndexStartMessage, NULL), GNUNET_MQ_hd_fixed_size(client_index_list_get, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET, struct GNUNET_MessageHeader, NULL), GNUNET_MQ_hd_fixed_size(client_unindex, GNUNET_MESSAGE_TYPE_FS_UNINDEX, struct UnindexMessage, NULL), GNUNET_MQ_hd_var_size(client_start_search, GNUNET_MESSAGE_TYPE_FS_START_SEARCH, struct SearchMessage, NULL), GNUNET_MQ_hd_fixed_size(client_loc_sign, GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN, struct RequestLocSignatureMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro.

Variables
struct GNUNET_DATASTORE_Handle *	GSF_dsh
	Our connection to the datastore.
const struct GNUNET_CONFIGURATION_Handle *	GSF_cfg
	Our configuration.
struct GNUNET_STATISTICS_Handle *	GSF_stats
	Handle for reporting statistics.
struct GNUNET_DHT_Handle *	GSF_dht
	Handle for DHT operations.
struct GNUNET_LOAD_Value *	GSF_rt_entry_lifetime
	How long do requests typically stay in the routing table?
struct GNUNET_TIME_Relative	GSF_avg_latency = { 500 }
	Running average of the observed latency to other peers (round trip).
double	GSF_current_priorities
	Typical priorities we're seeing from other peers right now.
unsigned int	GSF_datastore_queue_size
	Size of the datastore queue we assume for common requests.
unsigned int	GSF_cover_query_count
	How many query messages have we received 'recently' that have not yet been claimed as cover traffic?
unsigned int	GSF_cover_content_count
	How many content messages have we received 'recently' that have not yet been claimed as cover traffic?
struct GNUNET_BLOCK_Context *	GSF_block_ctx
	Our block context.
struct GNUNET_CORE_Handle *	GSF_core
	Pointer to handle to the core service (points to NULL until we've connected to it).
struct GNUNET_PILS_Handle *	GSF_pils
	Pointer to handle to the pils service (points to NULL until we've connected to it).
int	GSF_enable_randomized_delays
	Are we introducing randomized delays for better anonymity?
struct GNUNET_PeerIdentity	GSF_my_id
	Identity of this peer.
static struct GNUNET_CONFIGURATION_Handle *	block_cfg
	Configuration for block library.
static struct GNUNET_CRYPTO_EddsaPrivateKey	pk
	Private key of this peer.
static struct GNUNET_SCHEDULER_Task *	cover_age_task
	ID of our task that we use to age the cover counters.
static struct GNUNET_LOAD_Value *	datastore_get_load
	Datastore 'GET' load tracking.

Detailed Description

gnunet anonymity protocol implementation

Author

Christian Grothoff

Definition in file gnunet-service-fs.c.

Macro Definition Documentation

FS_DHT_HT_SIZE

#define FS_DHT_HT_SIZE   1024

Size for the hash map for DHT requests from the FS service.

Should be about the number of concurrent DHT requests we plan to make.

Definition at line 52 of file gnunet-service-fs.c.

COVER_AGE_FREQUENCY

#define COVER_AGE_FREQUENCY

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_SECONDS, 5)

How quickly do we age cover traffic? At the given time interval, remaining cover traffic counters are decremented by 1/16th.

Definition at line 60 of file gnunet-service-fs.c.

{
  struct ClientRequest *next;
 
  struct ClientRequest *prev;
 
  struct GSF_PendingRequest *pr;
 
  struct GSF_LocalClient *lc;
 
  struct GNUNET_SCHEDULER_Task *kill_task;
};
 
 
struct ClientResponse
{
  struct ClientResponse *next;
 
  struct ClientResponse *prev;
 
  struct GSF_LocalClient *lc;
 
  size_t msize;
};
 
 
struct IndexStartContext
{
  struct IndexStartContext *next;
 
  struct IndexStartContext *prev;
 
  char *filename;
 
  struct GSF_LocalClient *lc;
 
  struct GNUNET_CRYPTO_FileHashContext *fhc;
 
  struct GNUNET_HashCode file_id;
};
 
 
struct GSF_LocalClient
{
  struct GNUNET_SERVICE_Client *client;
 
  struct GNUNET_MQ_Handle *mq;
 
  struct ClientRequest *cr_head;
 
  struct ClientRequest *cr_tail;
 
  struct IndexStartContext *isc_head;
 
  struct IndexStartContext *isc_tail;
 
  struct ClientResponse *res_head;
 
  struct ClientResponse *res_tail;
};
 
 
/* ****************************** globals ****************************** */
 
struct GNUNET_DATASTORE_Handle *GSF_dsh;
 
const struct GNUNET_CONFIGURATION_Handle *GSF_cfg;
 
struct GNUNET_STATISTICS_Handle *GSF_stats;
 
struct GNUNET_DHT_Handle *GSF_dht;
 
struct GNUNET_LOAD_Value *GSF_rt_entry_lifetime;
 
struct GNUNET_TIME_Relative GSF_avg_latency = { 500 };
 
 
double GSF_current_priorities;
 
unsigned int GSF_datastore_queue_size;
 
unsigned int GSF_cover_query_count;
 
unsigned int GSF_cover_content_count;
 
struct GNUNET_BLOCK_Context *GSF_block_ctx;
 
struct GNUNET_CORE_Handle *GSF_core;
 
struct GNUNET_PILS_Handle *GSF_pils;
 
int GSF_enable_randomized_delays;
 
struct GNUNET_PeerIdentity GSF_my_id;
 
/* ***************************** locals ******************************* */
 
static struct GNUNET_CONFIGURATION_Handle *block_cfg;
 
static struct GNUNET_CRYPTO_EddsaPrivateKey pk;
 
static struct GNUNET_SCHEDULER_Task *cover_age_task;
 
static struct GNUNET_LOAD_Value *datastore_get_load;
 
 
static void *
client_connect_cb (void *cls,
                   struct GNUNET_SERVICE_Client *client,
                   struct GNUNET_MQ_Handle *mq)
{
  struct GSF_LocalClient *pos;
 
  pos = GNUNET_new (struct GSF_LocalClient);
  pos->client = client;
  pos->mq = mq;
  return pos;
}
 
 
static void
client_request_destroy (void *cls)
{
  struct ClientRequest *cr = cls;
  struct GSF_LocalClient *lc = cr->lc;
 
  cr->kill_task = NULL;
  GNUNET_CONTAINER_DLL_remove (lc->cr_head,
                               lc->cr_tail,
                               cr);
  GSF_pending_request_cancel_ (cr->pr,
                               GNUNET_YES);
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# client searches active"),
                            -1,
                            GNUNET_NO);
  GNUNET_free (cr);
}
 
 
static void
client_response_handler (void *cls,
                         enum GNUNET_BLOCK_ReplyEvaluationResult eval,
                         struct GSF_PendingRequest *pr,
                         uint32_t reply_anonymity_level,
                         struct GNUNET_TIME_Absolute expiration,
                         struct GNUNET_TIME_Absolute last_transmission,
                         enum GNUNET_BLOCK_Type type,
                         const void *data,
                         size_t data_len)
{
  struct ClientRequest *cr = cls;
  struct GSF_LocalClient *lc;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPutMessage *pm;
  const struct GSF_PendingRequestData *prd;
 
  if (NULL == data)
  {
    /* local-only request, with no result, clean up. */
    if (NULL == cr->kill_task)
      cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
                                                cr);
    return;
  }
  prd = GSF_pending_request_get_data_ (pr);
  GNUNET_break (type != GNUNET_BLOCK_TYPE_ANY);
  if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop
                              ("# replies received for local clients"), 1,
                            GNUNET_NO);
  GNUNET_assert (pr == cr->pr);
  lc = cr->lc;
  env = GNUNET_MQ_msg_extra (pm,
                             data_len,
                             GNUNET_MESSAGE_TYPE_FS_PUT);
  pm->type = htonl (type);
  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
  pm->last_transmission = GNUNET_TIME_absolute_hton (last_transmission);
  pm->num_transmissions = htonl (prd->num_transmissions);
  pm->respect_offered = htonl (prd->respect_offered);
  GNUNET_memcpy (&pm[1],
                 data,
                 data_len);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Queued reply to query `%s' for local client\n",
              GNUNET_h2s (&prd->query));
  if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Evaluation %d - keeping query alive\n",
                (int) eval);
    return;
  }
  if (NULL == cr->kill_task)
    cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
                                              cr);
}
 
 
static void
client_disconnect_cb (void *cls,
                      struct GNUNET_SERVICE_Client *client,
                      void *app_ctx)
{
  struct GSF_LocalClient *lc = app_ctx;
  struct IndexStartContext *isc;
  struct ClientRequest *cr;
  struct ClientResponse *res;
 
  while (NULL != (cr = lc->cr_head))
  {
    if (NULL != cr->kill_task)
      GNUNET_SCHEDULER_cancel (cr->kill_task);
    client_request_destroy (cr);
  }
  while (NULL != (res = lc->res_head))
  {
    GNUNET_CONTAINER_DLL_remove (lc->res_head,
                                 lc->res_tail,
                                 res);
    GNUNET_free (res);
  }
  while (NULL != (isc = lc->isc_head))
  {
    GNUNET_CONTAINER_DLL_remove (lc->isc_head,
                                 lc->isc_tail,
                                 isc);
    GNUNET_CRYPTO_hash_file_cancel (isc->fhc);
    GNUNET_free (isc);
  }
  GNUNET_free (lc);
}
 
 
static void
age_cover_counters (void *cls)
{
  GSF_cover_content_count = (GSF_cover_content_count * 15) / 16;
  GSF_cover_query_count = (GSF_cover_query_count * 15) / 16;
  cover_age_task =
    GNUNET_SCHEDULER_add_delayed (COVER_AGE_FREQUENCY,
                                  &age_cover_counters,
                                  NULL);
}
 
 
void
GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start)
{
  struct GNUNET_TIME_Relative delay;
 
  delay = GNUNET_TIME_absolute_get_duration (start);
  GNUNET_LOAD_update (datastore_get_load, delay.rel_value_us);
}
 
 
int
GSF_test_get_load_too_high_ (uint32_t priority)
{
  double ld;
 
  ld = GNUNET_LOAD_get_load (datastore_get_load);
  if (ld < 1)
    return GNUNET_SYSERR;
  if (ld <= priority)
    return GNUNET_NO;
  return GNUNET_YES;
}
 
 
static int
check_p2p_put (void *cls,
               const struct PutMessage *put)
{
  enum GNUNET_BLOCK_Type type;
 
  type = ntohl (put->type);
  if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
consider_request_for_forwarding (void *cls,
                                 const struct GNUNET_PeerIdentity *peer,
                                 struct GSF_ConnectedPeer *cp,
                                 const struct GSF_PeerPerformanceData *ppd)
{
  struct GSF_PendingRequest *pr = cls;
 
  if (GNUNET_YES !=
      GSF_pending_request_test_target_ (pr, peer))
  {
#if INSANE_STATISTICS
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop ("# Loopback routes suppressed"), 1,
                              GNUNET_NO);
#endif
    return;
  }
  GSF_plan_add_ (cp,
                 pr);
}
 
 
void
GSF_consider_forwarding (void *cls,
                         struct GSF_PendingRequest *pr,
                         enum GNUNET_BLOCK_ReplyEvaluationResult result)
{
  if (GNUNET_BLOCK_REPLY_OK_LAST == result)
    return;                     /* we're done... */
  if (GNUNET_YES !=
      GSF_pending_request_test_active_ (pr))
    return; /* request is not actually active, skip! */
  GSF_iterate_connected_peers_ (&consider_request_for_forwarding,
                                pr);
}
 
 
static int
check_p2p_get (void *cls,
               const struct GetMessage *gm)
{
  size_t msize;
  unsigned int bm;
  unsigned int bits;
  size_t bfsize;
 
  msize = ntohs (gm->header.size);
  bm = ntohl (gm->hash_bitmap);
  bits = 0;
  while (bm > 0)
  {
    if (1 == (bm & 1))
      bits++;
    bm >>= 1;
  }
  if (msize < sizeof(struct GetMessage) + bits * sizeof(struct
                                                        GNUNET_PeerIdentity))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
                                                             GNUNET_PeerIdentity);
  /* bfsize must be power of 2, check! */
  if (0 != ((bfsize - 1) & bfsize))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
start_p2p_processing (void *cls,
                      struct GSF_PendingRequest *pr,
                      enum GNUNET_BLOCK_ReplyEvaluationResult result)
{
  struct GSF_LocalClient *lc = cls;
  struct GSF_PendingRequestData *prd;
 
  GNUNET_SERVICE_client_continue (lc->client);
  if (GNUNET_BLOCK_REPLY_OK_LAST == result)
    return;                     /* we're done, 'pr' was already destroyed... */
  prd = GSF_pending_request_get_data_ (pr);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Finished database lookup for local request `%s' with result %d\n",
              GNUNET_h2s (&prd->query),
              result);
  if (0 == prd->anonymity_level)
  {
    switch (prd->type)
    {
    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
      /* the above block types MAY be available via 'cadet' */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Considering cadet-based download for block\n");
      GSF_cadet_lookup_ (pr);
      break;
 
    case GNUNET_BLOCK_TYPE_FS_UBLOCK:
      /* the above block types are in the DHT */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Considering DHT-based search for block\n");
      GSF_dht_lookup_ (pr);
      break;
 
    default:
      GNUNET_break (0);
      break;
    }
  }
  GSF_consider_forwarding (NULL,
                           pr,
                           result);
}
 
 
static int
check_client_start_search (void *cls,
                           const struct SearchMessage *sm)
{
  uint16_t msize;
 
  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
  if (0 != msize % sizeof(struct GNUNET_HashCode))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}
 
 
static void
handle_client_start_search (void *cls,
                            const struct SearchMessage *sm)
{
  static struct GNUNET_PeerIdentity all_zeros;
  struct GSF_LocalClient *lc = cls;
  struct ClientRequest *cr;
  struct GSF_PendingRequestData *prd;
  uint16_t msize;
  unsigned int sc;
  enum GNUNET_BLOCK_Type type;
  enum GSF_PendingRequestOptions options;
 
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# client searches received"),
                            1,
                            GNUNET_NO);
  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
  sc = msize / sizeof(struct GNUNET_HashCode);
  type = ntohl (sm->type);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received request for `%s' of type %u from local client\n",
              GNUNET_h2s (&sm->query),
              (unsigned int) type);
  cr = NULL;
  /* detect duplicate UBLOCK requests */
  if ((type == GNUNET_BLOCK_TYPE_FS_UBLOCK) ||
      (type == GNUNET_BLOCK_TYPE_ANY))
  {
    cr = lc->cr_head;
    while (NULL != cr)
    {
      prd = GSF_pending_request_get_data_ (cr->pr);
      /* only unify with queries that hae not yet started local processing
         (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
         matching query and type */
      if ((GNUNET_YES != prd->has_started) &&
          (0 != memcmp (&prd->query,
                        &sm->query,
                        sizeof(struct GNUNET_HashCode))) &&
          (prd->type == type))
        break;
      cr = cr->next;
    }
  }
  if (NULL != cr)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Have existing request, merging content-seen lists.\n");
    GSF_pending_request_update_ (cr->pr,
                                 (const struct GNUNET_HashCode *) &sm[1],
                                 sc);
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop (
                                "# client searches updated (merged content seen list)"),
                              1,
                              GNUNET_NO);
  }
  else
  {
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop ("# client searches active"),
                              1,
                              GNUNET_NO);
    cr = GNUNET_new (struct ClientRequest);
    cr->lc = lc;
    GNUNET_CONTAINER_DLL_insert (lc->cr_head,
                                 lc->cr_tail,
                                 cr);
    options = GSF_PRO_LOCAL_REQUEST;
    if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
      options |= GSF_PRO_LOCAL_ONLY;
    cr->pr = GSF_pending_request_create_ (options, type,
                                          &sm->query,
                                          (0 !=
                                           memcmp (&sm->target,
                                                   &all_zeros,
                                                   sizeof(struct
                                                          GNUNET_PeerIdentity)))
                                          ? &sm->target : NULL, NULL,
                                          0 /* bf */,
                                          ntohl (sm->anonymity_level),
                                          0 /* priority */,
                                          0 /* ttl */,
                                          0 /* sender PID */,
                                          0 /* origin PID */,
                                          (const struct
                                           GNUNET_HashCode *) &sm[1], sc,
                                          &client_response_handler,
                                          cr);
  }
  if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl (sm->options)))
  {
    GNUNET_SERVICE_client_continue (lc->client);
    return;
  }
  GSF_pending_request_get_data_ (cr->pr)->has_started = GNUNET_YES;
  GSF_local_lookup_ (cr->pr,
                     &start_p2p_processing,
                     lc);
}
 
 
static void
handle_client_loc_sign (void *cls,
                        const struct RequestLocSignatureMessage *msg)
{
  struct GSF_LocalClient *lc = cls;
  struct GNUNET_FS_Uri base;
  struct GNUNET_FS_Uri *loc;
  struct GNUNET_MQ_Envelope *env;
  struct ResponseLocSignatureMessage *resp;
 
  GNUNET_break (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT ==
                ntohl (msg->purpose));
  base.type = GNUNET_FS_URI_CHK;
  base.data.chk.chk = msg->chk;
  base.data.chk.file_length = GNUNET_ntohll (msg->file_length);
  loc = GNUNET_FS_uri_loc_create (&base,
                                  &pk,
                                  GNUNET_TIME_absolute_ntoh (
                                    msg->expiration_time));
  env = GNUNET_MQ_msg (resp,
                       GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE);
  resp->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
  resp->expiration_time = GNUNET_TIME_absolute_hton (
    loc->data.loc.expirationTime);
  resp->signature = loc->data.loc.contentSignature;
  resp->peer = loc->data.loc.peer;
  GNUNET_FS_uri_destroy (loc);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_SERVICE_client_continue (lc->client);
}
 
 
static int
check_client_index_start (void *cls,
                          const struct IndexStartMessage *ism)
{
  char *fn;
 
  GNUNET_MQ_check_zero_termination (ism);
  if (0 != ism->reserved)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
  if (NULL == fn)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_free (fn);
  return GNUNET_OK;
}
 
 
static void
signal_index_ok (struct IndexStartContext *isc)
{
  struct GSF_LocalClient *lc = isc->lc;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  GNUNET_FS_add_to_index (isc->filename,
                          &isc->file_id);
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_free (isc->filename);
  GNUNET_free (isc);
  GNUNET_SERVICE_client_continue (lc->client);
}
 
 
static void
hash_for_index_val (void *cls,
                    const struct GNUNET_HashCode *res)
{
  struct IndexStartContext *isc = cls;
  struct GSF_LocalClient *lc = isc->lc;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  GNUNET_CONTAINER_DLL_remove (lc->isc_head,
                               lc->isc_tail,
                               isc);
  isc->fhc = NULL;
  if ((NULL == res) ||
      (0 != memcmp (res,
                    &isc->file_id,
                    sizeof(struct GNUNET_HashCode))))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ (
                  "Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
                isc->filename,
                GNUNET_h2s (&isc->file_id));
 
    const char *emsg = "hash mismatch";
    const size_t msize = strlen (emsg) + 1;
 
    env = GNUNET_MQ_msg_extra (msg,
                               msize,
                               GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
    memcpy ((char*) &msg[1], emsg, msize);
    GNUNET_MQ_send (lc->mq,
                    env);
    GNUNET_SERVICE_client_continue (lc->client);
    GNUNET_free (isc);
    return;
  }
  signal_index_ok (isc);
}
 
 
static void
handle_client_index_start (void *cls,
                           const struct IndexStartMessage *ism)
{
  struct GSF_LocalClient *lc = cls;
  struct IndexStartContext *isc;
  char *fn;
  uint64_t dev;
  uint64_t ino;
  uint64_t mydev;
  uint64_t myino;
 
  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
  GNUNET_assert (NULL != fn);
  dev = GNUNET_ntohll (ism->device);
  ino = GNUNET_ntohll (ism->inode);
  isc = GNUNET_new (struct IndexStartContext);
  isc->filename = fn;
  isc->file_id = ism->file_id;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received START_INDEX message for file `%s'\n",
              isc->filename);
  isc->lc = lc;
  mydev = 0;
  myino = 0;
  if (((dev != 0) ||
       (ino != 0)) &&
      (GNUNET_OK == GNUNET_DISK_file_get_identifiers (fn,
                                                      &mydev,
                                                      &myino)) &&
      (dev == mydev) &&
      (ino == myino))
  {
    /* fast validation OK! */
    signal_index_ok (isc);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
              (unsigned long long) ino,
              (unsigned long long) myino,
              (unsigned int) dev,
              (unsigned int) mydev);
  /* slow validation, need to hash full file (again) */
  GNUNET_CONTAINER_DLL_insert (lc->isc_head,
                               lc->isc_tail,
                               isc);
  isc->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                      isc->filename,
                                      HASHING_BLOCKSIZE,
                                      &hash_for_index_val,
                                      isc);
  if (NULL == isc->fhc)
    hash_for_index_val (isc,
                        NULL);
}
 
 
static void
handle_client_index_list_get (void *cls,
                              const struct GNUNET_MessageHeader *message)
{
  struct GSF_LocalClient *lc = cls;
 
  GNUNET_FS_indexing_send_list (lc->mq);
  GNUNET_SERVICE_client_continue (lc->client);
}
 
 
static void
handle_client_unindex (void *cls,
                       const struct UnindexMessage *um)
{
  struct GSF_LocalClient *lc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
  int found;
 
  GNUNET_break (0 == um->reserved);
  found = GNUNET_FS_indexing_do_unindex (&um->file_id);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client requested unindexing of file `%s': %s\n",
              GNUNET_h2s (&um->file_id),
              found ? "found" : "not found");
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_SERVICE_client_continue (lc->client);
}
 
 
static void
shutdown_task (void *cls)
{
  GSF_cadet_stop_server ();
  if (NULL != GSF_pils)
  {
    GNUNET_PILS_disconnect (GSF_pils);
    GSF_pils = NULL;
  }
  if (NULL != GSF_core)
  {
    GNUNET_CORE_disconnect (GSF_core);
    GSF_core = NULL;
  }
  GSF_put_done_ ();
  GSF_push_done_ ();
  GSF_pending_request_done_ ();
  GSF_plan_done ();
  GSF_connected_peer_done_ ();
  GNUNET_DATASTORE_disconnect (GSF_dsh,
                               GNUNET_NO);
  GSF_dsh = NULL;
  GNUNET_DHT_disconnect (GSF_dht);
  GSF_dht = NULL;
  GNUNET_BLOCK_context_destroy (GSF_block_ctx);
  GSF_block_ctx = NULL;
  GNUNET_CONFIGURATION_destroy (block_cfg);
  block_cfg = NULL;
  GNUNET_STATISTICS_destroy (GSF_stats, GNUNET_NO);
  GSF_stats = NULL;
  if (NULL != cover_age_task)
  {
    GNUNET_SCHEDULER_cancel (cover_age_task);
    cover_age_task = NULL;
  }
  GNUNET_FS_indexing_done ();
  GNUNET_LOAD_value_free (datastore_get_load);
  datastore_get_load = NULL;
  GNUNET_LOAD_value_free (GSF_rt_entry_lifetime);
  GSF_rt_entry_lifetime = NULL;
}
 
 
static void
pils_pid_change_cb (void *cls,
                    const struct GNUNET_HELLO_Parser *parser,
                    const struct GNUNET_HashCode *hash)
{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My current identity is `%s'\n",
              GNUNET_i2s_full (&GSF_my_id));
  GSF_my_id = *GNUNET_HELLO_parser_get_id (parser);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My new identity is `%s'\n",
              GNUNET_i2s_full (&GSF_my_id));
}
 
 
static int
main_init (const struct GNUNET_CONFIGURATION_Handle *c)
{
  struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
    GNUNET_MQ_hd_var_size (p2p_get,
                           GNUNET_MESSAGE_TYPE_FS_GET,
                           struct GetMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (p2p_put,
                           GNUNET_MESSAGE_TYPE_FS_PUT,
                           struct PutMessage,
                           NULL),
    GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
                             GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
                             struct MigrationStopMessage,
                             NULL),
    GNUNET_MQ_handler_end ()
  };
  int anon_p2p_off;
  char *keyfile;
  struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_FS,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  /* this option is really only for testcases that need to disable
     _anonymous_ file-sharing for some reason */
  anon_p2p_off = (GNUNET_YES ==
                  GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg,
                                                        "fs",
                                                        "DISABLE_ANON_TRANSFER")
                  );
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (GSF_cfg,
                                               "PEER",
                                               "PRIVATE_KEY",
                                               &keyfile))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ (
                  "FS service is lacking HOSTKEY configuration setting.  Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &pk))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup peer's private key\n");
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (keyfile);
    return GNUNET_SYSERR;
  }
  GNUNET_free (keyfile);
  GNUNET_CRYPTO_eddsa_key_get_public (&pk,
                                      &GSF_my_id.public_key);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "I am peer %s\n",
              GNUNET_i2s (&GSF_my_id));
  GSF_core
    = GNUNET_CORE_connect (GSF_cfg,
                           NULL,
                           NULL,
                           &GSF_peer_connect_handler,
                           &GSF_peer_disconnect_handler,
                           (GNUNET_YES == anon_p2p_off)
                           ? no_p2p_handlers
                           : p2p_handlers,
                           &service_info);
  if (NULL == GSF_core)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "core");
    return GNUNET_SYSERR;
  }
  GSF_pils
    = GNUNET_PILS_connect (GSF_cfg,
                           &pils_pid_change_cb,
                           NULL);
  if (NULL == GSF_core)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "core");
    return GNUNET_SYSERR;
  }
  cover_age_task =
    GNUNET_SCHEDULER_add_delayed (COVER_AGE_FREQUENCY,
                                  &age_cover_counters,
                                  NULL);
  datastore_get_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
  GSF_cadet_start_server ();
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  return GNUNET_OK;
}
 
 
static void
run (void *cls,
     const struct GNUNET_CONFIGURATION_Handle *cfg,
     struct GNUNET_SERVICE_Handle *service)
{
  unsigned long long dqs;
 
  GSF_cfg = cfg;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_size (GSF_cfg,
                                           "fs",
                                           "DATASTORE_QUEUE_SIZE",
                                           &dqs))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
                               "fs",
                               "DATASTORE_QUEUE_SIZE");
    dqs = 32;
  }
  GSF_datastore_queue_size = (unsigned int) dqs;
  GSF_enable_randomized_delays =
    GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
  GSF_dsh = GNUNET_DATASTORE_connect (cfg);
  if (NULL == GSF_dsh)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GSF_rt_entry_lifetime = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_FOREVER_REL);
  GSF_stats = GNUNET_STATISTICS_create ("fs", cfg);
  block_cfg = GNUNET_CONFIGURATION_create (GNUNET_OS_project_data_gnunet ());
  GSF_block_ctx = GNUNET_BLOCK_context_create (block_cfg);
  GNUNET_assert (NULL != GSF_block_ctx);
  GSF_dht = GNUNET_DHT_connect (cfg, FS_DHT_HT_SIZE);
  GSF_plan_init ();
  GSF_pending_request_init_ ();
  GSF_connected_peer_init_ ();
 
  GSF_push_init_ ();
  GSF_put_init_ ();
  if ((GNUNET_OK != GNUNET_FS_indexing_init (cfg,
                                             GSF_dsh)) ||
      (GNUNET_OK != main_init (cfg)))
  {
    GNUNET_SCHEDULER_shutdown ();
    shutdown_task (NULL);
    return;
  }
}
 
 
GNUNET_SERVICE_MAIN
  (GNUNET_OS_project_data_gnunet (),
  "fs",
  GNUNET_SERVICE_OPTION_NONE,
  &run,
  &client_connect_cb,
  &client_disconnect_cb,
  NULL,
  GNUNET_MQ_hd_var_size (client_index_start,
                         GNUNET_MESSAGE_TYPE_FS_INDEX_START,
                         struct IndexStartMessage,
                         NULL),
  GNUNET_MQ_hd_fixed_size (client_index_list_get,
                           GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET,
                           struct GNUNET_MessageHeader,
                           NULL),
  GNUNET_MQ_hd_fixed_size (client_unindex,
                           GNUNET_MESSAGE_TYPE_FS_UNINDEX,
                           struct UnindexMessage,
                           NULL),
  GNUNET_MQ_hd_var_size (client_start_search,
                         GNUNET_MESSAGE_TYPE_FS_START_SEARCH,
                         struct SearchMessage,
                         NULL),
  GNUNET_MQ_hd_fixed_size (client_loc_sign,
                           GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN,
                           struct RequestLocSignatureMessage,
                           NULL),
  GNUNET_MQ_handler_end ());
 
 
/* end of gnunet-service-fs.c */

INSANE_STATISTICS

#define INSANE_STATISTICS   GNUNET_NO

Collect an instance number of statistics? May cause excessive IPC.

Definition at line 66 of file gnunet-service-fs.c.

Function Documentation

client_connect_cb()

static void * client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, struct GNUNET_MQ_Handle *  mq  )

static

Creates a fresh local client handle.

Parameters

cls	NULL
client	handle of the client
mq	message queue for client

Returns

handle to local client entry

Definition at line 339 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *pos;
 
  pos = GNUNET_new (struct GSF_LocalClient);
  pos->client = client;
  pos->mq = mq;
  return pos;
}

References GSF_LocalClient::client, GNUNET_new, mq, and GSF_LocalClient::mq.

client_request_destroy()

static void client_request_destroy ( void *  cls )

static

Free the given client request.

Parameters

cls	the client request to free

Definition at line 358 of file gnunet-service-fs.c.

{
  struct ClientRequest *cr = cls;
  struct GSF_LocalClient *lc = cr->lc;
 
  cr->kill_task = NULL;
  GNUNET_CONTAINER_DLL_remove (lc->cr_head,
                               lc->cr_tail,
                               cr);
  GSF_pending_request_cancel_ (cr->pr,
                               GNUNET_YES);
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# client searches active"),
                            -1,
                            GNUNET_NO);
  GNUNET_free (cr);
}

References GSF_LocalClient::cr_head, GSF_LocalClient::cr_tail, gettext_noop, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GSF_pending_request_cancel_(), GSF_stats, ClientRequest::kill_task, ClientRequest::lc, and ClientRequest::pr.

Referenced by client_disconnect_cb(), and client_response_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

client_response_handler()

static void client_response_handler ( void *  cls, enum GNUNET_BLOCK_ReplyEvaluationResult  eval, struct GSF_PendingRequest *  pr, uint32_t  reply_anonymity_level, struct GNUNET_TIME_Absolute  expiration, struct GNUNET_TIME_Absolute  last_transmission, enum GNUNET_BLOCK_Type  type, const void *  data, size_t  data_len  )

static

Handle a reply to a pending request.

Also called if a request expires (then with data == NULL). The handler may be called many times (depending on the request type), but will not be called during or after a call to #GSF_pending_request_cancel() and will also not be called anymore after a call signalling expiration.

Parameters

cls	user-specified closure
eval	evaluation of the result
pr	handle to the original pending request
reply_anonymity_level	anonymity level for the reply, UINT32_MAX for "unknown"
expiration	when does data expire?
last_transmission	when was the last time we've tried to download this block? (FOREVER if unknown)
type	type of the block
data	response data, NULL on request expiration
data_len	number of bytes in data

Definition at line 396 of file gnunet-service-fs.c.

{
  struct ClientRequest *cr = cls;
  struct GSF_LocalClient *lc;
  struct GNUNET_MQ_Envelope *env;
  struct ClientPutMessage *pm;
  const struct GSF_PendingRequestData *prd;
 
  if (NULL == data)
  {
    /* local-only request, with no result, clean up. */
    if (NULL == cr->kill_task)
      cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
                                                cr);
    return;
  }
  prd = GSF_pending_request_get_data_ (pr);
  GNUNET_break (type != GNUNET_BLOCK_TYPE_ANY);
  if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
  {
    GNUNET_break (0);
    return;
  }
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop
                              ("# replies received for local clients"), 1,
                            GNUNET_NO);
  GNUNET_assert (pr == cr->pr);
  lc = cr->lc;
  env = GNUNET_MQ_msg_extra (pm,
                             data_len,
                             GNUNET_MESSAGE_TYPE_FS_PUT);
  pm->type = htonl (type);
  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
  pm->last_transmission = GNUNET_TIME_absolute_hton (last_transmission);
  pm->num_transmissions = htonl (prd->num_transmissions);
  pm->respect_offered = htonl (prd->respect_offered);
  GNUNET_memcpy (&pm[1],
                 data,
                 data_len);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Queued reply to query `%s' for local client\n",
              GNUNET_h2s (&prd->query));
  if (GNUNET_BLOCK_REPLY_OK_LAST != eval)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Evaluation %d - keeping query alive\n",
                (int) eval);
    return;
  }
  if (NULL == cr->kill_task)
    cr->kill_task = GNUNET_SCHEDULER_add_now (&client_request_destroy,
                                              cr);
}

References client_request_destroy(), data, env, expiration, gettext_noop, GNUNET_assert, GNUNET_BLOCK_REPLY_OK_LAST, GNUNET_BLOCK_TYPE_ANY, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_FS_PUT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GSF_pending_request_get_data_(), GSF_stats, ClientRequest::kill_task, ClientRequest::lc, GSF_LocalClient::mq, GSF_PendingRequestData::num_transmissions, pm, ClientRequest::pr, GSF_PendingRequestData::query, GSF_PendingRequestData::respect_offered, type, and GSF_PendingRequestData::type.

Referenced by handle_client_start_search().

Here is the call graph for this function:

Here is the caller graph for this function:

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_ctx  )

static

A client disconnected from us.

Tear down the local client record.

Parameters

cls	unused
client	handle of the client
app_ctx	the struct GSF_LocalClient

Definition at line 471 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *lc = app_ctx;
  struct IndexStartContext *isc;
  struct ClientRequest *cr;
  struct ClientResponse *res;
 
  while (NULL != (cr = lc->cr_head))
  {
    if (NULL != cr->kill_task)
      GNUNET_SCHEDULER_cancel (cr->kill_task);
    client_request_destroy (cr);
  }
  while (NULL != (res = lc->res_head))
  {
    GNUNET_CONTAINER_DLL_remove (lc->res_head,
                                 lc->res_tail,
                                 res);
    GNUNET_free (res);
  }
  while (NULL != (isc = lc->isc_head))
  {
    GNUNET_CONTAINER_DLL_remove (lc->isc_head,
                                 lc->isc_tail,
                                 isc);
    GNUNET_CRYPTO_hash_file_cancel (isc->fhc);
    GNUNET_free (isc);
  }
  GNUNET_free (lc);
}

References client_request_destroy(), GSF_LocalClient::cr_head, IndexStartContext::fhc, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_hash_file_cancel(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GSF_LocalClient::isc_head, GSF_LocalClient::isc_tail, ClientRequest::kill_task, ClientResponse::lc, res, GSF_LocalClient::res_head, and GSF_LocalClient::res_tail.

Here is the call graph for this function:

age_cover_counters()

static void age_cover_counters ( void *  cls )

static

Task that periodically ages our cover traffic statistics.

Parameters

cls	unused closure

Definition at line 511 of file gnunet-service-fs.c.

{
  GSF_cover_content_count = (GSF_cover_content_count * 15) / 16;
  GSF_cover_query_count = (GSF_cover_query_count * 15) / 16;
  cover_age_task =
    GNUNET_SCHEDULER_add_delayed (COVER_AGE_FREQUENCY,
                                  &age_cover_counters,
                                  NULL);
}

References age_cover_counters(), COVER_AGE_FREQUENCY, cover_age_task, GNUNET_SCHEDULER_add_delayed(), GSF_cover_content_count, and GSF_cover_query_count.

Referenced by age_cover_counters(), and main_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_update_datastore_delay_()

void GSF_update_datastore_delay_

(

struct GNUNET_TIME_Absolute

start

)

We've just now completed a datastore request.

Update our datastore load calculations.

Parameters

start

time when the datastore request was issued

Definition at line 529 of file gnunet-service-fs.c.

{
  struct GNUNET_TIME_Relative delay;
 
  delay = GNUNET_TIME_absolute_get_duration (start);
  GNUNET_LOAD_update (datastore_get_load, delay.rel_value_us);
}

References datastore_get_load, GNUNET_LOAD_update(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_Relative::rel_value_us, and start.

Referenced by process_local_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_test_get_load_too_high_()

int GSF_test_get_load_too_high_

(

uint32_t

priority

)

Test if the DATABASE (GET) load on this peer is too high to even consider processing the query at all.

Parameters

priority

priority of the request (used as a reference point to compare with the load)

Returns

GNUNET_YES if the load is too high to do anything (load high) GNUNET_NO to process normally (load normal) GNUNET_SYSERR to process for free (load low)

Definition at line 549 of file gnunet-service-fs.c.

{
  double ld;
 
  ld = GNUNET_LOAD_get_load (datastore_get_load);
  if (ld < 1)
    return GNUNET_SYSERR;
  if (ld <= priority)
    return GNUNET_NO;
  return GNUNET_YES;
}

References datastore_get_load, GNUNET_LOAD_get_load(), GNUNET_NO, GNUNET_SYSERR, and GNUNET_YES.

Referenced by bound_priority(), and process_local_reply().

Here is the call graph for this function:

Here is the caller graph for this function:

check_p2p_put()

static int check_p2p_put ( void *  cls, const struct PutMessage *  put  )

static

Check P2P "PUT" message.

Parameters

cls	closure with the struct GSF_ConnectedPeer
put	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 571 of file gnunet-service-fs.c.

{
  enum GNUNET_BLOCK_Type type;
 
  type = ntohl (put->type);
  if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_BLOCK_TYPE_FS_ONDEMAND, GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, type, and PutMessage::type.

consider_request_for_forwarding()

static void consider_request_for_forwarding ( void *  cls, const struct GNUNET_PeerIdentity *  peer, struct GSF_ConnectedPeer *  cp, const struct GSF_PeerPerformanceData *  ppd  )

static

We have a new request, consider forwarding it to the given peer.

Parameters

cls	the struct GSF_PendingRequest
peer	identity of the peer
cp	handle to the connected peer record
ppd	peer performance data

Definition at line 596 of file gnunet-service-fs.c.

{
  struct GSF_PendingRequest *pr = cls;
 
  if (GNUNET_YES !=
      GSF_pending_request_test_target_ (pr, peer))
  {
#if INSANE_STATISTICS
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop ("# Loopback routes suppressed"), 1,
                              GNUNET_NO);
#endif
    return;
  }
  GSF_plan_add_ (cp,
                 pr);
}

References gettext_noop, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GSF_pending_request_test_target_(), GSF_plan_add_(), and GSF_stats.

Referenced by GSF_consider_forwarding().

Here is the call graph for this function:

Here is the caller graph for this function:

GSF_consider_forwarding()

void GSF_consider_forwarding	(	void *	cls,
		struct GSF_PendingRequest *	pr,
		enum GNUNET_BLOCK_ReplyEvaluationResult	result
	)

Function to be called after we're done processing replies from the local lookup.

If the result status code indicates that there may be more replies, plan forwarding the request.

Parameters

cls	closure (NULL)
pr	the pending request we were processing
result	final datastore lookup result

Definition at line 629 of file gnunet-service-fs.c.

{
  if (GNUNET_BLOCK_REPLY_OK_LAST == result)
    return;                     /* we're done... */
  if (GNUNET_YES !=
      GSF_pending_request_test_active_ (pr))
    return; /* request is not actually active, skip! */
  GSF_iterate_connected_peers_ (&consider_request_for_forwarding,
                                pr);
}

References consider_request_for_forwarding(), GNUNET_BLOCK_REPLY_OK_LAST, GNUNET_YES, GSF_iterate_connected_peers_(), GSF_pending_request_test_active_(), and result.

Referenced by handle_p2p_get(), and start_p2p_processing().

Here is the call graph for this function:

Here is the caller graph for this function:

check_p2p_get()

static int check_p2p_get ( void *  cls, const struct GetMessage *  gm  )

static

Check P2P "GET" request.

Parameters

cls	closure
gm	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 652 of file gnunet-service-fs.c.

{
  size_t msize;
  unsigned int bm;
  unsigned int bits;
  size_t bfsize;
 
  msize = ntohs (gm->header.size);
  bm = ntohl (gm->hash_bitmap);
  bits = 0;
  while (bm > 0)
  {
    if (1 == (bm & 1))
      bits++;
    bm >>= 1;
  }
  if (msize < sizeof(struct GetMessage) + bits * sizeof(struct
                                                        GNUNET_PeerIdentity))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
                                                             GNUNET_PeerIdentity);
  /* bfsize must be power of 2, check! */
  if (0 != ((bfsize - 1) & bfsize))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break_op, GNUNET_OK, GNUNET_SYSERR, GetMessage::hash_bitmap, GetMessage::header, and GNUNET_MessageHeader::size.

start_p2p_processing()

static void start_p2p_processing ( void *  cls, struct GSF_PendingRequest *  pr, enum GNUNET_BLOCK_ReplyEvaluationResult  result  )

static

We're done with the local lookup, now consider P2P processing (depending on request options and result status).

Also signal that we can now receive more request information from the client.

Parameters

cls	the client doing the request (struct GSF_LocalClient)
pr	the pending request we were processing
result	final datastore lookup result

Definition at line 698 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *lc = cls;
  struct GSF_PendingRequestData *prd;
 
  GNUNET_SERVICE_client_continue (lc->client);
  if (GNUNET_BLOCK_REPLY_OK_LAST == result)
    return;                     /* we're done, 'pr' was already destroyed... */
  prd = GSF_pending_request_get_data_ (pr);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Finished database lookup for local request `%s' with result %d\n",
              GNUNET_h2s (&prd->query),
              result);
  if (0 == prd->anonymity_level)
  {
    switch (prd->type)
    {
    case GNUNET_BLOCK_TYPE_FS_DBLOCK:
    case GNUNET_BLOCK_TYPE_FS_IBLOCK:
      /* the above block types MAY be available via 'cadet' */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Considering cadet-based download for block\n");
      GSF_cadet_lookup_ (pr);
      break;
 
    case GNUNET_BLOCK_TYPE_FS_UBLOCK:
      /* the above block types are in the DHT */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Considering DHT-based search for block\n");
      GSF_dht_lookup_ (pr);
      break;
 
    default:
      GNUNET_break (0);
      break;
    }
  }
  GSF_consider_forwarding (NULL,
                           pr,
                           result);
}

References GSF_PendingRequestData::anonymity_level, GSF_LocalClient::client, GNUNET_BLOCK_REPLY_OK_LAST, GNUNET_BLOCK_TYPE_FS_DBLOCK, GNUNET_BLOCK_TYPE_FS_IBLOCK, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_SERVICE_client_continue(), GSF_cadet_lookup_(), GSF_consider_forwarding(), GSF_dht_lookup_(), GSF_pending_request_get_data_(), GSF_PendingRequestData::query, result, and GSF_PendingRequestData::type.

Referenced by handle_client_start_search().

Here is the call graph for this function:

Here is the caller graph for this function:

check_client_start_search()

static int check_client_start_search ( void *  cls, const struct SearchMessage *  sm  )

static

Check GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).

Parameters

cls	identification of the client
sm	the actual message

Returns

GNUNET_OK if sm is well-formed

Definition at line 752 of file gnunet-service-fs.c.

{
  uint16_t msize;
 
  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
  if (0 != msize % sizeof(struct GNUNET_HashCode))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_OK, GNUNET_SYSERR, SearchMessage::header, and GNUNET_MessageHeader::size.

handle_client_start_search()

static void handle_client_start_search ( void *  cls, const struct SearchMessage *  sm  )

static

Handle GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client).

Responsible for creating the request entry itself and setting up reply callback and cancellation on client disconnect.

Parameters

cls	identification of the client
sm	the actual message

Definition at line 778 of file gnunet-service-fs.c.

{
  static struct GNUNET_PeerIdentity all_zeros;
  struct GSF_LocalClient *lc = cls;
  struct ClientRequest *cr;
  struct GSF_PendingRequestData *prd;
  uint16_t msize;
  unsigned int sc;
  enum GNUNET_BLOCK_Type type;
  enum GSF_PendingRequestOptions options;
 
  GNUNET_STATISTICS_update (GSF_stats,
                            gettext_noop ("# client searches received"),
                            1,
                            GNUNET_NO);
  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
  sc = msize / sizeof(struct GNUNET_HashCode);
  type = ntohl (sm->type);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received request for `%s' of type %u from local client\n",
              GNUNET_h2s (&sm->query),
              (unsigned int) type);
  cr = NULL;
  /* detect duplicate UBLOCK requests */
  if ((type == GNUNET_BLOCK_TYPE_FS_UBLOCK) ||
      (type == GNUNET_BLOCK_TYPE_ANY))
  {
    cr = lc->cr_head;
    while (NULL != cr)
    {
      prd = GSF_pending_request_get_data_ (cr->pr);
      /* only unify with queries that hae not yet started local processing
         (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
         matching query and type */
      if ((GNUNET_YES != prd->has_started) &&
          (0 != memcmp (&prd->query,
                        &sm->query,
                        sizeof(struct GNUNET_HashCode))) &&
          (prd->type == type))
        break;
      cr = cr->next;
    }
  }
  if (NULL != cr)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Have existing request, merging content-seen lists.\n");
    GSF_pending_request_update_ (cr->pr,
                                 (const struct GNUNET_HashCode *) &sm[1],
                                 sc);
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop (
                                "# client searches updated (merged content seen list)"),
                              1,
                              GNUNET_NO);
  }
  else
  {
    GNUNET_STATISTICS_update (GSF_stats,
                              gettext_noop ("# client searches active"),
                              1,
                              GNUNET_NO);
    cr = GNUNET_new (struct ClientRequest);
    cr->lc = lc;
    GNUNET_CONTAINER_DLL_insert (lc->cr_head,
                                 lc->cr_tail,
                                 cr);
    options = GSF_PRO_LOCAL_REQUEST;
    if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
      options |= GSF_PRO_LOCAL_ONLY;
    cr->pr = GSF_pending_request_create_ (options, type,
                                          &sm->query,
                                          (0 !=
                                           memcmp (&sm->target,
                                                   &all_zeros,
                                                   sizeof(struct
                                                          GNUNET_PeerIdentity)))
                                          ? &sm->target : NULL, NULL,
                                          0 /* bf */,
                                          ntohl (sm->anonymity_level),
                                          0 /* priority */,
                                          0 /* ttl */,
                                          0 /* sender PID */,
                                          0 /* origin PID */,
                                          (const struct
                                           GNUNET_HashCode *) &sm[1], sc,
                                          &client_response_handler,
                                          cr);
  }
  if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl (sm->options)))
  {
    GNUNET_SERVICE_client_continue (lc->client);
    return;
  }
  GSF_pending_request_get_data_ (cr->pr)->has_started = GNUNET_YES;
  GSF_local_lookup_ (cr->pr,
                     &start_p2p_processing,
                     lc);
}

References SearchMessage::anonymity_level, GSF_LocalClient::client, client_response_handler(), GSF_LocalClient::cr_head, GSF_LocalClient::cr_tail, gettext_noop, GNUNET_BLOCK_TYPE_ANY, GNUNET_BLOCK_TYPE_FS_UBLOCK, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_YES, GSF_local_lookup_(), GSF_pending_request_create_(), GSF_pending_request_get_data_(), GSF_pending_request_update_(), GSF_PRO_LOCAL_ONLY, GSF_PRO_LOCAL_REQUEST, GSF_stats, GSF_PendingRequestData::has_started, SearchMessage::header, ClientRequest::lc, ClientRequest::next, options, SearchMessage::options, ClientRequest::pr, SearchMessage::query, GSF_PendingRequestData::query, sc, SEARCH_MESSAGE_OPTION_CONTINUED, SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY, GNUNET_MessageHeader::size, start_p2p_processing(), SearchMessage::target, type, SearchMessage::type, and GSF_PendingRequestData::type.

Here is the call graph for this function:

handle_client_loc_sign()

static void handle_client_loc_sign ( void *  cls, const struct RequestLocSignatureMessage *  msg  )

static

Handle request to sign a LOC URI (from client).

Parameters

cls	identification of the client
msg	the actual message

Definition at line 887 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *lc = cls;
  struct GNUNET_FS_Uri base;
  struct GNUNET_FS_Uri *loc;
  struct GNUNET_MQ_Envelope *env;
  struct ResponseLocSignatureMessage *resp;
 
  GNUNET_break (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT ==
                ntohl (msg->purpose));
  base.type = GNUNET_FS_URI_CHK;
  base.data.chk.chk = msg->chk;
  base.data.chk.file_length = GNUNET_ntohll (msg->file_length);
  loc = GNUNET_FS_uri_loc_create (&base,
                                  &pk,
                                  GNUNET_TIME_absolute_ntoh (
                                    msg->expiration_time));
  env = GNUNET_MQ_msg (resp,
                       GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE);
  resp->purpose = htonl (GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT);
  resp->expiration_time = GNUNET_TIME_absolute_hton (
    loc->data.loc.expirationTime);
  resp->signature = loc->data.loc.contentSignature;
  resp->peer = loc->data.loc.peer;
  GNUNET_FS_uri_destroy (loc);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_SERVICE_client_continue (lc->client);
}

References FileIdentifier::chk, GNUNET_FS_Uri::chk, GSF_LocalClient::client, Location::contentSignature, GNUNET_FS_Uri::data, env, ResponseLocSignatureMessage::expiration_time, Location::expirationTime, FileIdentifier::file_length, GNUNET_break, GNUNET_FS_URI_CHK, GNUNET_FS_uri_destroy(), GNUNET_FS_uri_loc_create(), GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_ntohll(), GNUNET_SERVICE_client_continue(), GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT, GNUNET_TIME_absolute_hton(), GNUNET_TIME_absolute_ntoh(), GNUNET_FS_Uri::loc, GSF_LocalClient::mq, msg, ResponseLocSignatureMessage::peer, Location::peer, pk, ResponseLocSignatureMessage::purpose, ResponseLocSignatureMessage::signature, and GNUNET_FS_Uri::type.

Here is the call graph for this function:

check_client_index_start()

static int check_client_index_start ( void *  cls, const struct IndexStartMessage *  ism  )

static

Check INDEX_START-message.

Parameters

cls	identification of the client
ism	the actual message

Returns

GNUNET_OK if ism is well-formed

Definition at line 927 of file gnunet-service-fs.c.

{
  char *fn;
 
  GNUNET_MQ_check_zero_termination (ism);
  if (0 != ism->reserved)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
  if (NULL == fn)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  GNUNET_free (fn);
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_free, GNUNET_MQ_check_zero_termination, GNUNET_OK, GNUNET_STRINGS_filename_expand(), GNUNET_SYSERR, and IndexStartMessage::reserved.

Here is the call graph for this function:

signal_index_ok()

static void signal_index_ok ( struct IndexStartContext *  isc )

static

We've validated the hash of the file we're about to index.

Signal success to the client and update our internal data structures.

Parameters

isc	the data about the index info entry for the request

Definition at line 956 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *lc = isc->lc;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  GNUNET_FS_add_to_index (isc->filename,
                          &isc->file_id);
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_free (isc->filename);
  GNUNET_free (isc);
  GNUNET_SERVICE_client_continue (lc->client);
}

References GSF_LocalClient::client, env, IndexStartContext::file_id, IndexStartContext::filename, GNUNET_free, GNUNET_FS_add_to_index(), GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), IndexStartContext::lc, GSF_LocalClient::mq, and msg.

Referenced by handle_client_index_start(), and hash_for_index_val().

Here is the call graph for this function:

Here is the caller graph for this function:

hash_for_index_val()

static void hash_for_index_val ( void *  cls, const struct GNUNET_HashCode *  res  )

static

Function called once the hash computation over an indexed file has completed.

Parameters

cls	closure, our publishing context
res	resulting hash, NULL on error

Definition at line 982 of file gnunet-service-fs.c.

{
  struct IndexStartContext *isc = cls;
  struct GSF_LocalClient *lc = isc->lc;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
 
  GNUNET_CONTAINER_DLL_remove (lc->isc_head,
                               lc->isc_tail,
                               isc);
  isc->fhc = NULL;
  if ((NULL == res) ||
      (0 != memcmp (res,
                    &isc->file_id,
                    sizeof(struct GNUNET_HashCode))))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ (
                  "Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
                isc->filename,
                GNUNET_h2s (&isc->file_id));
 
    const char *emsg = "hash mismatch";
    const size_t msize = strlen (emsg) + 1;
 
    env = GNUNET_MQ_msg_extra (msg,
                               msize,
                               GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
    memcpy ((char*) &msg[1], emsg, msize);
    GNUNET_MQ_send (lc->mq,
                    env);
    GNUNET_SERVICE_client_continue (lc->client);
    GNUNET_free (isc);
    return;
  }
  signal_index_ok (isc);
}

References _, GSF_LocalClient::client, env, IndexStartContext::fhc, IndexStartContext::file_id, IndexStartContext::filename, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GSF_LocalClient::isc_head, GSF_LocalClient::isc_tail, IndexStartContext::lc, GSF_LocalClient::mq, msg, res, and signal_index_ok().

Referenced by handle_client_index_start().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_index_start()

static void handle_client_index_start ( void *  cls, const struct IndexStartMessage *  ism  )

static

Handle INDEX_START-message.

Parameters

cls	identification of the client
ism	the actual message

Definition at line 1029 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *lc = cls;
  struct IndexStartContext *isc;
  char *fn;
  uint64_t dev;
  uint64_t ino;
  uint64_t mydev;
  uint64_t myino;
 
  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
  GNUNET_assert (NULL != fn);
  dev = GNUNET_ntohll (ism->device);
  ino = GNUNET_ntohll (ism->inode);
  isc = GNUNET_new (struct IndexStartContext);
  isc->filename = fn;
  isc->file_id = ism->file_id;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received START_INDEX message for file `%s'\n",
              isc->filename);
  isc->lc = lc;
  mydev = 0;
  myino = 0;
  if (((dev != 0) ||
       (ino != 0)) &&
      (GNUNET_OK == GNUNET_DISK_file_get_identifiers (fn,
                                                      &mydev,
                                                      &myino)) &&
      (dev == mydev) &&
      (ino == myino))
  {
    /* fast validation OK! */
    signal_index_ok (isc);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
              (unsigned long long) ino,
              (unsigned long long) myino,
              (unsigned int) dev,
              (unsigned int) mydev);
  /* slow validation, need to hash full file (again) */
  GNUNET_CONTAINER_DLL_insert (lc->isc_head,
                               lc->isc_tail,
                               isc);
  isc->fhc = GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                      isc->filename,
                                      HASHING_BLOCKSIZE,
                                      &hash_for_index_val,
                                      isc);
  if (NULL == isc->fhc)
    hash_for_index_val (isc,
                        NULL);
}

References IndexStartMessage::device, IndexStartContext::fhc, IndexStartMessage::file_id, IndexStartContext::file_id, IndexStartContext::filename, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_hash_file(), GNUNET_DISK_file_get_identifiers(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_ntohll(), GNUNET_OK, GNUNET_SCHEDULER_PRIORITY_IDLE, GNUNET_STRINGS_filename_expand(), hash_for_index_val(), HASHING_BLOCKSIZE, IndexStartMessage::inode, GSF_LocalClient::isc_head, GSF_LocalClient::isc_tail, IndexStartContext::lc, and signal_index_ok().

Here is the call graph for this function:

handle_client_index_list_get()

static void handle_client_index_list_get ( void *  cls, const struct GNUNET_MessageHeader *  message  )

static

Handle INDEX_LIST_GET-message.

Parameters

cls	closure
message	the actual message

Definition at line 1093 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *lc = cls;
 
  GNUNET_FS_indexing_send_list (lc->mq);
  GNUNET_SERVICE_client_continue (lc->client);
}

References GSF_LocalClient::client, GNUNET_FS_indexing_send_list(), GNUNET_SERVICE_client_continue(), and GSF_LocalClient::mq.

Here is the call graph for this function:

handle_client_unindex()

static void handle_client_unindex ( void *  cls, const struct UnindexMessage *  um  )

static

Handle UNINDEX-message.

Parameters

cls	identification of the client
um	the actual message

Definition at line 1110 of file gnunet-service-fs.c.

{
  struct GSF_LocalClient *lc = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *msg;
  int found;
 
  GNUNET_break (0 == um->reserved);
  found = GNUNET_FS_indexing_do_unindex (&um->file_id);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client requested unindexing of file `%s': %s\n",
              GNUNET_h2s (&um->file_id),
              found ? "found" : "not found");
  env = GNUNET_MQ_msg (msg,
                       GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK);
  GNUNET_MQ_send (lc->mq,
                  env);
  GNUNET_SERVICE_client_continue (lc->client);
}

References GSF_LocalClient::client, env, UnindexMessage::file_id, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_FS_indexing_do_unindex(), GNUNET_h2s(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GSF_LocalClient::mq, msg, and UnindexMessage::reserved.

Here is the call graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls

unused

Definition at line 1138 of file gnunet-service-fs.c.

{
  GSF_cadet_stop_server ();
  if (NULL != GSF_pils)
  {
    GNUNET_PILS_disconnect (GSF_pils);
    GSF_pils = NULL;
  }
  if (NULL != GSF_core)
  {
    GNUNET_CORE_disconnect (GSF_core);
    GSF_core = NULL;
  }
  GSF_put_done_ ();
  GSF_push_done_ ();
  GSF_pending_request_done_ ();
  GSF_plan_done ();
  GSF_connected_peer_done_ ();
  GNUNET_DATASTORE_disconnect (GSF_dsh,
                               GNUNET_NO);
  GSF_dsh = NULL;
  GNUNET_DHT_disconnect (GSF_dht);
  GSF_dht = NULL;
  GNUNET_BLOCK_context_destroy (GSF_block_ctx);
  GSF_block_ctx = NULL;
  GNUNET_CONFIGURATION_destroy (block_cfg);
  block_cfg = NULL;
  GNUNET_STATISTICS_destroy (GSF_stats, GNUNET_NO);
  GSF_stats = NULL;
  if (NULL != cover_age_task)
  {
    GNUNET_SCHEDULER_cancel (cover_age_task);
    cover_age_task = NULL;
  }
  GNUNET_FS_indexing_done ();
  GNUNET_LOAD_value_free (datastore_get_load);
  datastore_get_load = NULL;
  GNUNET_LOAD_value_free (GSF_rt_entry_lifetime);
  GSF_rt_entry_lifetime = NULL;
}

References block_cfg, cover_age_task, datastore_get_load, GNUNET_BLOCK_context_destroy(), GNUNET_CONFIGURATION_destroy(), GNUNET_CORE_disconnect(), GNUNET_DATASTORE_disconnect(), GNUNET_DHT_disconnect(), GNUNET_FS_indexing_done(), GNUNET_LOAD_value_free, GNUNET_NO, GNUNET_PILS_disconnect(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GSF_block_ctx, GSF_cadet_stop_server(), GSF_connected_peer_done_(), GSF_core, GSF_dht, GSF_dsh, GSF_pending_request_done_(), GSF_pils, GSF_plan_done(), GSF_push_done_(), GSF_put_done_(), GSF_rt_entry_lifetime, and GSF_stats.

Here is the call graph for this function:

pils_pid_change_cb()

static void pils_pid_change_cb ( void *  cls, const struct GNUNET_HELLO_Parser *  parser, const struct GNUNET_HashCode *  hash  )

static

Function called after GNUNET_PILS_connect has succeeded (or failed for good).

Note that the private key of the peer is intentionally not exposed here; if you need it, your process should try to read the private key file directly (which should work if you are authorized...).

Parameters

cls	closure
my_identity	ID of this peer, NULL if we failed
cls	closure given to GNUNET_PILS_connect
parser	the new HELLO from which the PID can be extracted
hash	The hash of addresses the peer id is based on. This hash is also returned by #GNUNET_PILS_feed_address.

Definition at line 1195 of file gnunet-service-fs.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My current identity is `%s'\n",
              GNUNET_i2s_full (&GSF_my_id));
  GSF_my_id = *GNUNET_HELLO_parser_get_id (parser);
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "My new identity is `%s'\n",
              GNUNET_i2s_full (&GSF_my_id));
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_HELLO_parser_get_id(), GNUNET_i2s_full(), GNUNET_log, and GSF_my_id.

Referenced by main_init().

Here is the call graph for this function:

Here is the caller graph for this function:

main_init()

static int main_init ( const struct GNUNET_CONFIGURATION_Handle *  c )

static

Process fs requests.

Parameters

c	configuration to use

Definition at line 1215 of file gnunet-service-fs.c.

{
  struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
    GNUNET_MQ_handler_end ()
  };
  struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
    GNUNET_MQ_hd_var_size (p2p_get,
                           GNUNET_MESSAGE_TYPE_FS_GET,
                           struct GetMessage,
                           NULL),
    GNUNET_MQ_hd_var_size (p2p_put,
                           GNUNET_MESSAGE_TYPE_FS_PUT,
                           struct PutMessage,
                           NULL),
    GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
                             GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP,
                             struct MigrationStopMessage,
                             NULL),
    GNUNET_MQ_handler_end ()
  };
  int anon_p2p_off;
  char *keyfile;
  struct GNUNET_CORE_ServiceInfo service_info = {
    .service = GNUNET_CORE_SERVICE_FS,
    .version = { 1, 0 },
    .version_max = { 1, 0 },
    .version_min = { 1, 0 },
  };
 
  /* this option is really only for testcases that need to disable
     _anonymous_ file-sharing for some reason */
  anon_p2p_off = (GNUNET_YES ==
                  GNUNET_CONFIGURATION_get_value_yesno (GSF_cfg,
                                                        "fs",
                                                        "DISABLE_ANON_TRANSFER")
                  );
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename (GSF_cfg,
                                               "PEER",
                                               "PRIVATE_KEY",
                                               &keyfile))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ (
                  "FS service is lacking HOSTKEY configuration setting.  Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return GNUNET_SYSERR;
  }
  if (GNUNET_SYSERR ==
      GNUNET_CRYPTO_eddsa_key_from_file (keyfile,
                                         GNUNET_YES,
                                         &pk))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to setup peer's private key\n");
    GNUNET_SCHEDULER_shutdown ();
    GNUNET_free (keyfile);
    return GNUNET_SYSERR;
  }
  GNUNET_free (keyfile);
  GNUNET_CRYPTO_eddsa_key_get_public (&pk,
                                      &GSF_my_id.public_key);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "I am peer %s\n",
              GNUNET_i2s (&GSF_my_id));
  GSF_core
    = GNUNET_CORE_connect (GSF_cfg,
                           NULL,
                           NULL,
                           &GSF_peer_connect_handler,
                           &GSF_peer_disconnect_handler,
                           (GNUNET_YES == anon_p2p_off)
                           ? no_p2p_handlers
                           : p2p_handlers,
                           &service_info);
  if (NULL == GSF_core)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "core");
    return GNUNET_SYSERR;
  }
  GSF_pils
    = GNUNET_PILS_connect (GSF_cfg,
                           &pils_pid_change_cb,
                           NULL);
  if (NULL == GSF_core)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to `%s' service.\n"),
                "core");
    return GNUNET_SYSERR;
  }
  cover_age_task =
    GNUNET_SCHEDULER_add_delayed (COVER_AGE_FREQUENCY,
                                  &age_cover_counters,
                                  NULL);
  datastore_get_load = GNUNET_LOAD_value_init (DATASTORE_LOAD_AUTODECLINE);
  GSF_cadet_start_server ();
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
  return GNUNET_OK;
}

References _, age_cover_counters(), COVER_AGE_FREQUENCY, cover_age_task, datastore_get_load, DATASTORE_LOAD_AUTODECLINE, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CORE_connect(), GNUNET_CORE_SERVICE_FS, GNUNET_CRYPTO_eddsa_key_from_file(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_i2s(), GNUNET_LOAD_value_init(), GNUNET_log, GNUNET_MESSAGE_TYPE_FS_GET, GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP, GNUNET_MESSAGE_TYPE_FS_PUT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_OK, GNUNET_PILS_connect(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_YES, GSF_cadet_start_server(), GSF_cfg, GSF_core, GSF_my_id, GSF_peer_connect_handler(), GSF_peer_disconnect_handler(), GSF_pils, pils_pid_change_cb(), pk, GNUNET_PeerIdentity::public_key, GNUNET_CORE_ServiceInfo::service, and shutdown_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_SERVICE_Handle *  service  )

static

Process fs requests.

Parameters

cls	closure
cfg	configuration to use
service	the initialized service

Definition at line 1330 of file gnunet-service-fs.c.

{
  unsigned long long dqs;
 
  GSF_cfg = cfg;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_size (GSF_cfg,
                                           "fs",
                                           "DATASTORE_QUEUE_SIZE",
                                           &dqs))
  {
    GNUNET_log_config_missing (GNUNET_ERROR_TYPE_INFO,
                               "fs",
                               "DATASTORE_QUEUE_SIZE");
    dqs = 32;
  }
  GSF_datastore_queue_size = (unsigned int) dqs;
  GSF_enable_randomized_delays =
    GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
  GSF_dsh = GNUNET_DATASTORE_connect (cfg);
  if (NULL == GSF_dsh)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GSF_rt_entry_lifetime = GNUNET_LOAD_value_init (GNUNET_TIME_UNIT_FOREVER_REL);
  GSF_stats = GNUNET_STATISTICS_create ("fs", cfg);
  block_cfg = GNUNET_CONFIGURATION_create (GNUNET_OS_project_data_gnunet ());
  GSF_block_ctx = GNUNET_BLOCK_context_create (block_cfg);
  GNUNET_assert (NULL != GSF_block_ctx);
  GSF_dht = GNUNET_DHT_connect (cfg, FS_DHT_HT_SIZE);
  GSF_plan_init ();
  GSF_pending_request_init_ ();
  GSF_connected_peer_init_ ();
 
  GSF_push_init_ ();
  GSF_put_init_ ();
  if ((GNUNET_OK != GNUNET_FS_indexing_init (cfg,
                                             GSF_dsh)) ||
      (GNUNET_OK != main_init (cfg)))
  {
    GNUNET_SCHEDULER_shutdown ();
    shutdown_task (NULL);
    return;
  }
}

References block_cfg, cfg, FS_DHT_HT_SIZE, GNUNET_assert, GNUNET_BLOCK_context_create(), GNUNET_CONFIGURATION_create(), GNUNET_CONFIGURATION_get_value_size(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_DATASTORE_connect(), GNUNET_DHT_connect(), GNUNET_ERROR_TYPE_INFO, GNUNET_FS_indexing_init(), GNUNET_LOAD_value_init(), GNUNET_log_config_missing(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_FOREVER_REL, GSF_block_ctx, GSF_cfg, GSF_connected_peer_init_(), GSF_datastore_queue_size, GSF_dht, GSF_dsh, GSF_enable_randomized_delays, GSF_pending_request_init_(), GSF_plan_init(), GSF_push_init_(), GSF_put_init_(), GSF_rt_entry_lifetime, GSF_stats, main_init(), and shutdown_task.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	GNUNET_OS_project_data_gnunet()	,
		"fs"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(client_index_start, GNUNET_MESSAGE_TYPE_FS_INDEX_START, struct IndexStartMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_index_list_get, GNUNET_MESSAGE_TYPE_FS_INDEX_LIST_GET, struct GNUNET_MessageHeader, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_unindex, GNUNET_MESSAGE_TYPE_FS_UNINDEX, struct UnindexMessage, NULL)	,
		GNUNET_MQ_hd_var_size(client_start_search, GNUNET_MESSAGE_TYPE_FS_START_SEARCH, struct SearchMessage, NULL)	,
		GNUNET_MQ_hd_fixed_size(client_loc_sign, GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN, struct RequestLocSignatureMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

GSF_dsh

struct GNUNET_DATASTORE_Handle* GSF_dsh

Our connection to the datastore.

Definition at line 222 of file gnunet-service-fs.c.

Referenced by consider_gathering(), gather_dht_put_blocks(), gather_migration_blocks(), handle_dht_reply(), handle_p2p_put(), handle_request(), process_local_reply(), run(), shutdown_task(), and start_local_query().

GSF_cfg

const struct GNUNET_CONFIGURATION_Handle* GSF_cfg

Our configuration.

Definition at line 227 of file gnunet-service-fs.c.

Referenced by GSF_cadet_start_server(), GSF_connected_peer_init_(), GSF_pending_request_init_(), GSF_push_init_(), main_init(), and run().

GSF_stats

struct GNUNET_STATISTICS_Handle* GSF_stats

Handle for reporting statistics.

Definition at line 232 of file gnunet-service-fs.c.

Referenced by bound_priority(), cadet_reply_proc(), clean_request(), client_request_destroy(), client_response_handler(), connect_cb(), consider_peer_for_forwarding(), consider_request_for_forwarding(), disconnect_cb(), free_pending_request(), get_randomized_delay(), GNUNET_FS_handle_on_demand_block(), GSF_block_peer_migration_(), GSF_local_lookup_(), GSF_peer_connect_handler(), GSF_peer_disconnect_handler(), GSF_pending_request_create_(), GSF_plan_add_(), GSF_plan_notify_peer_disconnect_(), GSF_plan_notify_request_done_(), handle_client_start_search(), handle_datastore_reply(), handle_dht_reply(), handle_p2p_get(), handle_p2p_migration_stop(), handle_p2p_put(), handle_p2p_reply(), handle_reply(), handle_request(), merge_pr(), no_more_local_results(), plan(), process_local_reply(), process_reply(), put_migration_continuation(), run(), schedule_peer_transmission(), shutdown_task(), start_local_query(), test_exist_cb(), and test_put_load_too_high().

GSF_dht

struct GNUNET_DHT_Handle* GSF_dht

Handle for DHT operations.

Definition at line 237 of file gnunet-service-fs.c.

Referenced by GSF_dht_lookup_(), process_dht_put_content(), run(), and shutdown_task().

GSF_rt_entry_lifetime

struct GNUNET_LOAD_Value* GSF_rt_entry_lifetime

How long do requests typically stay in the routing table?

Definition at line 242 of file gnunet-service-fs.c.

Referenced by handle_p2p_get(), process_reply(), run(), and shutdown_task().

GSF_avg_latency

struct GNUNET_TIME_Relative GSF_avg_latency = { 500 }

Running average of the observed latency to other peers (round trip).

Initialized to 5s as the initial default.

Definition at line 248 of file gnunet-service-fs.c.

{ 500 };

Referenced by get_randomized_delay().

GSF_current_priorities

double GSF_current_priorities

Typical priorities we're seeing from other peers right now.

Since most priorities will be zero, this value is the weighted average of non-zero priorities seen "recently". In order to ensure that new values do not dramatically change the ratio, values are first "capped" to a reasonable range (+N of the current value) and then averaged into the existing value by a ratio of 1:N. Hence receiving the largest possible priority can still only raise our "current_priorities" by at most 1.

Definition at line 261 of file gnunet-service-fs.c.

Referenced by bound_priority(), and plan().

GSF_datastore_queue_size

unsigned int GSF_datastore_queue_size

Size of the datastore queue we assume for common requests.

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

Referenced by handle_request(), run(), and start_local_query().

GSF_cover_query_count

unsigned int GSF_cover_query_count

How many query messages have we received 'recently' that have not yet been claimed as cover traffic?

Definition at line 272 of file gnunet-service-fs.c.

Referenced by age_cover_counters(), and handle_p2p_get().

GSF_cover_content_count

unsigned int GSF_cover_content_count

How many content messages have we received 'recently' that have not yet been claimed as cover traffic?

Definition at line 278 of file gnunet-service-fs.c.

Referenced by age_cover_counters(), handle_p2p_put(), and handle_p2p_reply().

GSF_block_ctx

struct GNUNET_BLOCK_Context* GSF_block_ctx

Our block context.

Definition at line 283 of file gnunet-service-fs.c.

Referenced by cadet_reply_proc(), GSF_pending_request_create_(), handle_p2p_put(), handle_reply(), process_local_reply(), process_reply(), refresh_bloomfilter(), run(), and shutdown_task().

GSF_core

struct GNUNET_CORE_Handle* GSF_core

Pointer to handle to the core service (points to NULL until we've connected to it).

Definition at line 289 of file gnunet-service-fs.c.

Referenced by main_init(), and shutdown_task().

GSF_pils

struct GNUNET_PILS_Handle* GSF_pils

Pointer to handle to the pils service (points to NULL until we've connected to it).

Definition at line 295 of file gnunet-service-fs.c.

Referenced by main_init(), and shutdown_task().

GSF_enable_randomized_delays

int GSF_enable_randomized_delays

Are we introducing randomized delays for better anonymity?

Definition at line 300 of file gnunet-service-fs.c.

Referenced by handle_p2p_reply(), and run().

GSF_my_id

struct GNUNET_PeerIdentity GSF_my_id

Identity of this peer.

Definition at line 305 of file gnunet-service-fs.c.

Referenced by GSF_peer_connect_handler(), main_init(), and pils_pid_change_cb().

block_cfg

struct GNUNET_CONFIGURATION_Handle* block_cfg

static

Configuration for block library.

Definition at line 312 of file gnunet-service-fs.c.

Referenced by run(), and shutdown_task().

pk

struct GNUNET_CRYPTO_EddsaPrivateKey pk

static

Private key of this peer.

Used to sign LOC URI requests.

Definition at line 317 of file gnunet-service-fs.c.

Referenced by handle_client_loc_sign(), and main_init().

cover_age_task

struct GNUNET_SCHEDULER_Task* cover_age_task

static

ID of our task that we use to age the cover counters.

Definition at line 322 of file gnunet-service-fs.c.

Referenced by age_cover_counters(), main_init(), and shutdown_task().

datastore_get_load

struct GNUNET_LOAD_Value* datastore_get_load

static

Datastore 'GET' load tracking.

Definition at line 327 of file gnunet-service-fs.c.

Referenced by GSF_test_get_load_too_high_(), GSF_update_datastore_delay_(), main_init(), and shutdown_task().