Information we track per peer. More...

#include "gnunet_common.h"
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_pils_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-cadet.h"
#include "gnunet-service-cadet_dht.h"
#include "gnunet-service-cadet_hello.h"
#include "gnunet-service-cadet_peer.h"
#include "gnunet-service-cadet_paths.h"

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

Data Structures
struct	GCD_search_handle

Macros
#define	STARTUP_DELAY
	How long do we wait before first announcing our presence to the DHT.

#define	CHANGE_DELAY
	How long do we wait after we get an updated HELLO before publishing? Allows for the HELLO to be updated again quickly, for example in case multiple addresses changed and we got a partial update.

#define	LOG(level, ...) GNUNET_log_from (level, "cadet-dht", __VA_ARGS__)

Functions
static void	dht_get_id_handler (void cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode key, const struct GNUNET_PeerIdentity trunc_peer, const struct GNUNET_DHT_PathElement get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void data)
	Function to process paths received for a new peer addition.

static void	announce_id (void *cls)

void	GCD_hello_update ()
	Function called by the HELLO subsystem whenever OUR hello changes.

void	GCD_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Initialize the DHT subsystem.

void	GCD_shutdown (void)
	Shut down the DHT subsystem.

struct GCD_search_handle *	GCD_search (const struct GNUNET_PeerIdentity *peer_id)
	Search DHT for paths to peeR_id.

void	GCD_search_stop (struct GCD_search_handle *h)
	Stop DHT search started with GCD_search().

Variables
static struct GNUNET_DHT_Handle *	dht_handle
	Handle to use DHT.

static struct GNUNET_TIME_Relative	id_announce_time
	How often to PUT own ID in the DHT.

static unsigned long long	dht_replication_level
	DHT replication level, see DHT API: GNUNET_DHT_get_start(), GNUNET_DHT_put().

static struct GNUNET_SCHEDULER_Task *	announce_id_task
	Task to periodically announce itself in the network.

static struct GNUNET_TIME_Relative	announce_delay
	Delay for the next ID announce.

Detailed Description

Information we track per peer.

Author: Bartlomiej Polot; Christian Grothoff

Definition in file gnunet-service-cadet_dht.c.

Macro Definition Documentation

◆ STARTUP_DELAY

#define STARTUP_DELAY

Value:

GNUNET_TIME_relative_multiply ( \

GNUNET_TIME_UNIT_MILLISECONDS, 500)

GNUNET_TIME_UNIT_MILLISECONDS

#define GNUNET_TIME_UNIT_MILLISECONDS

One millisecond.

Definition gnunet_time_lib.h:151

GNUNET_TIME_relative_multiply

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:486

How long do we wait before first announcing our presence to the DHT.

Used to wait for our HELLO to be available. Note that we also get notifications when our HELLO is ready, so this is just the maximum we wait for the first notification.

Definition at line 45 of file gnunet-service-cadet_dht.c.

{
  struct GNUNET_DHT_GetHandle *dhtget;
};
 
 
static struct GNUNET_DHT_Handle *dht_handle;
 
static struct GNUNET_TIME_Relative id_announce_time;
 
static unsigned long long dht_replication_level;
 
static struct GNUNET_SCHEDULER_Task *announce_id_task;
 
static struct GNUNET_TIME_Relative announce_delay;
 
 
static void
dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
                    const struct GNUNET_HashCode *key,
                    const struct GNUNET_PeerIdentity *trunc_peer,
                    const struct GNUNET_DHT_PathElement *get_path,
                    unsigned int get_path_length,
                    const struct GNUNET_DHT_PathElement *put_path,
                    unsigned int put_path_length,
                    enum GNUNET_BLOCK_Type type,
                    size_t size,
                    const void *data)
{
  const struct GNUNET_MessageHeader *hello = data;
  struct CadetPeer *peer;
 
  (void) trunc_peer;
  GCPP_try_path_from_dht (get_path,
                          get_path_length,
                          put_path,
                          put_path_length);
 
 
  if (0 == put_path_length)
    return;
  peer = GCP_get (&put_path[0].pred,
                  GNUNET_YES);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got HELLO for %s\n",
       GCP_2s (peer));
  GCP_set_hello (peer,
                 hello);
}
 
 
static void
announce_id (void*cls)
{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_HashCode phash;
  const struct GNUNET_MessageHeader *hello;
  size_t size;
  size_t block_size;
  void *block;
  struct GNUNET_TIME_Absolute expiration;
  struct GNUNET_TIME_Relative next_put;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    announce_id_task
      = GNUNET_SCHEDULER_add_delayed (CHANGE_DELAY,
                                      &announce_id,
                                      NULL);
    return;
  }
 
  hello = GCH_get_mine ();
  size = (NULL != hello) ? ntohs (hello->size) : 0;
  if (0 == size)
  {
    expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
                                           announce_delay);
    announce_delay = GNUNET_TIME_STD_BACKOFF (announce_delay);
  }
  else
  {
    expiration = GNUNET_HELLO_get_expiration_time_from_msg (hello);
    announce_delay = GNUNET_TIME_UNIT_SECONDS;
  }
 
  /* Call again in id_announce_time, unless HELLO expires first,
   * but wait at least 1s. */
  next_put
    = GNUNET_TIME_absolute_get_remaining (expiration);
  next_put
    = GNUNET_TIME_relative_min (next_put,
                                id_announce_time);
  next_put
    = GNUNET_TIME_relative_max (next_put,
                                GNUNET_TIME_UNIT_SECONDS);
  announce_id_task
    = GNUNET_SCHEDULER_add_delayed (next_put,
                                    &announce_id,
                                    NULL);
  GNUNET_STATISTICS_update (stats,
                            "# DHT announce",
                            1,
                            GNUNET_NO);
  memset (&phash,
          0,
          sizeof(phash));
  GNUNET_memcpy (&phash, my_identity,
                 sizeof(*my_identity));
  if ((0 == size) ||
      (GNUNET_OK != GNUNET_HELLO_dht_msg_to_block (hello,
                                                   my_identity,
                                                   &block,
                                                   &block_size,
                                                   &expiration)))
    return;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Announcing my HELLO (%lu bytes) in the DHT\n",
       (unsigned long) block_size);
  GNUNET_DHT_put (dht_handle,    /* DHT handle */
                  &phash,       /* Key to use */
                  dht_replication_level,     /* Replication level */
                  GNUNET_DHT_RO_RECORD_ROUTE
                  | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,    /* DHT options */
                  GNUNET_BLOCK_TYPE_DHT_HELLO,       /* Block type */
                  block_size,  /* Size of the data */
                  (const char *) block, /* Data itself */
                  expiration,  /* Data expiration */
                  NULL,         /* Continuation */
                  NULL);        /* Continuation closure */
  GNUNET_free (block);
}
 
 
void
GCD_hello_update ()
{
  if (NULL == announce_id_task)
    return; /* too early */
  GNUNET_SCHEDULER_cancel (announce_id_task);
  announce_id_task
    = GNUNET_SCHEDULER_add_delayed (CHANGE_DELAY,
                                    &announce_id,
                                    NULL);
}
 
 
void
GCD_init (const struct GNUNET_CONFIGURATION_Handle *c)
{
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (c,
                                             "CADET",
                                             "DHT_REPLICATION_LEVEL",
                                             &dht_replication_level))
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
                               "CADET",
                               "DHT_REPLICATION_LEVEL",
                               "USING DEFAULT");
    dht_replication_level = 3;
  }
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (c,
                                           "CADET",
                                           "ID_ANNOUNCE_TIME",
                                           &id_announce_time))
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               "CADET",
                               "ID_ANNOUNCE_TIME",
                               "MISSING");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  dht_handle = GNUNET_DHT_connect (c,
                                   64);
  GNUNET_break (NULL != dht_handle);
  announce_delay = GNUNET_TIME_UNIT_SECONDS;
  announce_id_task = GNUNET_SCHEDULER_add_delayed (STARTUP_DELAY,
                                                   &announce_id,
                                                   NULL);
}
 
 
void
GCD_shutdown (void)
{
  if (NULL != dht_handle)
  {
    GNUNET_DHT_disconnect (dht_handle);
    dht_handle = NULL;
  }
  if (NULL != announce_id_task)
  {
    GNUNET_SCHEDULER_cancel (announce_id_task);
    announce_id_task = NULL;
  }
}
 
 
struct GCD_search_handle *
GCD_search (const struct GNUNET_PeerIdentity *peer_id)
{
  struct GNUNET_HashCode phash;
  struct GCD_search_handle *h;
 
  GNUNET_STATISTICS_update (stats,
                            "# DHT search",
                            1,
                            GNUNET_NO);
  memset (&phash,
          0,
          sizeof(phash));
  GNUNET_memcpy (&phash,
                 peer_id,
                 sizeof(*peer_id));
 
  h = GNUNET_new (struct GCD_search_handle);
  h->dhtget = GNUNET_DHT_get_start (dht_handle,     /* handle */
                                    GNUNET_BLOCK_TYPE_DHT_HELLO, /* type */
                                    &phash,     /* key to search */
                                    dht_replication_level, /* replication level */
                                    GNUNET_DHT_RO_RECORD_ROUTE
                                    | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
                                    NULL,       /* xquery */
                                    0,     /* xquery bits */
                                    &dht_get_id_handler,
                                    h);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Starting DHT GET for peer %s (%p)\n",
       GNUNET_i2s (peer_id),
       h);
  return h;
}
 
 
void
GCD_search_stop (struct GCD_search_handle *h)
{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Stopping DHT GET %p\n",
       h);
  GNUNET_DHT_get_stop (h->dhtget);
  GNUNET_free (h);
}
 
 
/* end of gnunet-service-cadet_dht.c */

◆ CHANGE_DELAY

#define CHANGE_DELAY

Value:

GNUNET_TIME_relative_multiply ( \

GNUNET_TIME_UNIT_MILLISECONDS, 100)

How long do we wait after we get an updated HELLO before publishing? Allows for the HELLO to be updated again quickly, for example in case multiple addresses changed and we got a partial update.

Definition at line 53 of file gnunet-service-cadet_dht.c.

◆ LOG

#define LOG	(	level,
		...
	)	GNUNET_log_from (level, "cadet-dht", __VA_ARGS__)

Definition at line 57 of file gnunet-service-cadet_dht.c.

Function Documentation

◆ dht_get_id_handler()

static void dht_get_id_handler	(	void *	cls,
		struct GNUNET_TIME_Absolute	exp,
		const struct GNUNET_HashCode *	key,
		const struct GNUNET_PeerIdentity *	trunc_peer,
		const struct GNUNET_DHT_PathElement *	get_path,
		unsigned int	get_path_length,
		const struct GNUNET_DHT_PathElement *	put_path,
		unsigned int	put_path_length,
		enum GNUNET_BLOCK_Type	type,
		size_t	size,
		const void *	data
	)

static

Function to process paths received for a new peer addition.

The recorded paths form the initial tunnel, which can be optimized later. Called on each result obtained for the DHT search.

Parameters

cls	closure
exp	when will this value expire
key	key of the result
trunc_peer	peer proceeding with invalid signature, or NULL
get_path	path of the get request
get_path_length	length of get_path
put_path	path of the put request
put_path_length	length of the put_path
type	type of the result
size	number of bytes in data
data	pointer to the result data

Definition at line 113 of file gnunet-service-cadet_dht.c.

{
  const struct GNUNET_MessageHeader *hello = data;
  struct CadetPeer *peer;
 
  (void) trunc_peer;
  GCPP_try_path_from_dht (get_path,
                          get_path_length,
                          put_path,
                          put_path_length);
 
 
  if (0 == put_path_length)
    return;
  peer = GCP_get (&put_path[0].pred,
                  GNUNET_YES);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Got HELLO for %s\n",
       GCP_2s (peer));
  GCP_set_hello (peer,
                 hello);
}

References data, GCP_2s(), GCP_get(), GCP_set_hello(), GCPP_try_path_from_dht(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_YES, CadetPeer::hello, and LOG.

Referenced by GCD_search().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ announce_id()

static void announce_id ( void * cls )

static

Definition at line 147 of file gnunet-service-cadet_dht.c.

{
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_HashCode phash;
  const struct GNUNET_MessageHeader *hello;
  size_t size;
  size_t block_size;
  void *block;
  struct GNUNET_TIME_Absolute expiration;
  struct GNUNET_TIME_Relative next_put;
 
  my_identity = GNUNET_PILS_get_identity (pils);
  if (NULL == my_identity)
  {
    announce_id_task
      = GNUNET_SCHEDULER_add_delayed (CHANGE_DELAY,
                                      &announce_id,
                                      NULL);
    return;
  }
 
  hello = GCH_get_mine ();
  size = (NULL != hello) ? ntohs (hello->size) : 0;
  if (0 == size)
  {
    expiration = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
                                           announce_delay);
    announce_delay = GNUNET_TIME_STD_BACKOFF (announce_delay);
  }
  else
  {
    expiration = GNUNET_HELLO_get_expiration_time_from_msg (hello);
    announce_delay = GNUNET_TIME_UNIT_SECONDS;
  }
 
  /* Call again in id_announce_time, unless HELLO expires first,
   * but wait at least 1s. */
  next_put
    = GNUNET_TIME_absolute_get_remaining (expiration);
  next_put
    = GNUNET_TIME_relative_min (next_put,
                                id_announce_time);
  next_put
    = GNUNET_TIME_relative_max (next_put,
                                GNUNET_TIME_UNIT_SECONDS);
  announce_id_task
    = GNUNET_SCHEDULER_add_delayed (next_put,
                                    &announce_id,
                                    NULL);
  GNUNET_STATISTICS_update (stats,
                            "# DHT announce",
                            1,
                            GNUNET_NO);
  memset (&phash,
          0,
          sizeof(phash));
  GNUNET_memcpy (&phash, my_identity,
                 sizeof(*my_identity));
  if ((0 == size) ||
      (GNUNET_OK != GNUNET_HELLO_dht_msg_to_block (hello,
                                                   my_identity,
                                                   &block,
                                                   &block_size,
                                                   &expiration)))
    return;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Announcing my HELLO (%lu bytes) in the DHT\n",
       (unsigned long) block_size);
  GNUNET_DHT_put (dht_handle,    /* DHT handle */
                  &phash,       /* Key to use */
                  dht_replication_level,     /* Replication level */
                  GNUNET_DHT_RO_RECORD_ROUTE
                  | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,    /* DHT options */
                  GNUNET_BLOCK_TYPE_DHT_HELLO,       /* Block type */
                  block_size,  /* Size of the data */
                  (const char *) block, /* Data itself */
                  expiration,  /* Data expiration */
                  NULL,         /* Continuation */
                  NULL);        /* Continuation closure */
  GNUNET_free (block);
}

References announce_delay, announce_id(), announce_id_task, CHANGE_DELAY, dht_handle, dht_replication_level, expiration, GCH_get_mine(), GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_DHT_put(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_dht_msg_to_block(), GNUNET_HELLO_get_expiration_time_from_msg(), GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_add(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_max(), GNUNET_TIME_relative_min(), GNUNET_TIME_STD_BACKOFF, GNUNET_TIME_UNIT_SECONDS, id_announce_time, LOG, my_identity, pils, GNUNET_MessageHeader::size, size, and stats.

Referenced by announce_id(), GCD_hello_update(), and GCD_init().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCD_hello_update()

void GCD_hello_update ( void )

Function called by the HELLO subsystem whenever OUR hello changes.

Re-triggers the DHT PUT immediately.

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

{
  if (NULL == announce_id_task)
    return; /* too early */
  GNUNET_SCHEDULER_cancel (announce_id_task);
  announce_id_task
    = GNUNET_SCHEDULER_add_delayed (CHANGE_DELAY,
                                    &announce_id,
                                    NULL);
}

References announce_id(), announce_id_task, CHANGE_DELAY, GNUNET_SCHEDULER_add_delayed(), and GNUNET_SCHEDULER_cancel().

Referenced by sign_hello_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCD_init()

void GCD_init ( const struct GNUNET_CONFIGURATION_Handle * c )

Initialize the DHT subsystem.

Parameters

c	Configuration.

Definition at line 245 of file gnunet-service-cadet_dht.c.

{
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number (c,
                                             "CADET",
                                             "DHT_REPLICATION_LEVEL",
                                             &dht_replication_level))
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
                               "CADET",
                               "DHT_REPLICATION_LEVEL",
                               "USING DEFAULT");
    dht_replication_level = 3;
  }
 
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_time (c,
                                           "CADET",
                                           "ID_ANNOUNCE_TIME",
                                           &id_announce_time))
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               "CADET",
                               "ID_ANNOUNCE_TIME",
                               "MISSING");
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
 
  dht_handle = GNUNET_DHT_connect (c,
                                   64);
  GNUNET_break (NULL != dht_handle);
  announce_delay = GNUNET_TIME_UNIT_SECONDS;
  announce_id_task = GNUNET_SCHEDULER_add_delayed (STARTUP_DELAY,
                                                   &announce_id,
                                                   NULL);
}

References announce_delay, announce_id(), announce_id_task, dht_handle, dht_replication_level, GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_time(), GNUNET_DHT_connect(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_config_invalid(), GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_TIME_UNIT_SECONDS, id_announce_time, and STARTUP_DELAY.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCD_shutdown()

void GCD_shutdown ( void )

Shut down the DHT subsystem.

Definition at line 285 of file gnunet-service-cadet_dht.c.

{
  if (NULL != dht_handle)
  {
    GNUNET_DHT_disconnect (dht_handle);
    dht_handle = NULL;
  }
  if (NULL != announce_id_task)
  {
    GNUNET_SCHEDULER_cancel (announce_id_task);
    announce_id_task = NULL;
  }
}

References announce_id_task, dht_handle, GNUNET_DHT_disconnect(), and GNUNET_SCHEDULER_cancel().

Referenced by shutdown_rest().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCD_search()

struct GCD_search_handle * GCD_search ( const struct GNUNET_PeerIdentity * peer_id )

Search DHT for paths to peeR_id.

Parameters

peer_id peer to search for

Returns: handle to abort search

Definition at line 301 of file gnunet-service-cadet_dht.c.

{
  struct GNUNET_HashCode phash;
  struct GCD_search_handle *h;
 
  GNUNET_STATISTICS_update (stats,
                            "# DHT search",
                            1,
                            GNUNET_NO);
  memset (&phash,
          0,
          sizeof(phash));
  GNUNET_memcpy (&phash,
                 peer_id,
                 sizeof(*peer_id));
 
  h = GNUNET_new (struct GCD_search_handle);
  h->dhtget = GNUNET_DHT_get_start (dht_handle,     /* handle */
                                    GNUNET_BLOCK_TYPE_DHT_HELLO, /* type */
                                    &phash,     /* key to search */
                                    dht_replication_level, /* replication level */
                                    GNUNET_DHT_RO_RECORD_ROUTE
                                    | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
                                    NULL,       /* xquery */
                                    0,     /* xquery bits */
                                    &dht_get_id_handler,
                                    h);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Starting DHT GET for peer %s (%p)\n",
       GNUNET_i2s (peer_id),
       h);
  return h;
}

References dht_get_id_handler(), dht_handle, dht_replication_level, GNUNET_BLOCK_TYPE_DHT_HELLO, GNUNET_DHT_get_start(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DHT_RO_RECORD_ROUTE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_i2s(), GNUNET_memcpy, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), h, LOG, peer_id, and stats.

Referenced by consider_peer_activate(), and GCP_path_entry_remove().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GCD_search_stop()

void GCD_search_stop ( struct GCD_search_handle * h )

Stop DHT search started with GCD_search().

Parameters

h	handle to search to stop

Definition at line 337 of file gnunet-service-cadet_dht.c.

{
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Stopping DHT GET %p\n",
       h);
  GNUNET_DHT_get_stop (h->dhtget);
  GNUNET_free (h);
}

References GNUNET_DHT_get_stop(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, h, and LOG.

Referenced by consider_peer_activate(), destroy_peer(), and GCP_path_entry_add().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

◆ dht_handle

struct GNUNET_DHT_Handle* dht_handle

static

Handle to use DHT.

Definition at line 72 of file gnunet-service-cadet_dht.c.

Referenced by announce_id(), GCD_init(), GCD_search(), and GCD_shutdown().

◆ id_announce_time

struct GNUNET_TIME_Relative id_announce_time

static

How often to PUT own ID in the DHT.

Definition at line 77 of file gnunet-service-cadet_dht.c.

Referenced by announce_id(), and GCD_init().

◆ dht_replication_level

unsigned long long dht_replication_level

static

DHT replication level, see DHT API: GNUNET_DHT_get_start(), GNUNET_DHT_put().

Definition at line 82 of file gnunet-service-cadet_dht.c.

Referenced by announce_id(), GCD_init(), and GCD_search().

◆ announce_id_task

struct GNUNET_SCHEDULER_Task* announce_id_task

static

Task to periodically announce itself in the network.

Definition at line 87 of file gnunet-service-cadet_dht.c.

Referenced by announce_id(), GCD_hello_update(), GCD_init(), and GCD_shutdown().

◆ announce_delay

struct GNUNET_TIME_Relative announce_delay

static

Delay for the next ID announce.

Definition at line 92 of file gnunet-service-cadet_dht.c.

Referenced by announce_id(), and GCD_init().

Data Structures

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ STARTUP_DELAY

◆ CHANGE_DELAY

◆ LOG

Function Documentation

◆ dht_get_id_handler()

◆ announce_id()

◆ GCD_hello_update()

◆ GCD_init()

◆ GCD_shutdown()

◆ GCD_search()

◆ GCD_search_stop()

Variable Documentation

◆ dht_handle

◆ id_announce_time

◆ dht_replication_level

◆ announce_id_task

◆ announce_delay