gnunet-service-dht.h File Reference

GNUnet DHT globals. More...

#include "gnunet-service-dht_datacache.h"
#include "gnunet-service-dht_neighbours.h"
#include "gnunet_pils_service.h"
#include "gnunet_statistics_service.h"

Include dependency graph for gnunet-service-dht.h:

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

Go to the source code of this file.

Macros
#define	DEBUG_DHT   GNUNET_EXTRA_LOGGING
#define	MINIMUM_LOG_NSE   0.5
	Floor for the log of the network size estimate, and the value we use before the NSE service has told us anything.

Functions
void	GDS_u_try_connect (const struct GNUNET_PeerIdentity *pid, const char *address)
	Ask all underlays to connect to peer pid at address.
void	GDS_u_send (struct GDS_Underlay *u, struct GNUNET_DHTU_Target *target, const void *msg, size_t msg_size, GNUNET_SCHEDULER_TaskCallback finished_cb, void *finished_cb_cls)
	Send message to some other participant over the network.
void	GDS_u_drop (struct GDS_Underlay *u, struct GNUNET_DHTU_PreferenceHandle *ph)
	Drop a hold ph from underlay u.
struct GNUNET_DHTU_PreferenceHandle *	GDS_u_hold (struct GDS_Underlay *u, struct GNUNET_DHTU_Target *target)
	Create a hold on target at underlay u.
bool	GDS_CLIENTS_handle_reply (const struct GNUNET_DATACACHE_Block *bd, const struct GNUNET_HashCode *query_hash, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *get_path)
	Handle a reply we've received from another peer.
void	GDS_CLIENTS_process_get (enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, const struct GNUNET_HashCode *key)
	Check if some client is monitoring GET messages and notify them in that case.
void	GDS_CLIENTS_process_get_resp (const struct GNUNET_DATACACHE_Block *bd, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length)
	Check if some client is monitoring GET RESP messages and notify them in that case.
void	GDS_CLIENTS_process_put (const struct GNUNET_DATACACHE_Block *bd, uint32_t hop_count, uint32_t desired_replication_level)
	Check if some client is monitoring PUT messages and notify them in that case.
void	GDS_CLIENTS_retry_requests (void)
	Our routing table gained a peer.
void	GDS_CLIENTS_retry_puts (void)
	Our routing table gained a peer.
double	GDS_NSE_get (void)
	Return the current NSE.

Variables
const struct GNUNET_CONFIGURATION_Handle *	GDS_cfg
	Configuration we use.
struct GNUNET_SERVICE_Handle *	GDS_service
	Handle for the service.
struct GNUNET_BLOCK_Context *	GDS_block_context
	Our handle to the BLOCK library.
struct GNUNET_STATISTICS_Handle *	GDS_stats
	Handle for the statistics service.
struct GNUNET_PILS_Handle *	GDS_pils
	Handle for the pils service.
struct GNUNET_MessageHeader *	GDS_my_hello
	Our HELLO parser.

Detailed Description

GNUnet DHT globals.

Author

Christian Grothoff

Definition in file gnunet-service-dht.h.

Macro Definition Documentation

DEBUG_DHT

#define DEBUG_DHT   GNUNET_EXTRA_LOGGING

Definition at line 35 of file gnunet-service-dht.h.

MINIMUM_LOG_NSE

#define MINIMUM_LOG_NSE   0.5

Floor for the log of the network size estimate, and the value we use before the NSE service has told us anything.

Routing divides by the estimate and drops requests whose hop count exceeds a multiple of it, so zero is not a usable "unknown".

Definition at line 201 of file gnunet-service-dht.h.

Function Documentation

GDS_u_try_connect()

void GDS_u_try_connect	(	const struct GNUNET_PeerIdentity *	pid,
		const char *	address
	)

Ask all underlays to connect to peer pid at address.

Parameters

pid	identity of the peer we would connect to
address	an address of pid

Definition at line 293 of file gnunet-service-dht.c.

{
  for (struct GDS_Underlay *u = u_head;
       NULL != u;
       u = u->next)
    u->dhtu->try_connect (u->dhtu->cls,
                          pid,
                          address);
}

References address, GDS_Underlay::next, u, and u_head.

Referenced by GDS_try_connect().

Here is the caller graph for this function:

GDS_u_send()

void GDS_u_send	(	struct GDS_Underlay *	u,
		struct GNUNET_DHTU_Target *	target,
		const void *	msg,
		size_t	msg_size,
		GNUNET_SCHEDULER_TaskCallback	finished_cb,
		void *	finished_cb_cls
	)

Send message to some other participant over the network.

Note that sending is not guaranteeing that the other peer actually received the message. For any given target, the DHT must wait for the finished_cb to be called before calling send() again.

Parameters

u	underlay to use for transmission
target	receiver identification
msg	message
msg_size	number of bytes in msg
finished_cb	function called once transmission is done (not called if target disconnects, then only the disconnect_cb is called).
finished_cb_cls	closure for finished_cb

Definition at line 306 of file gnunet-service-dht.c.

{
  u->dhtu->send (u->dhtu->cls,
                 target,
                 msg,
                 msg_size,
                 finished_cb,
                 finished_cb_cls);
}

References finished_cb(), msg, and u.

Referenced by do_send().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_u_drop()

void GDS_u_drop	(	struct GDS_Underlay *	u,
		struct GNUNET_DHTU_PreferenceHandle *	ph
	)

Drop a hold ph from underlay u.

Parameters

u	the underlay controlling the hold
ph	the preference handle

Definition at line 323 of file gnunet-service-dht.c.

{
  u->dhtu->drop (ph);
}

References u.

Referenced by GDS_u_disconnect().

Here is the caller graph for this function:

GDS_u_hold()

struct GNUNET_DHTU_PreferenceHandle * GDS_u_hold	(	struct GDS_Underlay *	u,
		struct GNUNET_DHTU_Target *	target
	)

Create a hold on target at underlay u.

Parameters

u	the underlay controlling the target
target	the peer to hold the connection to

Definition at line 331 of file gnunet-service-dht.c.

{
  return u->dhtu->hold (u->dhtu->cls,
                        target);
}

References GNUNET_DHTU_PreferenceHandle::target, and u.

Referenced by update_hold().

Here is the caller graph for this function:

GDS_CLIENTS_handle_reply()

bool GDS_CLIENTS_handle_reply	(	const struct GNUNET_DATACACHE_Block *	bd,
		const struct GNUNET_HashCode *	query_hash,
		unsigned int	get_path_length,
		const struct GNUNET_DHT_PathElement *	get_path
	)

Handle a reply we've received from another peer.

If the reply matches any of our pending queries, forward it to the respective client(s).

Parameters

bd	block details
query_hash	hash of the original query, might not match key in bd
get_path_length	number of entries in get_path
get_path	path the reply has taken

Returns

true on success, false on failures

Definition at line 1449 of file gnunet-service-dht_clients.c.

{
  struct ForwardReplyContext frc;
  size_t msize = sizeof (struct GNUNET_DHT_ClientResultMessage)
                 + bd->data_size
                 + (get_path_length + bd->put_path_length)
                 * sizeof(struct GNUNET_DHT_PathElement);
#if SANITY_CHECKS > 1
  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
#endif
 
  if (msize >= GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return false;
  }
#if SANITY_CHECKS > 1
  {
    const struct GNUNET_PeerIdentity *my_identity;
    my_identity = GNUNET_PILS_get_identity (GDS_pils);
    GNUNET_assert (NULL != my_identity);
    if (0 !=
        GNUNET_DHT_verify_path (bd->data,
                                bd->data_size,
                                bd->expiration_time,
                                truncated
                                ? &bd->trunc_peer
                                : NULL,
                                bd->put_path,
                                bd->put_path_length,
                                get_path,
                                get_path_length,
                                my_identity))
    {
      GNUNET_break (0);
      return false;
    }
  }
#endif
  frc.bd = bd;
  frc.get_path = get_path;
  frc.get_path_length = get_path_length;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Forwarding reply for query hash %s with GPL %u and PPL %u to client\n",
       GNUNET_h2s (query_hash),
       get_path_length,
       bd->put_path_length);
  if (0 ==
      GNUNET_CONTAINER_multihashmap_get_multiple (forward_map,
                                                  query_hash,
                                                  &forward_reply,
                                                  &frc))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "No matching client for reply for query %s\n",
         GNUNET_h2s (query_hash));
    GNUNET_STATISTICS_update (GDS_stats,
                              "# REPLIES ignored for CLIENTS (no match)",
                              1,
                              GNUNET_NO);
  }
  return true;
}

References ForwardReplyContext::bd, GNUNET_DATACACHE_Block::data, data_size, GNUNET_DATACACHE_Block::data_size, GNUNET_DATACACHE_Block::expiration_time, forward_map, forward_reply(), GDS_pils, GDS_stats, ForwardReplyContext::get_path, GNUNET_DHT_ClientResultMessage::get_path_length, ForwardReplyContext::get_path_length, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_DHT_RO_TRUNCATED, GNUNET_DHT_verify_path(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_STATISTICS_update(), LOG, my_identity, GNUNET_DATACACHE_Block::put_path, GNUNET_DATACACHE_Block::put_path_length, GNUNET_DHT_ClientResultMessage::put_path_length, GNUNET_DATACACHE_Block::ro, and GNUNET_DATACACHE_Block::trunc_peer.

Referenced by handle_dht_local_put(), handle_dht_p2p_put(), handle_local_result(), and process_reply_with_path().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_process_get()

void GDS_CLIENTS_process_get	(	enum GNUNET_DHT_RouteOption	options,
		enum GNUNET_BLOCK_Type	type,
		uint32_t	hop_count,
		uint32_t	desired_replication_level,
		const struct GNUNET_HashCode *	key
	)

Check if some client is monitoring GET messages and notify them in that case.

If tracked, path should include the local peer.

Parameters

options	Options, for instance RecordRoute, DemultiplexEverywhere.
type	The type of data in the request.
hop_count	Hop count so far.
desired_replication_level	Desired replication level.
key	Key of the requested data.

Definition at line 1813 of file gnunet-service-dht_clients.c.

{
  struct GetActionContext gac = {
    .options = options,
    .type = type,
    .hop_count = hop_count,
    .desired_replication_level = desired_replication_level,
    .key = key
  };
 
  for_matching_monitors (type,
                         key,
                         &get_action,
                         &gac);
}

References GetActionContext::desired_replication_level, for_matching_monitors(), get_action(), GetActionContext::hop_count, key, options, GetActionContext::options, and type.

Referenced by cb_handle_dht_p2p_get_local_result(), and handle_dht_local_get().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_process_get_resp()

void GDS_CLIENTS_process_get_resp	(	const struct GNUNET_DATACACHE_Block *	bd,
		const struct GNUNET_DHT_PathElement *	get_path,
		unsigned int	get_path_length
	)

Check if some client is monitoring GET RESP messages and notify them in that case.

Parameters

bd	block details
get_path	Peers on GET path (or NULL if not recorded).
get_path_length	number of entries in get_path.

Definition at line 1907 of file gnunet-service-dht_clients.c.

{
  struct ResponseActionContext rac = {
    .bd = bd,
    .get_path = get_path,
    .get_path_length = get_path_length
  };
 
  for_matching_monitors (bd->type,
                         &bd->key,
                         &response_action,
                         &rac);
}

References ResponseActionContext::bd, for_matching_monitors(), ResponseActionContext::get_path, ResponseActionContext::get_path_length, GNUNET_DATACACHE_Block::key, response_action(), and GNUNET_DATACACHE_Block::type.

Referenced by process_reply_with_path().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_process_put()

void GDS_CLIENTS_process_put	(	const struct GNUNET_DATACACHE_Block *	bd,
		uint32_t	hop_count,
		uint32_t	desired_replication_level
	)

Check if some client is monitoring PUT messages and notify them in that case.

The path should include our own peer ID (if recorded).

Parameters

bd	details about the block
hop_count	Hop count so far.
desired_replication_level	Desired replication level.

Definition at line 1995 of file gnunet-service-dht_clients.c.

{
  struct PutActionContext put_ctx = {
    .bd = bd,
    .hop_count = hop_count,
    .desired_replication_level = desired_replication_level
  };
 
  for_matching_monitors (bd->type,
                         &bd->key,
                         &put_action,
                         &put_ctx);
}

References PutActionContext::bd, PutActionContext::desired_replication_level, for_matching_monitors(), PutActionContext::hop_count, GNUNET_DATACACHE_Block::key, put_action(), and GNUNET_DATACACHE_Block::type.

Referenced by cb_forwarded_dht_p2p_put(), and handle_dht_local_put().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_retry_requests()

void GDS_CLIENTS_retry_requests

(

void

)

Our routing table gained a peer.

Reset the retry back-off of all pending client GET requests and re-transmit them now: a request that found no route earlier has been backing off for up to 15 minutes without ever reaching the network.

Definition at line 623 of file gnunet-service-dht_clients.c.

{
  if (0 == GNUNET_CONTAINER_multihashmap_size (forward_map))
    return;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Routing table changed, re-transmitting %u pending GET request(s)\n",
       GNUNET_CONTAINER_multihashmap_size (forward_map));
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET requests retried after routing table change",
                            GNUNET_CONTAINER_multihashmap_size (forward_map),
                            GNUNET_NO);
  GNUNET_CONTAINER_multihashmap_iterate (forward_map,
                                         &reset_retry_backoff,
                                         NULL);
  if (NULL != retry_task)
    GNUNET_SCHEDULER_cancel (retry_task);
  retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task,
                                         NULL);
}

References forward_map, GDS_stats, GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), LOG, reset_retry_backoff(), retry_task, and transmit_next_request_task().

Referenced by GDS_u_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_retry_puts()

void GDS_CLIENTS_retry_puts

(

void

)

Our routing table gained a peer.

Re-try the local PUTs that we were unable to route: nothing else will, as the DHT keeps no state about a PUT and the client was told the operation succeeded.

Definition at line 803 of file gnunet-service-dht_clients.c.

{
  if (NULL == pp_head)
    return;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Routing table changed, re-trying %u unrouted PUT(s)\n",
       pp_count);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# PUT requests retried after routing table change",
                            pp_count,
                            GNUNET_NO);
  for (struct PendingPut *pp = pp_head; NULL != pp; pp = pp->next)
  {
    pp->retry_frequency = GNUNET_TIME_UNIT_SECONDS;
    pp->retry_time = GNUNET_TIME_absolute_get ();
  }
  schedule_put_retry ();
}

References GDS_stats, GNUNET_ERROR_TYPE_DEBUG, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_SECONDS, LOG, PendingPut::next, pp_count, pp_head, and schedule_put_retry().

Referenced by GDS_u_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_NSE_get()

double GDS_NSE_get

(

void

)

Return the current NSE.

Returns

the current NSE as a logarithm

Definition at line 229 of file gnunet-service-dht.c.

{
  return log_of_network_size_estimate;
}

References log_of_network_size_estimate.

Referenced by get_forward_count(), handle_find_local_hello(), and select_peer().

Here is the caller graph for this function:

Variable Documentation

GDS_cfg

const struct GNUNET_CONFIGURATION_Handle* GDS_cfg

extern

Configuration we use.

Configuration we use.

Definition at line 290 of file gnunet-service-dht_clients.c.

Referenced by GDS_DATACACHE_init(), GDS_NEIGHBOURS_init(), load_underlay(), pid_change_cb(), and run().

GDS_service

struct GNUNET_SERVICE_Handle* GDS_service

extern

Handle for the service.

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

Referenced by pid_change_cb(), and run().

GDS_block_context

struct GNUNET_BLOCK_Context* GDS_block_context

extern

Our handle to the BLOCK library.

Definition at line 270 of file gnunet-service-dht_clients.c.

Referenced by datacache_get_iterator(), forward_reply(), handle_dht_local_put(), handle_dht_p2p_get(), handle_dht_p2p_put(), handle_dht_p2p_result(), handle_find_local_hello(), handle_find_my_hello(), process(), run(), send_find_peer_message(), shutdown_task(), and transmit_request().

GDS_stats

struct GNUNET_STATISTICS_Handle* GDS_stats

extern

Handle for the statistics service.

Definition at line 275 of file gnunet-service-dht_clients.c.

Referenced by cb_forwarded_dht_local_put(), cb_routing_put_message(), datacache_get_iterator(), do_send(), expire_oldest_entry(), forward_reply(), GDS_CLIENTS_handle_reply(), GDS_CLIENTS_retry_puts(), GDS_CLIENTS_retry_requests(), GDS_DATACACHE_get_closest(), GDS_DATACACHE_handle_get(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), GDS_NEIGHBOURS_handle_reply(), GDS_ROUTING_add(), GDS_u_connect(), GDS_u_disconnect(), get_forward_count(), handle_dht_local_get(), handle_dht_local_get_stop(), handle_dht_local_put(), handle_dht_p2p_get(), handle_dht_p2p_put(), handle_dht_p2p_result(), handle_find_my_hello(), process(), run(), select_peer(), send_find_peer_message(), shutdown_task(), transmit_request(), and update_network_size_estimate().

GDS_pils

struct GNUNET_PILS_Handle* GDS_pils

extern

Handle for the pils service.

(may be NULL but needed for linking)

Definition at line 40 of file gnunet-dht-tvg.c.

Referenced by forward_reply(), GDS_CLIENTS_handle_reply(), handle_dht_local_get(), handle_dht_local_hello_get(), handle_dht_local_put(), and run().

GDS_my_hello

struct GNUNET_MessageHeader* GDS_my_hello

extern

Our HELLO parser.

Our HELLO parser.

Definition at line 153 of file gnunet-service-dht.c.

Referenced by handle_dht_local_hello_get(), handle_find_my_hello(), pid_change_cb(), and shutdown_task().