gnunet-service-fs.c File Reference

gnunet anonymity protocol implementation More...

#include "platform.h"
#include <float.h>
#include "gnunet_constants.h"
#include "gnunet_core_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_datastore_service.h"
#include "gnunet_load_lib.h"
#include "gnunet_peer_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_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. More...
#define	COVER_AGE_FREQUENCY   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. More...
#define	INSANE_STATISTICS   GNUNET_NO
	Collect an instane number of statistics? May cause excessive IPC. More...

Functions
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Creates a fresh local client handle. More...
static void	client_request_destroy (void *cls)
	Free the given client request. More...
static void	client_response_handler (void *cls, enum GNUNET_BLOCK_EvaluationResult 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. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	A client disconnected from us. More...
static void	age_cover_counters (void *cls)
	Task that periodically ages our cover traffic statistics. More...
void	GSF_update_datastore_delay_ (struct GNUNET_TIME_Absolute start)
	We've just now completed a datastore request. More...
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. More...
static void	update_latencies (void *cls, const struct GNUNET_HELLO_Address *address, int active, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO bandwidth_in, const struct GNUNET_ATS_Properties *prop)
	We've received peer performance information. More...
static int	check_p2p_put (void *cls, const struct PutMessage *put)
	Check P2P "PUT" message. More...
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. More...
void	GSF_consider_forwarding (void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
	Function to be called after we're done processing replies from the local lookup. More...
static int	check_p2p_get (void *cls, const struct GetMessage *gm)
	Check P2P "GET" request. More...
static void	start_p2p_processing (void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
	We're done with the local lookup, now consider P2P processing (depending on request options and result status). More...
static int	check_client_start_search (void *cls, const struct SearchMessage *sm)
	Check GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client). More...
static void	handle_client_start_search (void *cls, const struct SearchMessage *sm)
	Handle GNUNET_MESSAGE_TYPE_FS_START_SEARCH-message (search request from client). More...
static void	handle_client_loc_sign (void *cls, const struct RequestLocSignatureMessage *msg)
	Handle request to sign a LOC URI (from client). More...
static int	check_client_index_start (void *cls, const struct IndexStartMessage *ism)
	Check INDEX_START-message. More...
static void	signal_index_ok (struct IndexStartContext *isc)
	We've validated the hash of the file we're about to index. More...
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. More...
static void	handle_client_index_start (void *cls, const struct IndexStartMessage *ism)
	Handle INDEX_START-message. More...
static void	handle_client_index_list_get (void *cls, const struct GNUNET_MessageHeader *message)
	Handle INDEX_LIST_GET-message. More...
static void	handle_client_unindex (void *cls, const struct UnindexMessage *um)
	Handle UNINDEX-message. More...
static void	shutdown_task (void *cls)
	Task run during shutdown. More...
static void	peer_init_handler (void *cls, const struct GNUNET_PeerIdentity *my_identity)
	Function called after GNUNET_CORE_connect has succeeded (or failed for good). More...
static int	main_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Process fs requests. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *service)
	Process fs requests. More...
	GNUNET_SERVICE_MAIN ("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. More...

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

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 54 of file gnunet-service-fs.c.

Referenced by run().

COVER_AGE_FREQUENCY

#define COVER_AGE_FREQUENCY   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 62 of file gnunet-service-fs.c.

Referenced by age_cover_counters(), and main_init().

INSANE_STATISTICS

#define INSANE_STATISTICS   GNUNET_NO

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

Definition at line 67 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 336 of file gnunet-service-fs.c.

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

Referenced by run().

{
  struct GSF_LocalClient *pos;

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

Here is the caller graph for this function:

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 355 of file gnunet-service-fs.c.

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_(), ClientRequest::kill_task, ClientRequest::lc, and ClientRequest::pr.

Referenced by client_disconnect_cb(), and client_response_handler().

{
  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);
}

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_EvaluationResult  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 393 of file gnunet-service-fs.c.

References client_request_destroy(), env, ClientPutMessage::expiration, gettext_noop, GNUNET_assert, GNUNET_BLOCK_EVALUATION_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_(), ClientRequest::kill_task, ClientPutMessage::last_transmission, ClientRequest::lc, GSF_LocalClient::mq, GSF_PendingRequestData::num_transmissions, ClientPutMessage::num_transmissions, pm, ClientRequest::pr, GSF_PendingRequestData::query, GSF_PendingRequestData::respect_offered, ClientPutMessage::respect_offered, GSF_PendingRequestData::type, and ClientPutMessage::type.

Referenced by handle_client_start_search().

{
  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_EVALUATION_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);
}

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 468 of file gnunet-service-fs.c.

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, ClientRequest::lc, res, GSF_LocalClient::res_head, and GSF_LocalClient::res_tail.

Referenced by run().

{
  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);
}

Here is the call graph for this function:

Here is the caller 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.

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

Referenced by main_init().

{
  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);
}

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.

References GNUNET_LOAD_update(), and GNUNET_TIME_absolute_get_duration().

Referenced by process_local_reply().

{
  struct GNUNET_TIME_Relative delay;

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

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.

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

Referenced by bound_priority(), and process_local_reply().

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_latencies()

static void update_latencies ( void *  cls, const struct GNUNET_HELLO_Address *  address, int  active, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_out, struct GNUNET_BANDWIDTH_Value32NBO  bandwidth_in, const struct GNUNET_ATS_Properties *  prop  )

static

We've received peer performance information.

Update our running average for the P2P latency.

Parameters

cls	closure
address	the address
active	is this address in active use
bandwidth_out	assigned outbound bandwidth for the connection
bandwidth_in	assigned inbound bandwidth for the connection
prop	performance data for the address (as far as known)

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

References GNUNET_ATS_Properties::delay, gettext_noop, GNUNET_MIN, GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_YES, GSF_update_peer_latency_(), GNUNET_HELLO_Address::peer, and GNUNET_TIME_Relative::rel_value_us.

Referenced by run().

{
  if (NULL == address)
    {
      /* ATS service temporarily disconnected */
      return;
    }

  if (GNUNET_YES != active)
    return;
  GSF_update_peer_latency_(&address->peer,
                           prop->delay);
  GSF_avg_latency.rel_value_us =
    (GSF_avg_latency.rel_value_us * 31 +
     GNUNET_MIN(5000, prop->delay.rel_value_us)) / 32;
  GNUNET_STATISTICS_set(GSF_stats,
                        gettext_noop("# running average P2P latency (ms)"),
                        GSF_avg_latency.rel_value_us / 1000LL,
                        GNUNET_NO);
}

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
message	the actual message

Returns

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

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

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

{
  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;
}

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 635 of file gnunet-service-fs.c.

References gettext_noop, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_YES, GSF_pending_request_test_target_(), GSF_plan_add_(), and ClientRequest::pr.

Referenced by GSF_consider_forwarding().

{
  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);
}

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_EvaluationResult	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 668 of file gnunet-service-fs.c.

References consider_request_for_forwarding(), GNUNET_BLOCK_EVALUATION_OK_LAST, GNUNET_YES, GSF_iterate_connected_peers_(), and GSF_pending_request_test_active_().

Referenced by handle_p2p_get(), and start_p2p_processing().

{
  if (GNUNET_BLOCK_EVALUATION_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);
}

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 691 of file gnunet-service-fs.c.

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

{
  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;
}

start_p2p_processing()

static void start_p2p_processing ( void *  cls, struct GSF_PendingRequest *  pr, enum GNUNET_BLOCK_EvaluationResult  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 735 of file gnunet-service-fs.c.

References GSF_PendingRequestData::anonymity_level, GSF_LocalClient::client, GNUNET_BLOCK_EVALUATION_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_(), ClientRequest::lc, GSF_PendingRequestData::query, and GSF_PendingRequestData::type.

Referenced by handle_client_start_search().

{
  struct GSF_LocalClient *lc = cls;
  struct GSF_PendingRequestData *prd;

  GNUNET_SERVICE_client_continue(lc->client);
  if (GNUNET_BLOCK_EVALUATION_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);
}

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 789 of file gnunet-service-fs.c.

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

{
  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;
}

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 815 of file gnunet-service-fs.c.

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_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, GSF_PendingRequestData::type, and SearchMessage::type.

{
  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,
                                           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);
}

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 921 of file gnunet-service-fs.c.

References RequestLocSignatureMessage::chk, FileIdentifier::chk, GNUNET_FS_Uri::chk, GSF_LocalClient::client, Location::contentSignature, GNUNET_FS_Uri::data, env, RequestLocSignatureMessage::expiration_time, ResponseLocSignatureMessage::expiration_time, Location::expirationTime, FileIdentifier::file_length, RequestLocSignatureMessage::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(), ClientRequest::lc, GNUNET_FS_Uri::loc, GSF_LocalClient::mq, Location::peer, ResponseLocSignatureMessage::peer, RequestLocSignatureMessage::purpose, ResponseLocSignatureMessage::purpose, ResponseLocSignatureMessage::signature, and GNUNET_FS_Uri::type.

{
  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);
}

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 959 of file gnunet-service-fs.c.

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

{
  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;
}

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 988 of file gnunet-service-fs.c.

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(), ClientRequest::lc, IndexStartContext::lc, GSF_LocalClient::mq, and msg.

Referenced by handle_client_index_start(), and hash_for_index_val().

{
  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);
}

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 1014 of file gnunet-service-fs.c.

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, GNUNET_MQ_send(), GNUNET_SERVICE_client_continue(), GSF_LocalClient::isc_head, GSF_LocalClient::isc_tail, ClientRequest::lc, IndexStartContext::lc, GSF_LocalClient::mq, msg, and signal_index_ok().

Referenced by handle_client_index_start().

{
  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));
      env = GNUNET_MQ_msg(msg,
                          GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED);
      GNUNET_MQ_send(lc->mq,
                     env);
      GNUNET_SERVICE_client_continue(lc->client);
      GNUNET_free(isc);
      return;
    }
  signal_index_ok(isc);
}

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
message	the actual message

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

References IndexStartContext::fhc, IndexStartContext::file_id, IndexStartContext::filename, fn, 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, GSF_LocalClient::isc_head, GSF_LocalClient::isc_tail, ClientRequest::lc, IndexStartContext::lc, and signal_index_ok().

{
  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);
}

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 1118 of file gnunet-service-fs.c.

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

{
  struct GSF_LocalClient *lc = cls;

  GNUNET_FS_indexing_send_list(lc->mq);
  GNUNET_SERVICE_client_continue(lc->client);
}

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
message	the actual message

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

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(), ClientRequest::lc, GSF_LocalClient::mq, msg, and UnindexMessage::reserved.

{
  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);
}

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 1163 of file gnunet-service-fs.c.

References GNUNET_ATS_performance_done(), 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_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), GSF_cadet_stop_server(), GSF_connected_peer_done_(), GSF_pending_request_done_(), GSF_plan_done(), GSF_push_done_(), and GSF_put_done_().

Referenced by main_init(), and run().

{
  GSF_cadet_stop_server();
  if (NULL != GSF_core)
    {
      GNUNET_CORE_disconnect(GSF_core);
      GSF_core = NULL;
    }
  if (NULL != GSF_ats)
    {
      GNUNET_ATS_performance_done(GSF_ats);
      GSF_ats = 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

peer_init_handler()

static void peer_init_handler ( void *  cls, const struct GNUNET_PeerIdentity *  my_identity  )

static

Function called after GNUNET_CORE_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

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

References GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_memcmp, GNUNET_SCHEDULER_shutdown(), and GSF_my_id.

Referenced by main_init().

{
  if (0 != GNUNET_memcmp(&GSF_my_id,
                         my_identity))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "Peer identity mismatch, refusing to start!\n");
      GNUNET_SCHEDULER_shutdown();
    }
}

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 1235 of file gnunet-service-fs.c.

References _, age_cover_counters(), COVER_AGE_FREQUENCY, DATASTORE_LOAD_AUTODECLINE, GNUNET_assert, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CORE_connect(), GNUNET_CRYPTO_eddsa_key_create_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_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_YES, GSF_cadet_start_server(), GSF_my_id, GSF_peer_connect_handler(), GSF_peer_disconnect_handler(), peer_init_handler(), GNUNET_PeerIdentity::public_key, and shutdown_task().

Referenced by run().

{
  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;

  /* 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;
    }
  pk = GNUNET_CRYPTO_eddsa_key_create_from_file(keyfile);
  GNUNET_free(keyfile);
  GNUNET_assert(NULL != pk);
  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,
                          &peer_init_handler,
                          &GSF_peer_connect_handler,
                          &GSF_peer_disconnect_handler,
                          (GNUNET_YES == anon_p2p_off)
                          ? no_p2p_handlers
                          : p2p_handlers);
  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;
}

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 1321 of file gnunet-service-fs.c.

References cfg, client_connect_cb(), client_disconnect_cb(), FS_DHT_HT_SIZE, GNUNET_assert, GNUNET_ATS_performance_init(), 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_MESSAGE_TYPE_FS_INDEX_LIST_GET, GNUNET_MESSAGE_TYPE_FS_INDEX_START, GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGN, GNUNET_MESSAGE_TYPE_FS_START_SEARCH, GNUNET_MESSAGE_TYPE_FS_UNINDEX, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_SERVICE_MAIN(), GNUNET_SERVICE_OPTION_NONE, GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_FOREVER_REL, GSF_connected_peer_init_(), GSF_datastore_queue_size, GSF_enable_randomized_delays, GSF_pending_request_init_(), GSF_plan_init(), GSF_push_init_(), GSF_put_init_(), main_init(), shutdown_task(), and update_latencies().

{
  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();
  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_ats = GNUNET_ATS_performance_init(GSF_cfg,
                                        &update_latencies,
                                        NULL);
  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;
    }
}

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"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.

Referenced by run().

Here is the caller graph for this function:

Variable Documentation

GSF_dsh

struct GNUNET_DATASTORE_Handle* GSF_dsh

Our connection to the datastore.

Definition at line 220 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(), and start_local_query().

GSF_cfg

const struct GNUNET_CONFIGURATION_Handle* GSF_cfg

Our configuration.

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

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

GSF_stats

struct GNUNET_STATISTICS_Handle* GSF_stats

Handle for reporting statistics.

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

Referenced by bound_priority(), cadet_reply_proc(), clean_request(), connect_cb(), consider_peer_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_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(), schedule_peer_transmission(), 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 235 of file gnunet-service-fs.c.

Referenced by GSF_dht_lookup_(), and process_dht_put_content().

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 240 of file gnunet-service-fs.c.

Referenced by handle_p2p_get(), and process_reply().

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 246 of file gnunet-service-fs.c.

Referenced by get_randomized_delay().

GSF_ats

struct GNUNET_ATS_PerformanceHandle* GSF_ats

Handle to ATS service.

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

Referenced by GSF_peer_connect_handler(), retry_reservation(), and schedule_transmission().

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 264 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 269 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 275 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 281 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 286 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(), and refresh_bloomfilter().

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 292 of file gnunet-service-fs.c.

GSF_enable_randomized_delays

int GSF_enable_randomized_delays

Are we introducing randomized delays for better anonymity?

Definition at line 297 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 302 of file gnunet-service-fs.c.

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

block_cfg

struct GNUNET_CONFIGURATION_Handle* block_cfg

static

Configuration for block library.

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

pk

struct GNUNET_CRYPTO_EddsaPrivateKey* pk

static

Private key of this peer.

Used to sign LOC URI requests.

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

Referenced by clean_rsa_pub(), clean_rsa_public_key(), create_hostkeys(), create_keys(), extract_rsa_pub(), extract_rsa_public_key(), GNUNET_JSON_spec_rsa_public_key(), GNUNET_TESTING_peer_configure(), GSC_KX_init(), parse_rsa_public_key(), peer_test_dead(), post_extract_rsa_public_key(), read_service_conf(), run(), and update_counters().

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 319 of file gnunet-service-fs.c.

datastore_get_load

struct GNUNET_LOAD_Value* datastore_get_load

static

Datastore 'GET' load tracking.

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