GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
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
 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_HandleGSF_dsh
 Our connection to the datastore. More...
 
const struct GNUNET_CONFIGURATION_HandleGSF_cfg
 Our configuration. More...
 
struct GNUNET_STATISTICS_HandleGSF_stats
 Handle for reporting statistics. More...
 
struct GNUNET_DHT_HandleGSF_dht
 Handle for DHT operations. More...
 
struct GNUNET_LOAD_ValueGSF_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_PerformanceHandleGSF_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_ContextGSF_block_ctx
 Our block context. More...
 
struct GNUNET_CORE_HandleGSF_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_Handleblock_cfg
 Configuration for block library. More...
 
static struct GNUNET_CRYPTO_EddsaPrivateKeypk
 Private key of this peer. More...
 
static struct GNUNET_SCHEDULER_Taskcover_age_task
 ID of our task that we use to age the cover counters. More...
 
static struct GNUNET_LOAD_Valuedatastore_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
Value:
#define GNUNET_TIME_UNIT_SECONDS
One second.
struct GNUNET_TIME_Relative GNUNET_TIME_relative_multiply(struct GNUNET_TIME_Relative rel, unsigned long long factor)
Multiply relative time by a given factor.
Definition: time.c:442

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 68 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
clsNULL
clienthandle of the client
mqmessage queue for client
Returns
handle to local client entry

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

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

Referenced by run().

343 {
344  struct GSF_LocalClient *pos;
345 
346  pos = GNUNET_new (struct GSF_LocalClient);
347  pos->client = client;
348  pos->mq = mq;
349  return pos;
350 }
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
A local client.
struct GNUNET_MQ_Handle * mq
Definition: 003.c:5
struct GNUNET_SERVICE_Client * client
ID of the client.
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
clsthe client request to free

Definition at line 359 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().

360 {
361  struct ClientRequest *cr = cls;
362  struct GSF_LocalClient *lc = cr->lc;
363 
364  cr->kill_task = NULL;
366  lc->cr_tail,
367  cr);
369  GNUNET_YES);
371  gettext_noop ("# client searches active"),
372  -1,
373  GNUNET_NO);
374  GNUNET_free (cr);
375 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GSF_PendingRequest * pr
Request this entry represents.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_SCHEDULER_Task * kill_task
Task scheduled to destroy the request.
A local client.
struct GSF_LocalClient * lc
Client list this request belongs to.
Doubly-linked list of requests we are performing on behalf of the same client.
struct ClientRequest * cr_head
Head of list of requests performed on behalf of this client right now.
struct ClientRequest * cr_tail
Tail of list of requests performed on behalf of this client right now.
#define GNUNET_YES
Definition: gnunet_common.h:77
void GSF_pending_request_cancel_(struct GSF_PendingRequest *pr, int full_cleanup)
Explicitly cancel a pending request.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
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
clsuser-specified closure
evalevaluation of the result
prhandle to the original pending request
reply_anonymity_levelanonymity level for the reply, UINT32_MAX for "unknown"
expirationwhen does data expire?
last_transmissionwhen was the last time we've tried to download this block? (FOREVER if unknown)
typetype of the block
dataresponse data, NULL on request expiration
data_lennumber of bytes in data

Definition at line 397 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().

406 {
407  struct ClientRequest *cr = cls;
408  struct GSF_LocalClient *lc;
409  struct GNUNET_MQ_Envelope *env;
410  struct ClientPutMessage *pm;
411  const struct GSF_PendingRequestData *prd;
412 
413  if (NULL == data)
414  {
415  /* local-only request, with no result, clean up. */
416  if (NULL == cr->kill_task)
418  cr);
419  return;
420  }
423  if ((prd->type != type) && (prd->type != GNUNET_BLOCK_TYPE_ANY))
424  {
425  GNUNET_break (0);
426  return;
427  }
430  ("# replies received for local clients"), 1,
431  GNUNET_NO);
432  GNUNET_assert (pr == cr->pr);
433  lc = cr->lc;
434  env = GNUNET_MQ_msg_extra (pm,
435  data_len,
437  pm->type = htonl (type);
438  pm->expiration = GNUNET_TIME_absolute_hton (expiration);
439  pm->last_transmission = GNUNET_TIME_absolute_hton (last_transmission);
440  pm->num_transmissions = htonl (prd->num_transmissions);
441  pm->respect_offered = htonl (prd->respect_offered);
442  GNUNET_memcpy (&pm[1],
443  data,
444  data_len);
445  GNUNET_MQ_send (lc->mq,
446  env);
448  "Queued reply to query `%s' for local client\n",
449  GNUNET_h2s (&prd->query));
451  {
453  "Evaluation %d - keeping query alive\n",
454  (int) eval);
455  return;
456  }
457  if (NULL == cr->kill_task)
459  cr);
460 }
Any type of block, used as a wildcard when searching.
uint32_t num_transmissions
Counter for how often this request has been transmitted (estimate, because we might have the same req...
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GSF_PendingRequest * pr
Request this entry represents.
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
struct GNUNET_TIME_AbsoluteNBO last_transmission
When was the last time we&#39;ve tried to download this block? (FOREVER if unknown/not relevant) ...
Definition: fs.h:375
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_SCHEDULER_Task * kill_task
Task scheduled to destroy the request.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_HashCode query
Primary query hash for this request.
A local client.
struct GNUNET_TIME_AbsoluteNBO expiration
When does this result expire?
Definition: fs.h:369
Public data (in the sense of not encapsulated within &#39;gnunet-service-fs_pr&#39;, not in the sense of netw...
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct...
Definition: gnunet_mq_lib.h:52
struct GSF_LocalClient * lc
Client list this request belongs to.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_now(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run as soon as possible.
Definition: scheduler.c:1280
Last possible valid result.
uint32_t respect_offered
How much respect did we (in total) offer for this request so far (estimate, because we might have the...
enum GNUNET_BLOCK_Type type
Type of the requested block.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
uint32_t respect_offered
How much respect did we offer (in total) before getting an answer (estimate).
Definition: fs.h:387
Response from FS service with a result for a previous FS search.
Definition: fs.h:354
uint32_t type
Type of the block (in big endian).
Definition: fs.h:364
Doubly-linked list of requests we are performing on behalf of the same client.
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
#define GNUNET_log(kind,...)
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
static void client_request_destroy(void *cls)
Free the given client request.
uint32_t data
The data value.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
uint32_t num_transmissions
How often did we transmit this query before getting an answer (estimate).
Definition: fs.h:381
static struct GNUNET_TRANSPORT_PluginMonitor * pm
Handle if we are monitoring plugin session activity.
#define gettext_noop(String)
Definition: gettext.h:69
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
clsunused
clienthandle of the client
app_ctxthe struct GSF_LocalClient

Definition at line 472 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().

475 {
476  struct GSF_LocalClient *lc = app_ctx;
477  struct IndexStartContext *isc;
478  struct ClientRequest *cr;
479  struct ClientResponse *res;
480 
481  while (NULL != (cr = lc->cr_head))
482  {
483  if (NULL != cr->kill_task)
486  }
487  while (NULL != (res = lc->res_head))
488  {
490  lc->res_tail,
491  res);
492  GNUNET_free (res);
493  }
494  while (NULL != (isc = lc->isc_head))
495  {
497  lc->isc_tail,
498  isc);
500  GNUNET_free (isc);
501  }
502  GNUNET_free (lc);
503 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
Replies to be transmitted to the client.
struct IndexStartContext * isc_head
This is a doubly linked list.
struct IndexStartContext * isc_tail
This is a doubly linked list.
struct GNUNET_SCHEDULER_Task * kill_task
Task scheduled to destroy the request.
Information we track while handling an index start request from a client.
A local client.
void GNUNET_CRYPTO_hash_file_cancel(struct GNUNET_CRYPTO_FileHashContext *fhc)
Cancel a file hashing operation.
static int res
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
struct ClientResponse * res_tail
Tail of linked list of responses.
Doubly-linked list of requests we are performing on behalf of the same client.
struct ClientResponse * res_head
Head of linked list of responses.
struct ClientRequest * cr_head
Head of list of requests performed on behalf of this client right now.
static void client_request_destroy(void *cls)
Free the given client request.
#define GNUNET_free(ptr)
Wrapper around free.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsunused closure

Definition at line 512 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().

513 {
519  NULL);
520 }
#define COVER_AGE_FREQUENCY
How quickly do we age cover traffic? At the given time interval, remaining cover traffic counters are...
unsigned int GSF_cover_query_count
How many query messages have we received &#39;recently&#39; that have not yet been claimed as cover traffic...
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
static void age_cover_counters(void *cls)
Task that periodically ages our cover traffic statistics.
static struct GNUNET_SCHEDULER_Task * cover_age_task
ID of our task that we use to age the cover counters.
unsigned int GSF_cover_content_count
How many content messages have we received &#39;recently&#39; that have not yet been claimed as cover traffic...
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
starttime when the datastore request was issued

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

References GNUNET_LOAD_update(), and GNUNET_TIME_absolute_get_duration().

Referenced by process_local_reply().

531 {
533 
535  GNUNET_LOAD_update (datastore_get_load, delay.rel_value_us);
536 }
static struct GNUNET_LOAD_Value * datastore_get_load
Datastore &#39;GET&#39; load tracking.
void GNUNET_LOAD_update(struct GNUNET_LOAD_Value *load, uint64_t data)
Update the current load.
Definition: load.c:236
static struct GNUNET_TIME_Relative delay
When should dkg communication start?
struct GNUNET_TIME_Relative GNUNET_TIME_absolute_get_duration(struct GNUNET_TIME_Absolute whence)
Get the duration of an operation as the difference of the current time and the given start time "henc...
Definition: time.c:375
Time for relative time used by GNUnet, in microseconds.
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
prioritypriority 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 550 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().

551 {
552  double ld;
553 
555  if (ld < 1)
556  return GNUNET_SYSERR;
557  if (ld <= priority)
558  return GNUNET_NO;
559  return GNUNET_YES;
560 }
static struct GNUNET_LOAD_Value * datastore_get_load
Datastore &#39;GET&#39; load tracking.
double GNUNET_LOAD_get_load(struct GNUNET_LOAD_Value *load)
Get the current load.
Definition: load.c:200
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define GNUNET_YES
Definition: gnunet_common.h:77
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
clsclosure
addressthe address
activeis this address in active use
bandwidth_outassigned outbound bandwidth for the connection
bandwidth_inassigned inbound bandwidth for the connection
propperformance data for the address (as far as known)

Definition at line 575 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().

581 {
582  if (NULL == address)
583  {
584  /* ATS service temporarily disconnected */
585  return;
586  }
587 
588  if (GNUNET_YES != active)
589  return;
590  GSF_update_peer_latency_ (&address->peer,
591  prop->delay);
594  + GNUNET_MIN (5000, prop->delay.rel_value_us)) / 32;
596  gettext_noop ("# running average P2P latency (ms)"),
597  GSF_avg_latency.rel_value_us / 1000LL,
598  GNUNET_NO);
599 }
uint64_t rel_value_us
The actual value.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GSF_update_peer_latency_(const struct GNUNET_PeerIdentity *id, struct GNUNET_TIME_Relative latency)
Update the latency information kept for the given peer.
#define GNUNET_MIN(a, b)
Definition: gnunet_common.h:80
struct GNUNET_TIME_Relative delay
Delay.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
struct GNUNET_PeerIdentity peer
For which peer is this an address?
struct GNUNET_TIME_Relative GSF_avg_latency
Running average of the observed latency to other peers (round trip).
#define GNUNET_YES
Definition: gnunet_common.h:77
#define gettext_noop(String)
Definition: gettext.h:69
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
clsclosure with the struct GSF_ConnectedPeer
messagethe actual message
Returns
GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

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

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

613 {
614  enum GNUNET_BLOCK_Type type;
615 
616  type = ntohl (put->type);
617  if (GNUNET_BLOCK_TYPE_FS_ONDEMAND == type)
618  {
619  GNUNET_break_op (0);
620  return GNUNET_SYSERR;
621  }
622  return GNUNET_OK;
623 }
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
Type of a block representing a block to be encoded on demand from disk.
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
uint32_t type
Type of the block (in big endian).
Definition: fs.h:338
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model

◆ 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
clsthe struct GSF_PendingRequest
peeridentity of the peer
cphandle to the connected peer record
ppdpeer performance data

Definition at line 636 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().

640 {
641  struct GSF_PendingRequest *pr = cls;
642 
643  if (GNUNET_YES !=
645  {
646 #if INSANE_STATISTICS
648  gettext_noop ("# Loopback routes suppressed"), 1,
649  GNUNET_NO);
650 #endif
651  return;
652  }
653  GSF_plan_add_ (cp,
654  pr);
655 }
void GSF_plan_add_(struct GSF_ConnectedPeer *cp, struct GSF_PendingRequest *pr)
Create a new query plan entry.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
int GSF_pending_request_test_target_(struct GSF_PendingRequest *pr, const struct GNUNET_PeerIdentity *target)
Is the given target a legitimate peer for forwarding the given request?
#define GNUNET_YES
Definition: gnunet_common.h:77
An active request.
#define gettext_noop(String)
Definition: gettext.h:69
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
clsclosure (NULL)
prthe pending request we were processing
resultfinal datastore lookup result

Definition at line 669 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().

672 {
674  return; /* we're done... */
675  if (GNUNET_YES !=
677  return; /* request is not actually active, skip! */
679  pr);
680 }
void GSF_iterate_connected_peers_(GSF_ConnectedPeerIterator it, void *it_cls)
Iterate over all connected peers.
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.
int GSF_pending_request_test_active_(struct GSF_PendingRequest *pr)
Check if the given request is still active.
Last possible valid result.
static int result
Global testing status.
#define GNUNET_YES
Definition: gnunet_common.h:77
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
clsclosure
gmthe actual message
Returns
GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

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

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

694 {
695  size_t msize;
696  unsigned int bm;
697  unsigned int bits;
698  size_t bfsize;
699 
700  msize = ntohs (gm->header.size);
701  bm = ntohl (gm->hash_bitmap);
702  bits = 0;
703  while (bm > 0)
704  {
705  if (1 == (bm & 1))
706  bits++;
707  bm >>= 1;
708  }
709  if (msize < sizeof(struct GetMessage) + bits * sizeof(struct
711  {
712  GNUNET_break_op (0);
713  return GNUNET_SYSERR;
714  }
715  bfsize = msize - sizeof(struct GetMessage) - bits * sizeof(struct
717  /* bfsize must be power of 2, check! */
718  if (0 != ((bfsize - 1) & bfsize))
719  {
720  GNUNET_break_op (0);
721  return GNUNET_SYSERR;
722  }
723  return GNUNET_OK;
724 }
struct GNUNET_MessageHeader header
Type is GNUNET_MESSAGE_TYPE_DATASTORE_GET.
Definition: datastore.h:145
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break_op(cond)
Use this for assertion violations caused by other peers (i.e.
Message to the datastore service asking about specific content.
Definition: datastore.h:140
uint32_t hash_bitmap
Which of the optional hash codes are present at the end of the message? See GET_MESSAGE_BIT_xx consta...
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
The identity of the host (wraps the signing key of the peer).

◆ 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
clsthe client doing the request (struct GSF_LocalClient)
prthe pending request we were processing
resultfinal datastore lookup result

Definition at line 738 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().

741 {
742  struct GSF_LocalClient *lc = cls;
743  struct GSF_PendingRequestData *prd;
744 
747  return; /* we're done, 'pr' was already destroyed... */
750  "Finished database lookup for local request `%s' with result %d\n",
751  GNUNET_h2s (&prd->query),
752  result);
753  if (0 == prd->anonymity_level)
754  {
755  switch (prd->type)
756  {
759  /* the above block types MAY be available via 'cadet' */
761  "Considering cadet-based download for block\n");
762  GSF_cadet_lookup_ (pr);
763  break;
764 
766  /* the above block types are in the DHT */
768  "Considering DHT-based search for block\n");
769  GSF_dht_lookup_ (pr);
770  break;
771 
772  default:
773  GNUNET_break (0);
774  break;
775  }
776  }
778  pr,
779  result);
780 }
uint32_t anonymity_level
Desired anonymity level.
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
struct GNUNET_HashCode query
Primary query hash for this request.
A local client.
Public data (in the sense of not encapsulated within &#39;gnunet-service-fs_pr&#39;, not in the sense of netw...
Inner block in the CHK tree.
Last possible valid result.
static int result
Global testing status.
enum GNUNET_BLOCK_Type type
Type of the requested block.
Type of a block representing any type of search result (universal).
void GSF_cadet_lookup_(struct GSF_PendingRequest *pr)
Consider downloading via cadet (if possible)
void GSF_consider_forwarding(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
Function to be called after we&#39;re done processing replies from the local lookup.
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
void GSF_dht_lookup_(struct GSF_PendingRequest *pr)
Consider looking up the data in the DHT (anonymity-level permitting).
#define GNUNET_log(kind,...)
Data block (leaf) in the CHK tree.
struct GNUNET_SERVICE_Client * client
ID of the client.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
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
clsidentification of the client
smthe actual message
Returns
GNUNET_OK if sm is well-formed

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

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

794 {
795  uint16_t msize;
796 
797  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
798  if (0 != msize % sizeof(struct GNUNET_HashCode))
799  {
800  GNUNET_break (0);
801  return GNUNET_SYSERR;
802  }
803  return GNUNET_OK;
804 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
A 512-bit hashcode.
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_START_SEARCH.
Definition: fs.h:273
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search...
Definition: fs.h:268

◆ 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
clsidentification of the client
smthe actual message

Definition at line 818 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.

820 {
821  static struct GNUNET_PeerIdentity all_zeros;
822  struct GSF_LocalClient *lc = cls;
823  struct ClientRequest *cr;
824  struct GSF_PendingRequestData *prd;
825  uint16_t msize;
826  unsigned int sc;
827  enum GNUNET_BLOCK_Type type;
829 
831  gettext_noop ("# client searches received"),
832  1,
833  GNUNET_NO);
834  msize = ntohs (sm->header.size) - sizeof(struct SearchMessage);
835  sc = msize / sizeof(struct GNUNET_HashCode);
836  type = ntohl (sm->type);
838  "Received request for `%s' of type %u from local client\n",
839  GNUNET_h2s (&sm->query),
840  (unsigned int) type);
841  cr = NULL;
842  /* detect duplicate UBLOCK requests */
843  if ((type == GNUNET_BLOCK_TYPE_FS_UBLOCK) ||
844  (type == GNUNET_BLOCK_TYPE_ANY))
845  {
846  cr = lc->cr_head;
847  while (NULL != cr)
848  {
849  prd = GSF_pending_request_get_data_ (cr->pr);
850  /* only unify with queries that hae not yet started local processing
851  (SEARCH_MESSAGE_OPTION_CONTINUED was always set) and that have a
852  matching query and type */
853  if ((GNUNET_YES != prd->has_started) &&
854  (0 != memcmp (&prd->query,
855  &sm->query,
856  sizeof(struct GNUNET_HashCode))) &&
857  (prd->type == type))
858  break;
859  cr = cr->next;
860  }
861  }
862  if (NULL != cr)
863  {
865  "Have existing request, merging content-seen lists.\n");
867  (const struct GNUNET_HashCode *) &sm[1],
868  sc);
870  gettext_noop (
871  "# client searches updated (merged content seen list)"),
872  1,
873  GNUNET_NO);
874  }
875  else
876  {
878  gettext_noop ("# client searches active"),
879  1,
880  GNUNET_NO);
881  cr = GNUNET_new (struct ClientRequest);
882  cr->lc = lc;
884  lc->cr_tail,
885  cr);
886  options = GSF_PRO_LOCAL_REQUEST;
887  if (0 != (SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY & ntohl (sm->options)))
888  options |= GSF_PRO_LOCAL_ONLY;
889  cr->pr = GSF_pending_request_create_ (options, type,
890  &sm->query,
891  (0 !=
892  memcmp (&sm->target,
893  &all_zeros,
894  sizeof(struct
896  ? &sm->target : NULL, NULL, 0,
897  0 /* bf */,
898  ntohl (sm->anonymity_level),
899  0 /* priority */,
900  0 /* ttl */,
901  0 /* sender PID */,
902  0 /* origin PID */,
903  (const struct
904  GNUNET_HashCode *) &sm[1], sc,
906  cr);
907  }
908  if (0 != (SEARCH_MESSAGE_OPTION_CONTINUED & ntohl (sm->options)))
909  {
911  return;
912  }
914  GSF_local_lookup_ (cr->pr,
916  lc);
917 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
Any type of block, used as a wildcard when searching.
struct GNUNET_GETOPT_CommandLineOption options[]
Definition: 002.c:5
GNUNET_BLOCK_Type
Blocks in the datastore and the datacache must have a unique type.
struct GSF_PendingRequest * pr
Request this entry represents.
uint32_t options
Bitmask with options.
Definition: fs.h:284
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
struct ClientRequest * next
This is a doubly-linked list.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
struct GNUNET_PeerIdentity target
If the request is for a DBLOCK or IBLOCK, this is the identity of the peer that is known to have a re...
Definition: fs.h:306
void GSF_pending_request_update_(struct GSF_PendingRequest *pr, const struct GNUNET_HashCode *replies_seen, unsigned int replies_seen_count)
Update a given pending request with additional replies that have been seen.
struct GNUNET_HashCode query
Primary query hash for this request.
struct GNUNET_HashCode query
Hash of the public key for UBLOCKs; Hash of the CHK-encoded block for DBLOCKS and IBLOCKS...
Definition: fs.h:312
A local client.
Public data (in the sense of not encapsulated within &#39;gnunet-service-fs_pr&#39;, not in the sense of netw...
static void start_p2p_processing(void *cls, struct GSF_PendingRequest *pr, enum GNUNET_BLOCK_EvaluationResult result)
We&#39;re done with the local lookup, now consider P2P processing (depending on request options and resul...
struct GSF_LocalClient * lc
Client list this request belongs to.
void GSF_local_lookup_(struct GSF_PendingRequest *pr, GSF_LocalLookupContinuation cont, void *cont_cls)
Look up the request in the local datastore.
uint32_t type
Type of the content that we&#39;re looking for.
Definition: fs.h:289
enum GNUNET_BLOCK_Type type
Type of the requested block.
Request must only be processed locally.
Type of a block representing any type of search result (universal).
A 512-bit hashcode.
struct GNUNET_MessageHeader header
Message type will be GNUNET_MESSAGE_TYPE_FS_START_SEARCH.
Definition: fs.h:273
static struct GNUNET_FS_SearchContext * sc
Definition: gnunet-search.c:37
static struct GNUNET_PeerIdentity all_zeros
Peer identity that is all zeros, used as a way to indicate "all peers".
Doubly-linked list of requests we are performing on behalf of the same client.
The identity of the host (wraps the signing key of the peer).
struct GSF_PendingRequestData * GSF_pending_request_get_data_(struct GSF_PendingRequest *pr)
Obtain the public data associated with a pending request.
Option mask for typical local requests.
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.
#define GNUNET_log(kind,...)
#define SEARCH_MESSAGE_OPTION_CONTINUED
Request is too large to fit in 64k format.
Definition: fs.h:261
struct ClientRequest * cr_head
Head of list of requests performed on behalf of this client right now.
struct ClientRequest * cr_tail
Tail of list of requests performed on behalf of this client right now.
struct GSF_PendingRequest * GSF_pending_request_create_(enum GSF_PendingRequestOptions options, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *query, const struct GNUNET_PeerIdentity *target, const char *bf_data, size_t bf_size, uint32_t mingle, uint32_t anonymity_level, uint32_t priority, int32_t ttl, GNUNET_PEER_Id sender_pid, GNUNET_PEER_Id origin_pid, const struct GNUNET_HashCode *replies_seen, unsigned int replies_seen_count, GSF_PendingRequestReplyHandler rh, void *rh_cls)
Create a new pending request.
enum GNUNET_TESTBED_UnderlayLinkModelType type
the type of this model
#define GNUNET_YES
Definition: gnunet_common.h:77
struct GNUNET_SERVICE_Client * client
ID of the client.
#define SEARCH_MESSAGE_OPTION_LOOPBACK_ONLY
Only search the local datastore (no network)
Definition: fs.h:253
Message sent from a GNUnet (fs) search activity to the gnunet-service-fs to start a search...
Definition: fs.h:268
uint32_t anonymity_level
Desired anonymity level, big-endian.
Definition: fs.h:294
int has_started
Has this request been started yet (local/p2p operations)? Or are we still constructing it...
GSF_PendingRequestOptions
Options for pending requests (bits to be ORed).
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define gettext_noop(String)
Definition: gettext.h:69
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
clsidentification of the client
msgthe actual message

Definition at line 927 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.

929 {
930  struct GSF_LocalClient *lc = cls;
931  struct GNUNET_FS_Uri base;
932  struct GNUNET_FS_Uri *loc;
933  struct GNUNET_MQ_Envelope *env;
934  struct ResponseLocSignatureMessage *resp;
935 
937  ntohl (msg->purpose));
938  base.type = GNUNET_FS_URI_CHK;
939  base.data.chk.chk = msg->chk;
940  base.data.chk.file_length = GNUNET_ntohll (msg->file_length);
941  loc = GNUNET_FS_uri_loc_create (&base,
942  pk,
944  msg->expiration_time));
945  env = GNUNET_MQ_msg (resp,
949  loc->data.loc.expirationTime);
950  resp->signature = loc->data.loc.contentSignature;
951  resp->peer = loc->data.loc.peer;
952  GNUNET_FS_uri_destroy (loc);
953  GNUNET_MQ_send (lc->mq,
954  env);
956 }
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
struct GNUNET_TIME_Absolute GNUNET_TIME_absolute_ntoh(struct GNUNET_TIME_AbsoluteNBO a)
Convert absolute time from network byte order.
Definition: time.c:673
struct GNUNET_FS_Uri * GNUNET_FS_uri_loc_create(const struct GNUNET_FS_Uri *base_uri, const struct GNUNET_CRYPTO_EddsaPrivateKey *sign_key, struct GNUNET_TIME_Absolute expiration_time)
Construct a location URI (this peer will be used for the location).
Definition: fs_uri.c:879
uint32_t purpose
Requested signature purpose.
Definition: fs.h:85
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
uint64_t file_length
Size of the shared file (to be signed).
Definition: fs.h:100
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs_api.h:121
#define GNUNET_MESSAGE_TYPE_FS_REQUEST_LOC_SIGNATURE
Reply sent by fs service with LOC signature.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
A local client.
#define GNUNET_SIGNATURE_PURPOSE_PEER_PLACEMENT
Signature by which a peer affirms that it is providing a certain bit of content (used in LOCation URI...
struct GNUNET_TIME_AbsoluteNBO expiration_time
Expiration time that was actually used (rounded!).
Definition: fs.h:124
uint32_t purpose
Purpose of the generated signature.
Definition: fs.h:119
void GNUNET_FS_uri_destroy(struct GNUNET_FS_Uri *uri)
Free URI.
Definition: fs_uri.c:678
Content-hash-key (simple file).
Definition: fs_api.h:143
struct GNUNET_PeerIdentity peer
Identity of the peer sharing the file.
Definition: fs.h:134
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_TIME_Absolute expirationTime
Time when this location URI expires.
Definition: fs_api.h:126
struct ContentHashKey chk
Information about the shared file (to be signed).
Definition: fs.h:95
union GNUNET_FS_Uri::@13 data
Message sent from the service with the signed LOC URI.
Definition: fs.h:107
A Universal Resource Identifier (URI), opaque.
Definition: fs_api.h:165
struct GNUNET_CRYPTO_EddsaSignature signature
The requested signature.
Definition: fs.h:129
struct GNUNET_CRYPTO_EddsaSignature contentSignature
Signature over the GNUNET_EC_FileIdentifier, peer identity and expiration time.
Definition: fs_api.h:132
struct GNUNET_TIME_AbsoluteNBO expiration_time
Requested expiration time.
Definition: fs.h:90
struct Location loc
Information needed to retrieve a file including signed location (identity of a peer) of the content...
Definition: fs_api.h:217
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_SERVICE_Client * client
ID of the client.
struct GNUNET_TIME_AbsoluteNBO GNUNET_TIME_absolute_hton(struct GNUNET_TIME_Absolute a)
Convert absolute time to network byte order.
Definition: time.c:657
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
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
clsidentification of the client
ismthe actual message
Returns
GNUNET_OK if ism is well-formed

Definition at line 967 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.

969 {
970  char *fn;
971 
973  if (0 != ism->reserved)
974  {
975  GNUNET_break (0);
976  return GNUNET_SYSERR;
977  }
978  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
979  if (NULL == fn)
980  {
981  GNUNET_break (0);
982  return GNUNET_SYSERR;
983  }
984  GNUNET_free (fn);
985  return GNUNET_OK;
986 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
#define GNUNET_MQ_check_zero_termination(m)
Insert code for a "check_" function that verifies that a given variable-length message received over ...
static char * fn
Filename of the unique file.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:603
uint32_t reserved
For alignment.
Definition: fs.h:161
#define GNUNET_free(ptr)
Wrapper around free.
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
iscthe data about the index info entry for the request

Definition at line 996 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().

997 {
998  struct GSF_LocalClient *lc = isc->lc;
999  struct GNUNET_MQ_Envelope *env;
1000  struct GNUNET_MessageHeader *msg;
1001 
1003  &isc->file_id);
1004  env = GNUNET_MQ_msg (msg,
1006  GNUNET_MQ_send (lc->mq,
1007  env);
1008  GNUNET_free (isc->filename);
1009  GNUNET_free (isc);
1011 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
char * filename
Name of the indexed file.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_OK
Affirmative response to a request for start indexing.
A local client.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_HashCode file_id
Hash of the contents of the file.
struct GSF_LocalClient * lc
Context for transmitting confirmation to client.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_SERVICE_Client * client
ID of the client.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
void GNUNET_FS_add_to_index(const char *filename, const struct GNUNET_HashCode *file_id)
Add the given file to the list of indexed files.
#define GNUNET_free(ptr)
Wrapper around free.
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
clsclosure, our publishing context
resresulting hash, NULL on error

Definition at line 1022 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().

1024 {
1025  struct IndexStartContext *isc = cls;
1026  struct GSF_LocalClient *lc = isc->lc;
1027  struct GNUNET_MQ_Envelope *env;
1028  struct GNUNET_MessageHeader *msg;
1029 
1031  lc->isc_tail,
1032  isc);
1033  isc->fhc = NULL;
1034  if ((NULL == res) ||
1035  (0 != memcmp (res,
1036  &isc->file_id,
1037  sizeof(struct GNUNET_HashCode))))
1038  {
1040  _ (
1041  "Hash mismatch trying to index file `%s' which does not have hash `%s'\n"),
1042  isc->filename,
1043  GNUNET_h2s (&isc->file_id));
1044  env = GNUNET_MQ_msg (msg,
1046  GNUNET_MQ_send (lc->mq,
1047  env);
1049  GNUNET_free (isc);
1050  return;
1051  }
1052  signal_index_ok (isc);
1053 }
#define GNUNET_CONTAINER_DLL_remove(head, tail, element)
Remove an element from a DLL.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
struct IndexStartContext * isc_head
This is a doubly linked list.
#define GNUNET_MESSAGE_TYPE_FS_INDEX_START_FAILED
Response to a request for start indexing that refuses.
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
char * filename
Name of the indexed file.
struct IndexStartContext * isc_tail
This is a doubly linked list.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
Information we track while handling an index start request from a client.
A local client.
A 512-bit hashcode.
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
struct GNUNET_HashCode file_id
Hash of the contents of the file.
#define GNUNET_log(kind,...)
struct GSF_LocalClient * lc
Context for transmitting confirmation to client.
static void signal_index_ok(struct IndexStartContext *isc)
We&#39;ve validated the hash of the file we&#39;re about to index.
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_SERVICE_Client * client
ID of the client.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
#define GNUNET_free(ptr)
Wrapper around free.
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
clsidentification of the client
messagethe actual message

Definition at line 1063 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().

1065 {
1066  struct GSF_LocalClient *lc = cls;
1067  struct IndexStartContext *isc;
1068  char *fn;
1069  uint64_t dev;
1070  uint64_t ino;
1071  uint64_t mydev;
1072  uint64_t myino;
1073 
1074  fn = GNUNET_STRINGS_filename_expand ((const char *) &ism[1]);
1075  GNUNET_assert (NULL != fn);
1076  dev = GNUNET_ntohll (ism->device);
1077  ino = GNUNET_ntohll (ism->inode);
1078  isc = GNUNET_new (struct IndexStartContext);
1079  isc->filename = fn;
1080  isc->file_id = ism->file_id;
1082  "Received START_INDEX message for file `%s'\n",
1083  isc->filename);
1084  isc->lc = lc;
1085  mydev = 0;
1086  myino = 0;
1087  if (((dev != 0) ||
1088  (ino != 0)) &&
1090  &mydev,
1091  &myino)) &&
1092  (dev == mydev) &&
1093  (ino == myino))
1094  {
1095  /* fast validation OK! */
1096  signal_index_ok (isc);
1097  return;
1098  }
1100  "Mismatch in file identifiers (%llu != %llu or %u != %u), need to hash.\n",
1101  (unsigned long long) ino,
1102  (unsigned long long) myino,
1103  (unsigned int) dev,
1104  (unsigned int) mydev);
1105  /* slow validation, need to hash full file (again) */
1107  lc->isc_tail,
1108  isc);
1110  isc->filename,
1113  isc);
1114  if (NULL == isc->fhc)
1115  hash_for_index_val (isc,
1116  NULL);
1117 }
#define GNUNET_CONTAINER_DLL_insert(head, tail, element)
Insert an element at the head of a DLL.
struct IndexStartContext * isc_head
This is a doubly linked list.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
char * filename
Name of the indexed file.
int GNUNET_DISK_file_get_identifiers(const char *filename, uint64_t *dev, uint64_t *ino)
Obtain some unique identifiers for the given file that can be used to identify it in the local system...
Definition: disk.c:291
#define GNUNET_new(type)
Allocate a struct or union of the given type.
struct IndexStartContext * isc_tail
This is a doubly linked list.
struct GNUNET_CRYPTO_FileHashContext * GNUNET_CRYPTO_hash_file(enum GNUNET_SCHEDULER_Priority priority, const char *filename, size_t blocksize, GNUNET_CRYPTO_HashCompletedCallback callback, void *callback_cls)
Compute the hash of an entire file.
Information we track while handling an index start request from a client.
A local client.
static char * fn
Filename of the unique file.
uint64_t device
ID of device containing the file, as seen by the client.
Definition: fs.h:170
Run when otherwise idle.
struct GNUNET_CRYPTO_FileHashContext * fhc
Context for hashing of the file.
struct GNUNET_HashCode file_id
Hash of the file that we would like to index.
Definition: fs.h:183
char * GNUNET_STRINGS_filename_expand(const char *fil)
Complete filename (a la shell) from abbrevition.
Definition: strings.c:603
uint64_t inode
Inode of the file on the given device, as seen by the client ("st_ino" field from "struct stat")...
Definition: fs.h:178
#define HASHING_BLOCKSIZE
Blocksize to use when hashing files for indexing (blocksize for IO, not for the DBlocks).
Definition: fs.h:47
struct GNUNET_HashCode file_id
Hash of the contents of the file.
#define GNUNET_log(kind,...)
struct GSF_LocalClient * lc
Context for transmitting confirmation to client.
static void signal_index_ok(struct IndexStartContext *isc)
We&#39;ve validated the hash of the file we&#39;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.
uint64_t GNUNET_ntohll(uint64_t n)
Convert unsigned 64-bit integer to host byte order.
Definition: common_endian.c:48
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
clsclosure
messagethe actual message

Definition at line 1127 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.

1129 {
1130  struct GSF_LocalClient *lc = cls;
1131 
1134 }
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
void GNUNET_FS_indexing_send_list(struct GNUNET_MQ_Handle *mq)
Transmit information about indexed files to mq.
A local client.
struct GNUNET_SERVICE_Client * client
ID of the client.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
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
clsidentification of the client
messagethe actual message

Definition at line 1144 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.

1146 {
1147  struct GSF_LocalClient *lc = cls;
1148  struct GNUNET_MQ_Envelope *env;
1149  struct GNUNET_MessageHeader *msg;
1150  int found;
1151 
1152  GNUNET_break (0 == um->reserved);
1153  found = GNUNET_FS_indexing_do_unindex (&um->file_id);
1155  "Client requested unindexing of file `%s': %s\n",
1156  GNUNET_h2s (&um->file_id),
1157  found ? "found" : "not found");
1158  env = GNUNET_MQ_msg (msg,
1160  GNUNET_MQ_send (lc->mq,
1161  env);
1163 }
int GNUNET_FS_indexing_do_unindex(const struct GNUNET_HashCode *fid)
Remove a file from the index.
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
uint32_t reserved
Always zero.
Definition: fs.h:236
struct GNUNET_MQ_Handle * mq
Queue for sending replies.
#define GNUNET_MQ_msg(mvar, type)
Allocate a GNUNET_MQ_Envelope.
Definition: gnunet_mq_lib.h:67
const char * GNUNET_h2s(const struct GNUNET_HashCode *hc)
Convert a hash value to a string (for printing debug messages).
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur...
A local client.
struct GNUNET_HashCode file_id
Hash of the file that we will unindex.
Definition: fs.h:241
#define GNUNET_MESSAGE_TYPE_FS_UNINDEX_OK
Reply to client indicating unindex receipt.
struct GNUNET_MQ_Envelope * env
Definition: 005.c:1
#define GNUNET_log(kind,...)
Header for all communications.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
Definition: mq.c:353
struct GNUNET_SERVICE_Client * client
ID of the client.
void GNUNET_SERVICE_client_continue(struct GNUNET_SERVICE_Client *c)
Continue receiving further messages from the given client.
Definition: service.c:2243
Here is the call graph for this function:

◆ shutdown_task()

static void shutdown_task ( void *  cls)
static

Task run during shutdown.

Parameters
clsunused

Definition at line 1172 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().

1173 {
1175  if (NULL != GSF_core)
1176  {
1178  GSF_core = NULL;
1179  }
1180  if (NULL != GSF_ats)
1181  {
1183  GSF_ats = NULL;
1184  }
1185  GSF_put_done_ ();
1186  GSF_push_done_ ();
1188  GSF_plan_done ();
1191  GNUNET_NO);
1192  GSF_dsh = NULL;
1194  GSF_dht = NULL;
1196  GSF_block_ctx = NULL;
1198  block_cfg = NULL;
1200  GSF_stats = NULL;
1201  if (NULL != cover_age_task)
1202  {
1204  cover_age_task = NULL;
1205  }
1208  datastore_get_load = NULL;
1210  GSF_rt_entry_lifetime = NULL;
1211 }
void GSF_plan_done()
Shutdown plan subsystem.
void GNUNET_FS_indexing_done()
Shutdown the module.
void GSF_put_done_()
Shutdown the module.
static struct GNUNET_LOAD_Value * datastore_get_load
Datastore &#39;GET&#39; load tracking.
void GSF_cadet_stop_server(void)
Shutdown subsystem for non-anonymous file-sharing.
struct GNUNET_ATS_PerformanceHandle * GSF_ats
Handle to ATS service.
void GNUNET_ATS_performance_done(struct GNUNET_ATS_PerformanceHandle *ph)
Client is done using the ATS performance subsystem, release resources.
struct GNUNET_DHT_Handle * GSF_dht
Handle for DHT operations.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_NO
Definition: gnunet_common.h:78
void GNUNET_STATISTICS_destroy(struct GNUNET_STATISTICS_Handle *h, int sync_first)
Destroy a handle (free all state associated with it).
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
static struct GNUNET_CONFIGURATION_Handle * block_cfg
Configuration for block library.
void GNUNET_CONFIGURATION_destroy(struct GNUNET_CONFIGURATION_Handle *cfg)
Destroy configuration object.
struct GNUNET_CORE_Handle * GSF_core
Pointer to handle to the core service (points to NULL until we&#39;ve connected to it).
struct GNUNET_DATASTORE_Handle * GSF_dsh
Our connection to the datastore.
void GNUNET_BLOCK_context_destroy(struct GNUNET_BLOCK_Context *ctx)
Destroy the block context.
Definition: block.c:151
void GSF_pending_request_done_()
Shutdown the subsystem.
static struct GNUNET_SCHEDULER_Task * cover_age_task
ID of our task that we use to age the cover counters.
void GNUNET_CORE_disconnect(struct GNUNET_CORE_Handle *handle)
Disconnect from the core service.
Definition: core_api.c:730
void GNUNET_DHT_disconnect(struct GNUNET_DHT_Handle *handle)
Shutdown connection with the DHT service.
Definition: dht_api.c:918
struct GNUNET_LOAD_Value * GSF_rt_entry_lifetime
How long do requests typically stay in the routing table?
void GNUNET_DATASTORE_disconnect(struct GNUNET_DATASTORE_Handle *h, int drop)
Disconnect from the datastore service (and free associated resources).
#define GNUNET_LOAD_value_free(lv)
Free a load value.
void GSF_push_done_()
Shutdown the module.
void GSF_connected_peer_done_()
Shutdown peer management subsystem.
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
Definition: scheduler.c:966
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
clsclosure
my_identityID of this peer, NULL if we failed

Definition at line 1225 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().

1227 {
1228  if (0 != GNUNET_memcmp (&GSF_my_id,
1229  my_identity))
1230  {
1232  "Peer identity mismatch, refusing to start!\n");
1234  }
1235 }
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
struct GNUNET_PeerIdentity GSF_my_id
Identity of this peer.
#define GNUNET_memcmp(a, b)
Compare memory in a and b, where both must be of the same pointer type.
#define GNUNET_log(kind,...)
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
cconfiguration to use

Definition at line 1244 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().

1245 {
1246  struct GNUNET_MQ_MessageHandler no_p2p_handlers[] = {
1248  };
1249  struct GNUNET_MQ_MessageHandler p2p_handlers[] = {
1250  GNUNET_MQ_hd_var_size (p2p_get,
1252  struct GetMessage,
1253  NULL),
1254  GNUNET_MQ_hd_var_size (p2p_put,
1256  struct PutMessage,
1257  NULL),
1258  GNUNET_MQ_hd_fixed_size (p2p_migration_stop,
1260  struct MigrationStopMessage,
1261  NULL),
1263  };
1264  int anon_p2p_off;
1265  char *keyfile;
1266 
1267  /* this option is really only for testcases that need to disable
1268  _anonymous_ file-sharing for some reason */
1269  anon_p2p_off = (GNUNET_YES ==
1271  "fs",
1272  "DISABLE_ANON_TRANSFER"));
1273 
1274  if (GNUNET_OK !=
1276  "PEER",
1277  "PRIVATE_KEY",
1278  &keyfile))
1279  {
1281  _ (
1282  "FS service is lacking HOSTKEY configuration setting. Exiting.\n"));
1284  return GNUNET_SYSERR;
1285  }
1287  GNUNET_free (keyfile);
1288  GNUNET_assert (NULL != pk);
1291 
1293  "I am peer %s\n",
1294  GNUNET_i2s (&GSF_my_id));
1295  GSF_core
1297  NULL,
1301  (GNUNET_YES == anon_p2p_off)
1302  ? no_p2p_handlers
1303  : p2p_handlers);
1304  if (NULL == GSF_core)
1305  {
1307  _ ("Failed to connect to `%s' service.\n"),
1308  "core");
1309  return GNUNET_SYSERR;
1310  }
1311  cover_age_task =
1314  NULL);
1318  NULL);
1319  return GNUNET_OK;
1320 }
static struct GNUNET_CRYPTO_EddsaPrivateKey * pk
Private key of this peer.
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:124
Response from FS service with a result for a previous FS search.
Definition: fs.h:328
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_shutdown(GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run on shutdown, that is when a CTRL-C signal is received, or when GNUNET_SCHEDULER_shutdown() is being invoked.
Definition: scheduler.c:1300
void GSF_peer_disconnect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, void *internal_cls)
A peer disconnected from us.
static struct GNUNET_LOAD_Value * datastore_get_load
Datastore &#39;GET&#39; load tracking.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
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).
#define GNUNET_MQ_hd_fixed_size(name, code, str, ctx)
#define COVER_AGE_FREQUENCY
How quickly do we age cover traffic? At the given time interval, remaining cover traffic counters are...
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
Definition: scheduler.c:1253
#define GNUNET_MQ_hd_var_size(name, code, str, ctx)
Message to the datastore service asking about specific content.
Definition: datastore.h:140
struct GNUNET_PeerIdentity GSF_my_id
Identity of this peer.
static void age_cover_counters(void *cls)
Task that periodically ages our cover traffic statistics.
struct GNUNET_CORE_Handle * GSF_core
Pointer to handle to the core service (points to NULL until we&#39;ve connected to it).
Message handler for a specific message type.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
struct GNUNET_CORE_Handle * GNUNET_CORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, void *cls, GNUNET_CORE_StartupCallback init, GNUNET_CORE_ConnectEventHandler connects, GNUNET_CORE_DisconnectEventHandler disconnects, const struct GNUNET_MQ_MessageHandler *handlers)
Connect to the core service.
Definition: core_api.c:692
static struct GNUNET_SCHEDULER_Task * cover_age_task
ID of our task that we use to age the cover counters.
Message send by a peer that wants to be excluded from migration for a while.
void GNUNET_CRYPTO_eddsa_key_get_public(const struct GNUNET_CRYPTO_EddsaPrivateKey *priv, struct GNUNET_CRYPTO_EddsaPublicKey *pub)
Extract the public key for the given private key.
Definition: crypto_ecc.c:270
void * GSF_peer_connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
A peer connected to us.
#define GNUNET_MESSAGE_TYPE_FS_MIGRATION_STOP
Peer asks us to stop migrating content towards it for a while.
static void shutdown_task(void *cls)
Task run during shutdown.
#define GNUNET_log(kind,...)
struct GNUNET_CRYPTO_EddsaPrivateKey * GNUNET_CRYPTO_eddsa_key_create_from_file(const char *filename)
Create a new private key by reading it from a file.
int GNUNET_CONFIGURATION_get_value_filename(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be the name of a file or directory.
#define GNUNET_YES
Definition: gnunet_common.h:77
void GSF_cadet_start_server(void)
Initialize subsystem for non-anonymous file-sharing.
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
#define GNUNET_MESSAGE_TYPE_FS_PUT
P2P response with content or active migration of content.
#define GNUNET_MESSAGE_TYPE_FS_GET
P2P request for content (one FS to another).
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define DATASTORE_LOAD_AUTODECLINE
At what frequency should our datastore load decrease automatically (since if we don&#39;t use it...
#define GNUNET_MQ_handler_end()
End-marker for the handlers array.
#define GNUNET_free(ptr)
Wrapper around free.
struct GNUNET_CRYPTO_EddsaPublicKey public_key
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
clsclosure
cfgconfiguration to use
servicethe initialized service

Definition at line 1331 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().

1334 {
1335  unsigned long long dqs;
1336 
1337  GSF_cfg = cfg;
1338  if (GNUNET_OK !=
1340  "fs",
1341  "DATASTORE_QUEUE_SIZE",
1342  &dqs))
1343  {
1345  "fs",
1346  "DATASTORE_QUEUE_SIZE");
1347  dqs = 32;
1348  }
1349  GSF_datastore_queue_size = (unsigned int) dqs;
1351  GNUNET_CONFIGURATION_get_value_yesno (cfg, "fs", "DELAY");
1353  if (NULL == GSF_dsh)
1354  {
1356  return;
1357  }
1359  GSF_stats = GNUNET_STATISTICS_create ("fs", cfg);
1362  GNUNET_assert (NULL != GSF_block_ctx);
1364  GSF_plan_init ();
1369  NULL);
1370  GSF_push_init_ ();
1371  GSF_put_init_ ();
1372  if ((GNUNET_OK != GNUNET_FS_indexing_init (cfg,
1373  GSF_dsh)) ||
1374  (GNUNET_OK != main_init (cfg)))
1375  {
1377  shutdown_task (NULL);
1378  return;
1379  }
1380 }
struct GNUNET_BLOCK_Context * GNUNET_BLOCK_context_create(const struct GNUNET_CONFIGURATION_Handle *cfg)
Create a block context.
Definition: block.c:131
int GSF_enable_randomized_delays
Are we introducing randomized delays for better anonymity?
static const struct GNUNET_CONFIGURATION_Handle * cfg
Configuration we are using.
Definition: gnunet-abd.c:36
struct GNUNET_LOAD_Value * GNUNET_LOAD_value_init(struct GNUNET_TIME_Relative autodecline)
Create a new load value.
Definition: load.c:124
void GSF_connected_peer_init_()
Initialize peer management subsystem.
struct GNUNET_STATISTICS_Handle * GNUNET_STATISTICS_create(const char *subsystem, const struct GNUNET_CONFIGURATION_Handle *cfg)
Get handle for the statistics service.
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
struct GNUNET_ATS_PerformanceHandle * GSF_ats
Handle to ATS service.
struct GNUNET_DHT_Handle * GSF_dht
Handle for DHT operations.
struct GNUNET_STATISTICS_Handle * GSF_stats
Handle for reporting statistics.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
struct GNUNET_CONFIGURATION_Handle * GNUNET_CONFIGURATION_create(void)
Create a new configuration object.
static int main_init(const struct GNUNET_CONFIGURATION_Handle *c)
Process fs requests.
void GNUNET_SCHEDULER_shutdown(void)
Request the shutdown of a scheduler.
Definition: scheduler.c:526
const struct GNUNET_CONFIGURATION_Handle * GSF_cfg
Our configuration.
void GSF_pending_request_init_()
Setup the subsystem.
int GNUNET_FS_indexing_init(const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_DATASTORE_Handle *d)
Initialize the indexing submodule.
void GSF_push_init_()
Setup the module.
void GNUNET_log_config_missing(enum GNUNET_ErrorType kind, const char *section, const char *option)
Log error message about missing configuration option.
void GSF_plan_init()
Initialize plan subsystem.
unsigned int GSF_datastore_queue_size
Size of the datastore queue we assume for common requests.
struct GNUNET_BLOCK_Context * GSF_block_ctx
Our block context.
static struct GNUNET_CONFIGURATION_Handle * block_cfg
Configuration for block library.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
int GNUNET_CONFIGURATION_get_value_size(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *size)
Get a configuration value that should be a size in bytes.
struct GNUNET_DATASTORE_Handle * GSF_dsh
Our connection to the datastore.
struct GNUNET_DHT_Handle * GNUNET_DHT_connect(const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
Initialize the connection with the DHT service.
Definition: dht_api.c:890
struct GNUNET_ATS_PerformanceHandle * GNUNET_ATS_performance_init(const struct GNUNET_CONFIGURATION_Handle *cfg, GNUNET_ATS_AddressInformationCallback addr_info_cb, void *addr_info_cb_cls)
Get handle to access performance API of the ATS subsystem.
struct GNUNET_LOAD_Value * GSF_rt_entry_lifetime
How long do requests typically stay in the routing table?
static void shutdown_task(void *cls)
Task run during shutdown.
#define FS_DHT_HT_SIZE
Size for the hash map for DHT requests from the FS service.
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&#39;ve received peer performance information.
int GNUNET_CONFIGURATION_get_value_yesno(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Get a configuration value that should be in a set of "YES" or "NO".
struct GNUNET_DATASTORE_Handle * GNUNET_DATASTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the datastore service.
void GSF_put_init_()
Setup the module.
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

◆ GSF_cfg

const struct GNUNET_CONFIGURATION_Handle* GSF_cfg

◆ GSF_stats

struct GNUNET_STATISTICS_Handle* GSF_stats

◆ GSF_dht

struct GNUNET_DHT_Handle* GSF_dht

Handle for DHT operations.

Definition at line 239 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 244 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 250 of file gnunet-service-fs.c.

Referenced by get_randomized_delay().

◆ GSF_ats

Handle to ATS service.

Definition at line 255 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 268 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 273 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 279 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 285 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

◆ 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 296 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 301 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 306 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 313 of file gnunet-service-fs.c.

◆ pk

struct GNUNET_CRYPTO_EddsaPrivateKey* pk
static

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

◆ datastore_get_load

struct GNUNET_LOAD_Value* datastore_get_load
static

Datastore 'GET' load tracking.

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