GNUnet DHT service's client management code. More...

#include "gnunet-service-dht_clients.h"
#include "gnunet_pils_service.h"
#include "gnunet_util_lib.h"

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

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

Data Structures
struct	ClientQueryRecord
	Entry in the local forwarding map for a client's GET request. More...

struct	ClientMonitorRecord
	Struct containing parameters of monitoring requests. More...

struct	ClientHandle
	Struct containing information about a client, handle to connect to it, and any pending messages that need to be sent to it. More...

struct	FindByUniqueIdContext
	Closure for find_by_unique_id(). More...

struct	RemoveByUniqueIdContext
	Closure for remove_by_unique_id(). More...

struct	ForwardReplyContext
	Closure for forward_reply() More...

struct	GetActionContext
	Closure for get_action();. More...

struct	ResponseActionContext
	Closure for response_action(). More...

struct	PutActionContext
	Closure for put_action(). More...

Macros
#define	SANITY_CHECKS 0
	Enable slow sanity checks to debug issues.

#define	LOG_TRAFFIC(kind, ...)
	Should routing details be logged to stderr (for debugging)?

#define	LOG(kind, ...) GNUNET_log_from (kind, "dht-clients", __VA_ARGS__)

#define	GDS_DHT_SERVICE_INIT(name, run)
	Define "main" method using service macro.

Typedefs
typedef void(*	MonitorAction) (void cls, struct ClientMonitorRecord m)
	Function to call by for_matching_monitors().

Functions
static void	remove_client_query_record (struct ClientQueryRecord *record)
	Free data structures associated with the given query.

static void *	client_connect_cb (void cls, struct GNUNET_SERVICE_Client client, struct GNUNET_MQ_Handle *mq)
	Functions with this signature are called whenever a local client is connects to us.

static void	client_disconnect_cb (void cls, struct GNUNET_SERVICE_Client client, void *app_ctx)
	Functions with this signature are called whenever a client is disconnected on the network level.

static void	transmit_request (struct ClientQueryRecord *cqr)
	Route the given request via the DHT.

static void	transmit_next_request_task (void *cls)
	Task that looks at the retry_heap and transmits all of the requests on the heap that are ready for transmission.

static enum GNUNET_GenericReturnValue	check_dht_local_put (void cls, const struct GNUNET_DHT_ClientPutMessage dht_msg)
	Check DHT PUT messages from the client.

static void	cb_forwarded_dht_local_put (void *cls, enum GNUNET_GenericReturnValue forwarded)

static void	handle_dht_local_put (void cls, const struct GNUNET_DHT_ClientPutMessage dht_msg)
	Handler for PUT messages.

static void	handle_local_result (void cls, const struct GNUNET_DATACACHE_Block bd)
	Handle a result from local datacache for a GET operation.

static enum GNUNET_GenericReturnValue	check_dht_local_get (void cls, const struct GNUNET_DHT_ClientGetMessage get)
	Check DHT GET messages from the client.

static void	handle_dht_local_get (void cls, const struct GNUNET_DHT_ClientGetMessage get)
	Handler for DHT GET messages from the client.

static enum GNUNET_GenericReturnValue	find_by_unique_id (void cls, const struct GNUNET_HashCode key, void *value)
	Function called for each existing DHT record for the given query.

static enum GNUNET_GenericReturnValue	check_dht_local_get_result_seen (void cls, const struct GNUNET_DHT_ClientGetResultSeenMessage seen)
	Check "GET result seen" messages from the client.

static void	handle_dht_local_get_result_seen (void cls, const struct GNUNET_DHT_ClientGetResultSeenMessage seen)
	Handler for "GET result seen" messages from the client.

static enum GNUNET_GenericReturnValue	remove_by_unique_id (void cls, const struct GNUNET_HashCode key, void *value)
	Iterator over hash map entries that frees all entries that match the given client and unique ID.

static void	handle_dht_local_get_stop (void cls, const struct GNUNET_DHT_ClientGetStopMessage dht_stop_msg)
	Handler for any generic DHT stop messages, calls the appropriate handler depending on message type (if processed locally)

static enum GNUNET_GenericReturnValue	forward_reply (void cls, const struct GNUNET_HashCode query_hash, void *value)
	Iterator over hash map entries that send a given reply to each of the matching clients.

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.

static void	handle_dht_local_hello_get (void cls, const struct GNUNET_MessageHeader msg)
	Handler for HELLO GET message.

static enum GNUNET_GenericReturnValue	check_dht_local_hello_offer (void cls, const struct GNUNET_MessageHeader hdr)
	Process a client HELLO message received from the service.

static void	handle_dht_local_hello_offer (void cls, const struct GNUNET_MessageHeader msg)
	Handler for HELLO OFFER message.

static void	handle_dht_local_monitor (void cls, const struct GNUNET_DHT_MonitorStartStopMessage msg)
	Handler for monitor start messages.

static void	handle_dht_local_monitor_stop (void cls, const struct GNUNET_DHT_MonitorStartStopMessage msg)
	Handler for monitor stop messages.

static void	for_matching_monitors (enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode key, MonitorAction cb, void cb_cls)
	Call cb on all monitors that watch for blocks of type and key key.

static void	get_action (void cls, struct ClientMonitorRecord m)
	Function called on monitors that match a 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.

static void	response_action (void cls, struct ClientMonitorRecord m)
	Function called on monitors that match a response.

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.

static void	put_action (void cls, struct ClientMonitorRecord m)
	Function called on monitors that match a 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.

void	GDS_CLIENTS_init (void)
	Initialize client subsystem.

void	GDS_CLIENTS_stop (void)
	Shutdown client subsystem.

void	GDS_CLIENTS_done (void)

void	__attribute__ ((destructor))
	MINIMIZE heap size (way below 128k) since this process doesn't need much.

Variables
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_SERVICE_Handle *	GDS_service
	Handle for the service.

const struct GNUNET_CONFIGURATION_Handle *	GDS_cfg
	The configuration the DHT service is running with.

static struct ClientMonitorRecord *	monitor_head
	List of active monitoring requests.

static struct ClientMonitorRecord *	monitor_tail
	List of active monitoring requests.

static struct GNUNET_CONTAINER_MultiHashMap *	forward_map
	Hashmap for fast key based lookup, maps keys to `struct ClientQueryRecord` entries.

static struct GNUNET_CONTAINER_Heap *	retry_heap
	Heap with all of our client's request, sorted by retry time (earliest on top).

static struct GNUNET_SCHEDULER_Task *	retry_task
	Task that re-transmits requests (using retry_heap).

Detailed Description

GNUnet DHT service's client management code.

Author: Christian Grothoff; Nathan Evans

Definition in file gnunet-service-dht_clients.c.

Macro Definition Documentation

◆ SANITY_CHECKS

#define SANITY_CHECKS 0

Enable slow sanity checks to debug issues.

0: do not check 1: check all external inputs 2: check internal computations as well

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

◆ LOG_TRAFFIC

#define LOG_TRAFFIC	(	kind,
		...
	)

Value:

GNUNET_log_from (kind, "dht-traffic", \

__VA_ARGS__)

GNUNET_log_from

#define GNUNET_log_from(kind, comp,...)

Definition gnunet_common.h:525

Should routing details be logged to stderr (for debugging)?

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

◆ LOG

#define LOG	(	kind,
		...
	)	GNUNET_log_from (kind, "dht-clients", __VA_ARGS__)

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

◆ GDS_DHT_SERVICE_INIT

#define GDS_DHT_SERVICE_INIT	(	name,
		run
	)

Define "main" method using service macro.

Parameters

name	name of the service, like "dht" or "xdht"
run	name of the initialization method for the service

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

Typedef Documentation

◆ MonitorAction

typedef void(* MonitorAction) (void *cls, struct ClientMonitorRecord *m)

Function to call by for_matching_monitors().

Parameters

cls	closure
m	a matching monitor

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

Function Documentation

◆ remove_client_query_record()

static void remove_client_query_record ( struct ClientQueryRecord * record )

static

Free data structures associated with the given query.

Parameters

record record to remove

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

{
  struct ClientHandle *ch = record->ch;
 
  GNUNET_CONTAINER_DLL_remove (ch->cqr_head,
                               ch->cqr_tail,
                               record);
  GNUNET_assert (GNUNET_YES ==
                 GNUNET_CONTAINER_multihashmap_remove (forward_map,
                                                       &record->key,
                                                       record));
  if (NULL != record->hnode)
    GNUNET_CONTAINER_heap_remove_node (record->hnode);
  GNUNET_array_grow (record->seen_replies,
                     record->seen_replies_count,
                     0);
  GNUNET_free (record);
}

References ch, forward_map, GNUNET_array_grow, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_YES, and record().

Referenced by client_disconnect_cb(), forward_reply(), and remove_by_unique_id().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ client_connect_cb()

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

static

Functions with this signature are called whenever a local client is connects to us.

Parameters

cls	closure (NULL for dht)
client	identification of the client
mq	message queue for talking to client

Returns: our struct ClientHandle for client

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

{
  struct ClientHandle *ch;
 
  (void) cls;
  ch = GNUNET_new (struct ClientHandle);
  ch->client = client;
  ch->mq = mq;
  return ch;
}

References ch, ClientHandle::client, GNUNET_new, mq, and GNUNET_CADET_Channel::mq.

◆ client_disconnect_cb()

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

static

Functions with this signature are called whenever a client is disconnected on the network level.

Parameters

cls	closure (NULL for dht)
client	identification of the client
app_ctx	our `struct ClientHandle` for client

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

{
  struct ClientHandle *ch = app_ctx;
 
  (void) cls;
  (void) client;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Local client %p disconnects\n",
              ch);
  {
    struct ClientMonitorRecord *next;
 
    for (struct ClientMonitorRecord *monitor = monitor_head;
         NULL != monitor;
         monitor = next)
    {
      next = monitor->next;
      if (monitor->ch != ch)
        continue;
      GNUNET_CONTAINER_DLL_remove (monitor_head,
                                   monitor_tail,
                                   monitor);
      GNUNET_free (monitor);
    }
  }
 
  {
    struct ClientQueryRecord *cqr;
 
    while (NULL != (cqr = ch->cqr_head))
      remove_client_query_record (cqr);
  }
  GNUNET_free (ch);
}

References ch, ClientHandle::client, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, monitor, monitor_head, monitor_tail, ClientMonitorRecord::next, and remove_client_query_record().

Here is the call graph for this function:

◆ transmit_request()

static void transmit_request ( struct ClientQueryRecord * cqr )

static

Route the given request via the DHT.

This includes updating the bloom filter and retransmission times, building the P2P message and initiating the routing operation.

Parameters

cqr	request to transmit

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

{
  struct GNUNET_BLOCK_Group *bg;
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;
 
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET requests from clients injected",
                            1,
                            GNUNET_NO);
  bg = GNUNET_BLOCK_group_create (GDS_block_context,
                                  cqr->type,
                                  NULL, /* raw data */
                                  0, /* raw data size */
                                  "seen-set-size",
                                  cqr->seen_replies_count,
                                  NULL);
  GNUNET_BLOCK_group_set_seen (bg,
                               cqr->seen_replies,
                               cqr->seen_replies_count);
  peer_bf
    = GNUNET_CONTAINER_bloomfilter_init (NULL,
                                         DHT_BLOOM_SIZE,
                                         GNUNET_CONSTANTS_BLOOMFILTER_K);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Initiating GET for %s, replication %u, already have %u replies\n",
       GNUNET_h2s (&cqr->key),
       cqr->replication,
       cqr->seen_replies_count);
  GDS_NEIGHBOURS_handle_get (cqr->type,
                             cqr->msg_options,
                             cqr->replication,
                             0 /* hop count */,
                             &cqr->key,
                             cqr->xquery,
                             cqr->xquery_size,
                             bg,
                             peer_bf);
  GNUNET_BLOCK_group_destroy (bg);
  GNUNET_CONTAINER_bloomfilter_free (peer_bf);
 
  /* Exponential back-off for retries.
   * max. is #GNUNET_TIME_STD_EXPONENTIAL_BACKOFF_THRESHOLD (15 min) */
  cqr->retry_frequency = GNUNET_TIME_STD_BACKOFF (cqr->retry_frequency);
  cqr->retry_time = GNUNET_TIME_relative_to_absolute (cqr->retry_frequency);
}

Referenced by transmit_next_request_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ transmit_next_request_task()

static void transmit_next_request_task ( void * cls )

static

Task that looks at the retry_heap and transmits all of the requests on the heap that are ready for transmission.

Then re-schedules itself (unless the heap is empty).

Parameters

cls unused

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

{
  struct ClientQueryRecord *cqr;
 
  (void) cls;
  retry_task = NULL;
  while (NULL != (cqr = GNUNET_CONTAINER_heap_remove_root (retry_heap)))
  {
    cqr->hnode = NULL;
    if (! GNUNET_TIME_absolute_is_past (cqr->retry_time))
    {
      cqr->hnode
        = GNUNET_CONTAINER_heap_insert (retry_heap,
                                        cqr,
                                        cqr->retry_time.abs_value_us);
      retry_task
        = GNUNET_SCHEDULER_add_at (cqr->retry_time,
                                   &transmit_next_request_task,
                                   NULL);
      return;
    }
    transmit_request (cqr);
    cqr->hnode
      = GNUNET_CONTAINER_heap_insert (retry_heap,
                                      cqr,
                                      cqr->retry_time.abs_value_us);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_SCHEDULER_add_at(), GNUNET_TIME_absolute_is_past(), ClientQueryRecord::hnode, retry_heap, retry_task, ClientQueryRecord::retry_time, transmit_next_request_task(), and transmit_request().

Referenced by handle_dht_local_get(), and transmit_next_request_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_dht_local_put()

static enum GNUNET_GenericReturnValue check_dht_local_put	(	void *	cls,
		const struct GNUNET_DHT_ClientPutMessage *	dht_msg
	)

static

Check DHT PUT messages from the client.

Parameters

cls	the client we received this message from
dht_msg	the actual message received

Returns: GNUNET_OK (always)

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

{
  uint32_t replication_level = ntohl (dht_msg->desired_replication_level);
 
  (void) cls;
  if (replication_level > GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_DHT_ClientPutMessage::desired_replication_level, GNUNET_break_op, GNUNET_DHT_MAXIMUM_REPLICATION_LEVEL, GNUNET_OK, GNUNET_SYSERR, and replication_level.

◆ cb_forwarded_dht_local_put()

static void cb_forwarded_dht_local_put	(	void *	cls,
		enum GNUNET_GenericReturnValue	forwarded
	)

static

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

{
  if (GNUNET_OK != forwarded)
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Local PUT requests not routed",
                              1,
                              GNUNET_NO);
  }
}

References GDS_stats, GNUNET_NO, GNUNET_OK, and GNUNET_STATISTICS_update().

Referenced by handle_dht_local_put().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_dht_local_put()

static void handle_dht_local_put	(	void *	cls,
		const struct GNUNET_DHT_ClientPutMessage *	dht_msg
	)

static

Handler for PUT messages.

Parameters

cls	the client we received this message from
dht_msg	the actual message received

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

{
  struct ClientHandle *ch = cls;
  uint16_t size = ntohs (dht_msg->header.size);
  uint32_t replication_level
    = ntohl (dht_msg->desired_replication_level);
  struct GNUNET_DATACACHE_Block bd = {
    .key = dht_msg->key,
    .expiration_time = GNUNET_TIME_absolute_ntoh (dht_msg->expiration),
    .data = &dht_msg[1],
    .data_size = size - sizeof (*dht_msg),
    .type = ntohl (dht_msg->type),
    .ro = ntohl (dht_msg->options)
  };
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Handling local PUT of %lu-bytes for query %s of type %u\n",
       (unsigned long) (size - sizeof(struct GNUNET_DHT_ClientPutMessage)),
       GNUNET_h2s (&dht_msg->key),
       (unsigned int) bd.type);
#if SANITY_CHECKS > 0
  if (GNUNET_OK !=
      GNUNET_BLOCK_check_block (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size))
  {
    GNUNET_break (0);
    return;
  }
#endif
  GNUNET_STATISTICS_update (GDS_stats,
                            "# PUT requests received from clients",
                            1,
                            GNUNET_NO);
  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG,
               "CLIENT-PUT %s\n",
               GNUNET_h2s_full (&dht_msg->key));
  /* give to local clients */
  GNUNET_break (GDS_CLIENTS_handle_reply (&bd,
                                          &bd.key,
                                          0, NULL /* get path */));
 
  {
    struct GNUNET_CONTAINER_BloomFilter *peer_bf;
 
    peer_bf
      = GNUNET_CONTAINER_bloomfilter_init (NULL,
                                           DHT_BLOOM_SIZE,
                                           GNUNET_CONSTANTS_BLOOMFILTER_K);
    /* store locally */
    if ( (0 != (bd.ro & GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE)) ||
         (GDS_am_closest_peer (&dht_msg->key,
                               peer_bf)))
      GDS_DATACACHE_handle_put (&bd);
    /* route to other peers */
    GDS_NEIGHBOURS_handle_put (&bd,
                               replication_level,
                               0 /* hop count */,
                               peer_bf,
                               &cb_forwarded_dht_local_put,
                               NULL);
    GNUNET_CONTAINER_bloomfilter_free (peer_bf);
  }
  GDS_CLIENTS_process_put (
    &bd,
    0,  /* hop count */
    replication_level);
  GNUNET_SERVICE_client_continue (ch->client);
}

References cb_forwarded_dht_local_put(), ch, GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, GNUNET_DHT_ClientPutMessage::desired_replication_level, DHT_BLOOM_SIZE, GNUNET_DHT_ClientPutMessage::expiration, GDS_am_closest_peer(), GDS_block_context, GDS_CLIENTS_handle_reply(), GDS_CLIENTS_process_put(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_handle_put(), GDS_stats, GNUNET_BLOCK_check_block(), GNUNET_break, GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GNUNET_DHT_ClientPutMessage::header, GNUNET_DATACACHE_Block::key, GNUNET_DHT_ClientPutMessage::key, LOG, LOG_TRAFFIC, GNUNET_DHT_ClientPutMessage::options, replication_level, GNUNET_DATACACHE_Block::ro, GNUNET_MessageHeader::size, size, GNUNET_DATACACHE_Block::type, and GNUNET_DHT_ClientPutMessage::type.

Here is the call graph for this function:

◆ handle_local_result()

static void handle_local_result	(	void *	cls,
		const struct GNUNET_DATACACHE_Block *	bd
	)

static

Handle a result from local datacache for a GET operation.

Parameters

cls	the `struct ClientHandle` of the client doing the query
bd	details about the block that was found

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

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Datacache provided result for query key %s\n",
              GNUNET_h2s (&bd->key));
  GNUNET_break (GDS_CLIENTS_handle_reply (bd,
                                          &bd->key,
                                          0, NULL /* get_path */));
}

References GDS_CLIENTS_handle_reply(), GNUNET_break, GNUNET_ERROR_TYPE_INFO, GNUNET_h2s(), GNUNET_log, and GNUNET_DATACACHE_Block::key.

Referenced by handle_dht_local_get().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_dht_local_get()

static enum GNUNET_GenericReturnValue check_dht_local_get	(	void *	cls,
		const struct GNUNET_DHT_ClientGetMessage *	get
	)

static

Check DHT GET messages from the client.

Parameters

cls	the client we received this message from
get	the actual message received

Returns: GNUNET_OK (always)

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

{
  (void) cls;
  (void) get;
  /* always well-formed */
  return GNUNET_OK;
}

References get, and GNUNET_OK.

◆ handle_dht_local_get()

static void handle_dht_local_get	(	void *	cls,
		const struct GNUNET_DHT_ClientGetMessage *	get
	)

static

Handler for DHT GET messages from the client.

Parameters

cls	the client we received this message from
get	the actual message received

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

{
  struct ClientHandle *ch = cls;
  struct ClientQueryRecord *cqr;
  uint16_t size = ntohs (get->header.size);
  const char *xquery = (const char *) &get[1];
  size_t xquery_size = size - sizeof(struct GNUNET_DHT_ClientGetMessage);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received GET request for %s from local client %p, xq: %.*s\n",
       GNUNET_h2s (&get->key),
       ch->client,
       (int) xquery_size,
       xquery);
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET requests received from clients",
                            1,
                            GNUNET_NO);
  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG,
               "CLIENT-GET %s\n",
               GNUNET_h2s_full (&get->key));
 
  cqr = GNUNET_malloc (sizeof(struct ClientQueryRecord) + xquery_size);
  cqr->key = get->key;
  cqr->ch = ch;
  cqr->xquery = (const void *) &cqr[1];
  GNUNET_memcpy (&cqr[1],
                 xquery,
                 xquery_size);
  cqr->hnode = GNUNET_CONTAINER_heap_insert (retry_heap,
                                             cqr,
                                             0);
  cqr->retry_frequency = GNUNET_TIME_UNIT_SECONDS;
  cqr->retry_time = GNUNET_TIME_absolute_get ();
  cqr->unique_id = get->unique_id;
  cqr->xquery_size = xquery_size;
  cqr->replication = ntohl (get->desired_replication_level);
  cqr->msg_options = ntohl (get->options);
  cqr->type = ntohl (get->type);
  GNUNET_CONTAINER_DLL_insert (ch->cqr_head,
                               ch->cqr_tail,
                               cqr);
  GNUNET_CONTAINER_multihashmap_put (forward_map,
                                     &cqr->key,
                                     cqr,
                                     GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GDS_CLIENTS_process_get (cqr->msg_options,
                           cqr->type,
                           0, /* hop count */
                           cqr->replication,
                           &get->key);
  /* start remote requests */
  if (NULL != retry_task)
    GNUNET_SCHEDULER_cancel (retry_task);
  retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task,
                                         NULL);
  /* perform local lookup */
  GDS_DATACACHE_handle_get (&get->key,
                            cqr->type,
                            cqr->xquery,
                            xquery_size,
                            NULL,
                            &handle_local_result,
                            ch);
  GNUNET_SERVICE_client_continue (ch->client);
}

Here is the call graph for this function:

◆ find_by_unique_id()

static enum GNUNET_GenericReturnValue find_by_unique_id	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

static

Function called for each existing DHT record for the given query.

Checks if it matches the UID given in the closure and if so returns the entry as a result.

Parameters

cls	the search context
key	query for the lookup (not used)
value	the `struct ClientQueryRecord`

Returns: GNUNET_YES to continue iteration (result not yet found)

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

{
  struct FindByUniqueIdContext *fui_ctx = cls;
  struct ClientQueryRecord *cqr = value;
 
  if (cqr->unique_id != fui_ctx->unique_id)
    return GNUNET_YES;
  fui_ctx->cqr = cqr;
  return GNUNET_NO;
}

References FindByUniqueIdContext::cqr, GNUNET_NO, GNUNET_YES, ClientQueryRecord::unique_id, FindByUniqueIdContext::unique_id, and value.

Referenced by handle_dht_local_get_result_seen().

Here is the caller graph for this function:

◆ check_dht_local_get_result_seen()

static enum GNUNET_GenericReturnValue check_dht_local_get_result_seen	(	void *	cls,
		const struct GNUNET_DHT_ClientGetResultSeenMessage *	seen
	)

static

Check "GET result seen" messages from the client.

Parameters

cls	the client we received this message from
seen	the actual message received

Returns: GNUNET_OK if seen is well-formed

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

{
  uint16_t size = ntohs (seen->header.size);
  unsigned int hash_count =
    (size - sizeof(*seen))
    / sizeof(struct GNUNET_HashCode);
 
  if (size != sizeof(*seen) + hash_count * sizeof(struct GNUNET_HashCode))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

◆ handle_dht_local_get_result_seen()

static void handle_dht_local_get_result_seen	(	void *	cls,
		const struct GNUNET_DHT_ClientGetResultSeenMessage *	seen
	)

static

Handler for "GET result seen" messages from the client.

Parameters

cls	the client we received this message from
seen	the actual message received

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

{
  struct ClientHandle *ch = cls;
  uint16_t size = ntohs (seen->header.size);
  unsigned int hash_count = (size - sizeof(*seen))
                            / sizeof(struct GNUNET_HashCode);
  const struct GNUNET_HashCode *hc = (const struct GNUNET_HashCode*) &seen[1];
  struct FindByUniqueIdContext fui_ctx = {
    .unique_id = seen->unique_id
  };
  unsigned int old_count;
  struct ClientQueryRecord *cqr;
 
  GNUNET_CONTAINER_multihashmap_get_multiple (forward_map,
                                              &seen->key,
                                              &find_by_unique_id,
                                              &fui_ctx);
  if (NULL == (cqr = fui_ctx.cqr))
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (ch->client);
    return;
  }
  /* finally, update 'seen' list */
  old_count = cqr->seen_replies_count;
  GNUNET_array_grow (cqr->seen_replies,
                     cqr->seen_replies_count,
                     cqr->seen_replies_count + hash_count);
  GNUNET_memcpy (&cqr->seen_replies[old_count],
                 hc,
                 sizeof(struct GNUNET_HashCode) * hash_count);
}

References ch, FindByUniqueIdContext::cqr, find_by_unique_id(), forward_map, GNUNET_array_grow, GNUNET_break, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_memcpy, GNUNET_SERVICE_client_drop(), GNUNET_DHT_ClientGetResultSeenMessage::header, GNUNET_DHT_ClientGetResultSeenMessage::key, ClientQueryRecord::seen_replies, ClientQueryRecord::seen_replies_count, GNUNET_MessageHeader::size, size, GNUNET_DHT_ClientGetResultSeenMessage::unique_id, and FindByUniqueIdContext::unique_id.

Here is the call graph for this function:

◆ remove_by_unique_id()

static enum GNUNET_GenericReturnValue remove_by_unique_id	(	void *	cls,
		const struct GNUNET_HashCode *	key,
		void *	value
	)

static

Iterator over hash map entries that frees all entries that match the given client and unique ID.

Parameters

cls	unique ID and client to search for in source routes
key	current key code
value	value in the hash map, a ClientQueryRecord

Returns: GNUNET_YES (we should continue to iterate)

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

{
  const struct RemoveByUniqueIdContext *ctx = cls;
  struct ClientQueryRecord *cqr = value;
 
  if (cqr->unique_id != ctx->unique_id)
    return GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Removing client %p's record for key %s (by unique id)\n",
              ctx->ch->client,
              GNUNET_h2s (key));
  remove_client_query_record (cqr);
  return GNUNET_YES;
}

References ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_YES, key, remove_client_query_record(), ClientQueryRecord::unique_id, and value.

Referenced by handle_dht_local_get_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_dht_local_get_stop()

static void handle_dht_local_get_stop	(	void *	cls,
		const struct GNUNET_DHT_ClientGetStopMessage *	dht_stop_msg
	)

static

Handler for any generic DHT stop messages, calls the appropriate handler depending on message type (if processed locally)

Parameters

cls	client we received this message from
dht_stop_msg	the actual message received

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

{
  struct ClientHandle *ch = cls;
  struct RemoveByUniqueIdContext ctx;
 
  GNUNET_STATISTICS_update (GDS_stats,
                            "# GET STOP requests received from clients",
                            1,
                            GNUNET_NO);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received GET STOP request for %s from local client %p\n",
       GNUNET_h2s (&dht_stop_msg->key),
       ch->client);
  ctx.ch = ch;
  ctx.unique_id = dht_stop_msg->unique_id;
  GNUNET_CONTAINER_multihashmap_get_multiple (forward_map,
                                              &dht_stop_msg->key,
                                              &remove_by_unique_id,
                                              &ctx);
  GNUNET_SERVICE_client_continue (ch->client);
}

References ch, ctx, forward_map, GDS_stats, GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_DHT_ClientGetStopMessage::key, LOG, remove_by_unique_id(), and GNUNET_DHT_ClientGetStopMessage::unique_id.

Here is the call graph for this function:

◆ forward_reply()

static enum GNUNET_GenericReturnValue forward_reply	(	void *	cls,
		const struct GNUNET_HashCode *	query_hash,
		void *	value
	)

static

Iterator over hash map entries that send a given reply to each of the matching clients.

With some tricky recycling of the buffer.

Parameters

cls	the `struct ForwardReplyContext`
query_hash	hash of the query for which this may be a reply
value	value in the hash map, a ClientQueryRecord

Returns: GNUNET_YES (we should continue to iterate), if the result is mal-formed, GNUNET_NO

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

{
  struct ForwardReplyContext *frc = cls;
  struct ClientQueryRecord *record = value;
  const struct GNUNET_DATACACHE_Block *bd = frc->bd;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_ClientResultMessage *reply;
  enum GNUNET_BLOCK_ReplyEvaluationResult eval;
  bool do_free;
  struct GNUNET_HashCode ch;
  struct GNUNET_DHT_PathElement *paths;
  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
  size_t xsize = bd->data_size;
 
  LOG_TRAFFIC (GNUNET_ERROR_TYPE_DEBUG,
               "CLIENT-RESULT %s\n",
               GNUNET_h2s_full (&bd->key));
  if ( (record->type != GNUNET_BLOCK_TYPE_ANY) &&
       (record->type != bd->type) )
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Record type mismatch, not passing request for key %s to local client\n",
         GNUNET_h2s (&bd->key));
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Key match, type mismatches in REPLY to CLIENT",
                              1,
                              GNUNET_NO);
    return GNUNET_YES;          /* type mismatch */
  }
  if ( (0 == (record->msg_options & GNUNET_DHT_RO_FIND_APPROXIMATE)) &&
       (0 != GNUNET_memcmp (&bd->key,
                            query_hash)) )
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Inexact key match, but exact match required",
                              1,
                              GNUNET_NO);
    return GNUNET_YES;          /* type mismatch */
  }
  GNUNET_CRYPTO_hash (bd->data,
                      bd->data_size,
                      &ch);
  for (unsigned int i = 0; i < record->seen_replies_count; i++)
    if (0 ==
        GNUNET_memcmp (&record->seen_replies[i],
                       &ch))
    {
      LOG (GNUNET_ERROR_TYPE_DEBUG,
           "Duplicate reply, not passing request for key %s to local client\n",
           GNUNET_h2s (&bd->key));
      GNUNET_STATISTICS_update (GDS_stats,
                                "# Duplicate REPLIES to CLIENT request dropped",
                                1,
                                GNUNET_NO);
      return GNUNET_YES;        /* duplicate */
    }
  eval
    = GNUNET_BLOCK_check_reply (GDS_block_context,
                                record->type,
                                NULL,
                                &bd->key,
                                record->xquery,
                                record->xquery_size,
                                bd->data,
                                bd->data_size);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Evaluation result is %d for key %s for local client's query\n",
       (int) eval,
       GNUNET_h2s (&bd->key));
  switch (eval)
  {
  case GNUNET_BLOCK_REPLY_OK_LAST:
    do_free = true;
    break;
  case GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED:
  case GNUNET_BLOCK_REPLY_OK_MORE:
    GNUNET_array_append (record->seen_replies,
                         record->seen_replies_count,
                         ch);
    do_free = false;
    break;
  case GNUNET_BLOCK_REPLY_OK_DUPLICATE:
    /* should be impossible to encounter here */
    GNUNET_break (0);
    return GNUNET_YES;
  case GNUNET_BLOCK_REPLY_IRRELEVANT:
    return GNUNET_YES;
  default:
    GNUNET_break (0);
    return GNUNET_NO;
  }
  GNUNET_STATISTICS_update (GDS_stats,
                            "# RESULTS queued for clients",
                            1,
                            GNUNET_NO);
  xsize += (frc->get_path_length + bd->put_path_length)
           * sizeof(struct GNUNET_DHT_PathElement);
  if (truncated)
    xsize += sizeof (struct GNUNET_PeerIdentity);
 
#if SUPER_REDUNDANT_CHECK
  {
    const struct GNUNET_PeerIdentity *my_identity;
    my_identity = GNUNET_PILS_get_identity (GDS_pils);
    GNUNET_assert (NULL != my_identity);
    GNUNET_break (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,
                                          frc->get_path,
                                          frc->get_path_length,
                                          my_identity));
  }
#endif
 
  env = GNUNET_MQ_msg_extra (reply,
                             xsize,
                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT);
  reply->type = htonl (bd->type);
  reply->options = htonl (bd->ro);
  reply->get_path_length = htonl (frc->get_path_length);
  reply->put_path_length = htonl (bd->put_path_length);
  reply->unique_id = record->unique_id;
  reply->expiration = GNUNET_TIME_absolute_hton (bd->expiration_time);
  reply->key = *query_hash;
  if (truncated)
  {
    void *tgt = &reply[1];
 
    GNUNET_memcpy (tgt,
                   &bd->trunc_peer,
                   sizeof (struct GNUNET_PeerIdentity));
    paths = (struct GNUNET_DHT_PathElement *)
            (tgt + sizeof (struct GNUNET_PeerIdentity));
  }
  else
  {
    paths = (struct GNUNET_DHT_PathElement *) &reply[1];
  }
  GNUNET_memcpy (paths,
                 bd->put_path,
                 sizeof(struct GNUNET_DHT_PathElement)
                 * bd->put_path_length);
  GNUNET_memcpy (&paths[bd->put_path_length],
                 frc->get_path,
                 sizeof(struct GNUNET_DHT_PathElement)
                 * frc->get_path_length);
  GNUNET_memcpy (&paths[frc->get_path_length + bd->put_path_length],
                 bd->data,
                 bd->data_size);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending reply to query %s for client %p\n",
       GNUNET_h2s (query_hash),
       record->ch->client);
  GNUNET_MQ_send (record->ch->mq,
                  env);
  if (GNUNET_YES == do_free)
    remove_client_query_record (record);
  return GNUNET_YES;
}

References ForwardReplyContext::bd, ch, GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, env, GNUNET_DHT_ClientResultMessage::expiration, GNUNET_DATACACHE_Block::expiration_time, GDS_block_context, GDS_pils, GDS_stats, ForwardReplyContext::get_path, GNUNET_DHT_ClientResultMessage::get_path_length, ForwardReplyContext::get_path_length, GNUNET_array_append, GNUNET_assert, GNUNET_BLOCK_check_reply(), GNUNET_BLOCK_REPLY_IRRELEVANT, GNUNET_BLOCK_REPLY_OK_DUPLICATE, GNUNET_BLOCK_REPLY_OK_LAST, GNUNET_BLOCK_REPLY_OK_MORE, GNUNET_BLOCK_REPLY_TYPE_NOT_SUPPORTED, GNUNET_BLOCK_TYPE_ANY, GNUNET_break, GNUNET_CRYPTO_hash(), GNUNET_DHT_RO_FIND_APPROXIMATE, GNUNET_DHT_RO_TRUNCATED, GNUNET_DHT_verify_path(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_memcmp, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GNUNET_YES, GNUNET_DATACACHE_Block::key, GNUNET_DHT_ClientResultMessage::key, LOG, LOG_TRAFFIC, my_identity, GNUNET_DHT_ClientResultMessage::options, GNUNET_DATACACHE_Block::put_path, GNUNET_DATACACHE_Block::put_path_length, GNUNET_DHT_ClientResultMessage::put_path_length, record(), remove_client_query_record(), GNUNET_DATACACHE_Block::ro, GNUNET_DATACACHE_Block::trunc_peer, GNUNET_DATACACHE_Block::type, GNUNET_DHT_ClientResultMessage::type, GNUNET_DHT_ClientResultMessage::unique_id, and value.

Referenced by GDS_CLIENTS_handle_reply().

Here is the call graph for this function:

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

◆ handle_dht_local_hello_get()

static void handle_dht_local_hello_get	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Handler for HELLO GET message.

Reply to client with a URL of our HELLO.

Parameters

cls	the client we received this message from
msg	the actual message received

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

{
  struct ClientHandle *ch = cls;
  const struct GNUNET_PeerIdentity *my_identity;
  struct GNUNET_HELLO_Parser *p;
  struct GNUNET_MessageHeader *hdr;
  struct GNUNET_MQ_Envelope *env;
 
  my_identity = GNUNET_PILS_get_identity (GDS_pils);
 
  if (NULL != GDS_my_hello)
    p = GNUNET_HELLO_parser_from_msg (GDS_my_hello, my_identity);
  else
    p = NULL;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling request from local client for my HELLO\n");
 
  if (NULL != p)
  {
    char *url;
    size_t slen;
 
    url = GNUNET_HELLO_parser_to_url (p);
    slen = strlen (url) + 1;
 
    env = GNUNET_MQ_msg_extra (hdr,
                               slen,
                               GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL);
    memcpy (&hdr[1],
            url,
            slen);
    GNUNET_free (url);
    GNUNET_HELLO_parser_free (p);
  }
  else
  {
    env = GNUNET_MQ_msg_extra (hdr, 0, GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL)
    ;
  }
 
  GNUNET_MQ_send (ch->mq,
                  env);
  GNUNET_SERVICE_client_continue (ch->client);
}

References ch, env, GDS_my_hello, GDS_pils, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_msg(), GNUNET_HELLO_parser_to_url(), GNUNET_log, GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_PILS_get_identity(), GNUNET_SERVICE_client_continue(), GNUNET_CADET_Channel::mq, my_identity, and p.

Here is the call graph for this function:

◆ check_dht_local_hello_offer()

static enum GNUNET_GenericReturnValue check_dht_local_hello_offer	(	void *	cls,
		const struct GNUNET_MessageHeader *	hdr
	)

static

Process a client HELLO message received from the service.

Parameters

cls	the client we received this message from
hdr	HELLO URL message from the service.

Returns: GNUNET_OK if hdr is well-formed

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

{
  uint16_t len = ntohs (hdr->size);
  const char *buf = (const char *) &hdr[1];
 
  (void) cls;
  if ('\0' != buf[len - sizeof (*hdr) - 1])
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

◆ handle_dht_local_hello_offer()

static void handle_dht_local_hello_offer	(	void *	cls,
		const struct GNUNET_MessageHeader *	msg
	)

static

Handler for HELLO OFFER message.

Try to use the HELLO to connect to another peer.

Parameters

cls	the client we received this message from
msg	the actual message received

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

{
  struct ClientHandle *ch = cls;
  const char *url = (const char *) &msg[1];
  struct GNUNET_HELLO_Parser *b;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Local client provided HELLO URL %s\n",
              url);
  b = GNUNET_HELLO_parser_from_url (url);
  if (NULL == b)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (ch->client);
    return;
  }
  GNUNET_SERVICE_client_continue (ch->client);
  GNUNET_HELLO_parser_iterate (b,
                               &GDS_try_connect,
                               NULL);
  GNUNET_HELLO_parser_free (b);
}

References ch, GDS_try_connect(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_HELLO_parser_free(), GNUNET_HELLO_parser_from_url(), GNUNET_HELLO_parser_iterate(), GNUNET_log, GNUNET_SERVICE_client_continue(), GNUNET_SERVICE_client_drop(), and msg.

Here is the call graph for this function:

◆ handle_dht_local_monitor()

static void handle_dht_local_monitor	(	void *	cls,
		const struct GNUNET_DHT_MonitorStartStopMessage *	msg
	)

static

Handler for monitor start messages.

Parameters

cls	the client we received this message from
msg	the actual message received

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

{
  struct ClientHandle *ch = cls;
  struct ClientMonitorRecord *r;
 
  r = GNUNET_new (struct ClientMonitorRecord);
  r->ch = ch;
  r->type = ntohl (msg->type);
  r->get = ntohs (msg->get);
  r->get_resp = ntohs (msg->get_resp);
  r->put = ntohs (msg->put);
  if (0 != ntohs (msg->filter_key))
    r->key = msg->key;
  GNUNET_CONTAINER_DLL_insert (monitor_head,
                               monitor_tail,
                               r);
  GNUNET_SERVICE_client_continue (ch->client);
}

References ch, ClientMonitorRecord::ch, ClientMonitorRecord::get, ClientMonitorRecord::get_resp, GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_SERVICE_client_continue(), ClientMonitorRecord::key, monitor_head, monitor_tail, msg, ClientMonitorRecord::put, GNUNET_MessageHeader::type, and ClientMonitorRecord::type.

Here is the call graph for this function:

◆ handle_dht_local_monitor_stop()

static void handle_dht_local_monitor_stop	(	void *	cls,
		const struct GNUNET_DHT_MonitorStartStopMessage *	msg
	)

static

Handler for monitor stop messages.

Parameters

cls	the client we received this message from
msg	the actual message received

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

{
  struct ClientHandle *ch = cls;
 
  GNUNET_SERVICE_client_continue (ch->client);
  for (struct ClientMonitorRecord *r = monitor_head;
       NULL != r;
       r = r->next)
  {
    bool keys_match;
 
    keys_match =
      (GNUNET_is_zero (&r->key))
      ? (0 == ntohs (msg->filter_key))
      : ( (0 != ntohs (msg->filter_key)) &&
          (! GNUNET_memcmp (&r->key,
                            &msg->key)) );
    if ( (ch == r->ch) &&
         (ntohl (msg->type) == r->type) &&
         (r->get == msg->get) &&
         (r->get_resp == msg->get_resp) &&
         (r->put == msg->put) &&
         keys_match)
    {
      GNUNET_CONTAINER_DLL_remove (monitor_head,
                                   monitor_tail,
                                   r);
      GNUNET_free (r);
      return;     /* Delete only ONE entry */
    }
  }
}

References ch, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_is_zero, GNUNET_memcmp, GNUNET_SERVICE_client_continue(), monitor_head, monitor_tail, msg, ClientMonitorRecord::next, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

◆ for_matching_monitors()

static void for_matching_monitors	(	enum GNUNET_BLOCK_Type	type,
		const struct GNUNET_HashCode *	key,
		MonitorAction	cb,
		void *	cb_cls
	)

static

Call cb on all monitors that watch for blocks of type and key key.

Parameters

type	the type to match
key	the key to match
cb	function to call
cb_cls	closure for cb

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

{
  struct ClientHandle **cl = NULL;
  unsigned int cl_size = 0;
 
  for (struct ClientMonitorRecord *m = monitor_head;
       NULL != m;
       m = m->next)
  {
    bool found = false;
 
    if ( (GNUNET_BLOCK_TYPE_ANY != m->type) &&
         (m->type != type) )
      continue;
    if ( (! GNUNET_is_zero (&m->key)) &&
         (0 ==
          GNUNET_memcmp (key,
                         &m->key)) )
      continue;
    /* Don't send duplicates */
    for (unsigned i = 0; i < cl_size; i++)
      if (cl[i] == m->ch)
      {
        found = true;
        break;
      }
    if (found)
      continue;
    GNUNET_array_append (cl,
                         cl_size,
                         m->ch);
    cb (cb_cls,
        m);
  }
  GNUNET_free (cl);
}

References GNUNET_array_append, GNUNET_BLOCK_TYPE_ANY, GNUNET_free, GNUNET_is_zero, GNUNET_memcmp, key, m, monitor_head, and type.

Referenced by GDS_CLIENTS_process_get(), GDS_CLIENTS_process_get_resp(), and GDS_CLIENTS_process_put().

Here is the caller graph for this function:

◆ get_action()

static void get_action	(	void *	cls,
		struct ClientMonitorRecord *	m
	)

static

Function called on monitors that match a GET.

Sends the GET notification to the monitor.

Parameters

cls	a `struct GetActionContext`
m	a matching monitor

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

{
  struct GetActionContext *gac = cls;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_MonitorGetMessage *mmsg;
 
  env = GNUNET_MQ_msg (mmsg,
                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET);
  mmsg->options = htonl (gac->options);
  mmsg->type = htonl (gac->type);
  mmsg->hop_count = htonl (gac->hop_count);
  mmsg->desired_replication_level = htonl (gac->desired_replication_level);
  mmsg->key = *gac->key;
  GNUNET_MQ_send (m->ch->mq,
                  env);
}

References GNUNET_DHT_MonitorGetMessage::desired_replication_level, GetActionContext::desired_replication_level, env, GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_DHT_MonitorGetMessage::hop_count, GetActionContext::hop_count, GNUNET_DHT_MonitorGetMessage::key, GetActionContext::key, m, GNUNET_ARM_MonitorHandle::mq, GNUNET_DHT_MonitorGetMessage::options, GetActionContext::options, GNUNET_DHT_MonitorGetMessage::type, and GetActionContext::type.

Referenced by GDS_CLIENTS_process_get().

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

◆ response_action()

static void response_action	(	void *	cls,
		struct ClientMonitorRecord *	m
	)

static

Function called on monitors that match a response.

Sends the response notification to the monitor.

Parameters

cls	a `struct ResponseActionContext`
m	a matching monitor

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

{
  const struct ResponseActionContext *resp_ctx = cls;
  const struct GNUNET_DATACACHE_Block *bd = resp_ctx->bd;
  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_MonitorGetRespMessage *mmsg;
  struct GNUNET_DHT_PathElement *path;
  size_t msize;
 
  msize = bd->data_size;
  msize += (resp_ctx->get_path_length + bd->put_path_length)
           * sizeof(struct GNUNET_DHT_PathElement);
  if (truncated)
    msize += sizeof (struct GNUNET_PeerIdentity);
  env = GNUNET_MQ_msg_extra (mmsg,
                             msize,
                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP);
  mmsg->type = htonl (bd->type);
  mmsg->put_path_length = htonl (bd->put_path_length);
  mmsg->get_path_length = htonl (resp_ctx->get_path_length);
  mmsg->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
  mmsg->key = bd->key;
  if (truncated)
  {
    void *tgt = &mmsg[1];
 
    GNUNET_memcpy (tgt,
                   &bd->trunc_peer,
                   sizeof (struct GNUNET_PeerIdentity));
    path = (struct GNUNET_DHT_PathElement *)
           (tgt + sizeof (struct GNUNET_PeerIdentity));
  }
  else
  {
    path = (struct GNUNET_DHT_PathElement *) &mmsg[1];
  }
  GNUNET_memcpy (path,
                 bd->put_path,
                 bd->put_path_length * sizeof(struct GNUNET_DHT_PathElement));
  GNUNET_memcpy (path,
                 resp_ctx->get_path,
                 resp_ctx->get_path_length
                 * sizeof(struct GNUNET_DHT_PathElement));
  GNUNET_memcpy (&path[resp_ctx->get_path_length],
                 bd->data,
                 bd->data_size);
  GNUNET_MQ_send (m->ch->mq,
                  env);
}

Referenced by GDS_CLIENTS_process_get_resp().

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

◆ put_action()

static void put_action	(	void *	cls,
		struct ClientMonitorRecord *	m
	)

static

Function called on monitors that match a PUT.

Sends the PUT notification to the monitor.

Parameters

cls	a `struct PutActionContext`
m	a matching monitor

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

{
  const struct PutActionContext *put_ctx = cls;
  const struct GNUNET_DATACACHE_Block *bd = put_ctx->bd;
  bool truncated = (0 != (bd->ro & GNUNET_DHT_RO_TRUNCATED));
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_MonitorPutMessage *mmsg;
  struct GNUNET_DHT_PathElement *msg_path;
  size_t msize;
 
  msize = bd->data_size
          + bd->put_path_length
          * sizeof(struct GNUNET_DHT_PathElement);
  if (truncated)
    msize += sizeof (struct GNUNET_PeerIdentity);
  env = GNUNET_MQ_msg_extra (mmsg,
                             msize,
                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT);
  mmsg->options = htonl (bd->ro);
  mmsg->type = htonl (bd->type);
  mmsg->hop_count = htonl (put_ctx->hop_count);
  mmsg->desired_replication_level = htonl (put_ctx->desired_replication_level);
  mmsg->put_path_length = htonl (bd->put_path_length);
  mmsg->key = bd->key;
  mmsg->expiration_time = GNUNET_TIME_absolute_hton (bd->expiration_time);
  if (truncated)
  {
    void *tgt = &mmsg[1];
 
    GNUNET_memcpy (tgt,
                   &bd->trunc_peer,
                   sizeof (struct GNUNET_PeerIdentity));
    msg_path = (struct GNUNET_DHT_PathElement *)
               (tgt + sizeof (struct GNUNET_PeerIdentity));
  }
  else
  {
    msg_path = (struct GNUNET_DHT_PathElement *) &mmsg[1];
  }
  GNUNET_memcpy (msg_path,
                 bd->put_path,
                 bd->put_path_length * sizeof(struct GNUNET_DHT_PathElement));
  GNUNET_memcpy (&msg_path[bd->put_path_length],
                 bd->data,
                 bd->data_size);
  GNUNET_MQ_send (m->ch->mq,
                  env);
}

Referenced by GDS_CLIENTS_process_put().

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 1628 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_init()

void GDS_CLIENTS_init ( void )

Initialize client subsystem.

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

{
  forward_map
    = GNUNET_CONTAINER_multihashmap_create (1024,
                                            GNUNET_YES);
  retry_heap
    = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
}

References forward_map, GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multihashmap_create(), GNUNET_YES, and retry_heap.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GDS_CLIENTS_stop()

void GDS_CLIENTS_stop ( void )

Shutdown client subsystem.

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

{
  if (NULL != retry_task)
  {
    GNUNET_SCHEDULER_cancel (retry_task);
    retry_task = NULL;
  }
}

References GNUNET_SCHEDULER_cancel(), and retry_task.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GDS_CLIENTS_done()

void GDS_CLIENTS_done ( void )

◆ attribute()

void __attribute__ ( (destructor) )

MINIMIZE heap size (way below 128k) since this process doesn't need much.

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

{
  if (NULL != retry_heap)
  {
    GNUNET_assert (0 == GNUNET_CONTAINER_heap_get_size (retry_heap));
    GNUNET_CONTAINER_heap_destroy (retry_heap);
    retry_heap = NULL;
  }
  if (NULL != forward_map)
  {
    GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap_size (forward_map));
    GNUNET_CONTAINER_multihashmap_destroy (forward_map);
    forward_map = NULL;
  }
}