gnunet-service-dht_clients.c File Reference

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:

Go to the source code of 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	PendingPut
	A local PUT that we could not route anywhere, kept so that we can try again once we have a peer to route it to. 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	UNROUTED_RETRY_INTERVAL
	Upper bound on the retry interval for a GET that we were unable to route anywhere.
#define	MAXIMUM_GET_RETRY_INTERVAL
	Upper bound on the retry interval during FAST_RETRY_WINDOW.
#define	FAST_RETRY_WINDOW
	For how long after a GET was received from the client do we bound the retry interval by MAXIMUM_GET_RETRY_INTERVAL? Beyond this the client is no longer waiting interactively (GNS gives up much earlier), and long-running searches (fs, cadet) should be allowed to back off.
#define	UNROUTED_PUT_TIMEOUT
	How long do we keep re-trying a local PUT that we were unable to route anywhere? Long enough to cover the usual "peer just started, transport and CORE have not brought up a link yet" case.
#define	UNROUTED_PUT_RETRY_INTERVAL
	Upper bound on the retry interval for such a PUT.
#define	MAX_PENDING_PUTS   1024
	How many unroutable local PUTs do we hold on to at most?
#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	reset_retry_backoff (void *cls, const struct GNUNET_HashCode *key, void *value)
	Make a client's GET request eligible for immediate re-transmission.
void	GDS_CLIENTS_retry_requests (void)
	Our routing table gained a peer.
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	route_pending_put (struct PendingPut *pp)
	Hand pp to the routing layer.
static void	put_retry_task_cb (void *cls)
static void	schedule_put_retry (void)
	Make sure the retry task is armed for the earliest pending PUT.
static void	cb_forwarded_dht_local_put (void *cls, enum GNUNET_GenericReturnValue forwarded)
void	GDS_CLIENTS_retry_puts (void)
	Our routing table gained a peer.
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).
static struct PendingPut *	pp_head
	Head of the list of PUTs waiting for a usable routing table.
static struct PendingPut *	pp_tail
	Tail of the list of PUTs waiting for a usable routing table.
static unsigned int	pp_count
	Number of entries in the pp_head DLL.
static struct GNUNET_SCHEDULER_Task *	put_retry_task
	Task that re-tries the PUTs in the pp_head DLL.

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__)

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.

UNROUTED_RETRY_INTERVAL

#define UNROUTED_RETRY_INTERVAL

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_SECONDS, 5)

Upper bound on the retry interval for a GET that we were unable to route anywhere.

Such a GET consumed no bandwidth, so the regular exponential back-off (which runs up to 15 minutes) must not apply to it: we want to be back on the wire quickly once the routing table has a usable peer again.

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

MAXIMUM_GET_RETRY_INTERVAL

#define MAXIMUM_GET_RETRY_INTERVAL

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_SECONDS, 5)

Upper bound on the retry interval during FAST_RETRY_WINDOW.

With the plain 15 minute ceiling of GNUNET_TIME_STD_BACKOFF the attempts fall on 0s, 2s, 6s, 14s, 30s, ..., so a single unanswered attempt already costs an interactive lookup (GNS) tens of seconds.

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

FAST_RETRY_WINDOW

#define FAST_RETRY_WINDOW

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MINUTES, 1)

For how long after a GET was received from the client do we bound the retry interval by MAXIMUM_GET_RETRY_INTERVAL? Beyond this the client is no longer waiting interactively (GNS gives up much earlier), and long-running searches (fs, cadet) should be allowed to back off.

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

UNROUTED_PUT_TIMEOUT

#define UNROUTED_PUT_TIMEOUT

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MINUTES, 5)

How long do we keep re-trying a local PUT that we were unable to route anywhere? Long enough to cover the usual "peer just started, transport and CORE have not brought up a link yet" case.

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

UNROUTED_PUT_RETRY_INTERVAL

#define UNROUTED_PUT_RETRY_INTERVAL

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_SECONDS, 5)

Upper bound on the retry interval for such a PUT.

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

MAX_PENDING_PUTS

#define MAX_PENDING_PUTS   1024

How many unroutable local PUTs do we hold on to at most?

Definition at line 92 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 2064 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 1715 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 387 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 417 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 440 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 486 of file gnunet-service-dht_clients.c.

{
  struct GNUNET_BLOCK_Group *bg;
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;
  enum GNUNET_GenericReturnValue routed;
 
  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);
  routed = 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);
  if (GNUNET_TIME_relative_cmp (
        GNUNET_TIME_absolute_get_duration (cqr->start_time),
        <,
        FAST_RETRY_WINDOW))
  {
    /* Somebody is still waiting for an answer; do not let the back-off
       turn one lost attempt into tens of seconds of latency. */
    cqr->retry_frequency
      = GNUNET_TIME_relative_min (MAXIMUM_GET_RETRY_INTERVAL,
                                  cqr->retry_frequency);
  }
  if (GNUNET_OK != routed)
  {
    /* We had no peer to route this to, so nothing was sent and nothing
       can answer.  Cap the interval so we come back as soon as the
       routing table recovers instead of idling for up to 15 minutes. */
    GNUNET_STATISTICS_update (GDS_stats,
                              "# GET requests from clients not routed",
                              1,
                              GNUNET_NO);
    cqr->retry_frequency
      = GNUNET_TIME_relative_min (UNROUTED_RETRY_INTERVAL,
                                  cqr->retry_frequency);
  }
  cqr->retry_time = GNUNET_TIME_relative_to_absolute (cqr->retry_frequency);
}

References DHT_BLOOM_SIZE, FAST_RETRY_WINDOW, GDS_block_context, GDS_NEIGHBOURS_handle_get(), GDS_stats, GNUNET_BLOCK_group_create(), GNUNET_BLOCK_group_destroy(), GNUNET_BLOCK_group_set_seen(), GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_cmp, GNUNET_TIME_relative_min(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_STD_BACKOFF, ClientQueryRecord::key, LOG, MAXIMUM_GET_RETRY_INTERVAL, ClientQueryRecord::msg_options, ClientQueryRecord::replication, ClientQueryRecord::retry_frequency, ClientQueryRecord::retry_time, ClientQueryRecord::seen_replies, ClientQueryRecord::seen_replies_count, ClientQueryRecord::start_time, ClientQueryRecord::type, UNROUTED_RETRY_INTERVAL, ClientQueryRecord::xquery, and ClientQueryRecord::xquery_size.

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 566 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 GDS_CLIENTS_retry_requests(), 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:

reset_retry_backoff()

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

static

Make a client's GET request eligible for immediate re-transmission.

Parameters

cls	NULL
key	the query (not used)
value	the struct ClientQueryRecord

Returns

GNUNET_YES (continue to iterate)

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

{
  struct ClientQueryRecord *cqr = value;
 
  (void) cls;
  (void) key;
  cqr->retry_frequency = GNUNET_TIME_UNIT_SECONDS;
  cqr->retry_time = GNUNET_TIME_absolute_get ();
  if (NULL != cqr->hnode)
    GNUNET_CONTAINER_heap_update_cost (cqr->hnode,
                                       cqr->retry_time.abs_value_us);
  return GNUNET_YES;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONTAINER_heap_update_cost(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, ClientQueryRecord::hnode, key, ClientQueryRecord::retry_frequency, ClientQueryRecord::retry_time, and value.

Referenced by GDS_CLIENTS_retry_requests().

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:

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 652 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.

route_pending_put()

static void route_pending_put ( struct PendingPut *  pp )

static

Hand pp to the routing layer.

Consumes pp: the operation callback either frees it or re-queues it.

Parameters

pp	the PUT to route

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

{
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;
 
  peer_bf
    = GNUNET_CONTAINER_bloomfilter_init (NULL,
                                         DHT_BLOOM_SIZE,
                                         GNUNET_CONSTANTS_BLOOMFILTER_K);
  /* Takes over @a pp via the callback, which may run synchronously. */
  GDS_NEIGHBOURS_handle_put (&pp->bd,
                             pp->replication_level,
                             0 /* hop count */,
                             peer_bf,
                             &cb_forwarded_dht_local_put,
                             pp);
  GNUNET_CONTAINER_bloomfilter_free (peer_bf);
}

References PendingPut::bd, cb_forwarded_dht_local_put(), DHT_BLOOM_SIZE, GDS_NEIGHBOURS_handle_put(), GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), and PendingPut::replication_level.

Referenced by handle_dht_local_put(), and put_retry_task_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

put_retry_task_cb()

static void put_retry_task_cb ( void *  cls )

static

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

{
  struct PendingPut *ready_head = NULL;
  struct PendingPut *ready_tail = NULL;
  struct GNUNET_TIME_Absolute next = GNUNET_TIME_UNIT_FOREVER_ABS;
  struct PendingPut *nxt;
 
  (void) cls;
  put_retry_task = NULL;
  /* Splice the entries that are due out of the DLL first: routing one of
     them can re-queue it (and does, whenever it still finds no route). */
  for (struct PendingPut *pp = pp_head; NULL != pp; pp = nxt)
  {
    nxt = pp->next;
    if (! GNUNET_TIME_absolute_is_past (pp->retry_time))
      continue;
    GNUNET_CONTAINER_DLL_remove (pp_head,
                                 pp_tail,
                                 pp);
    pp_count--;
    GNUNET_CONTAINER_DLL_insert_tail (ready_head,
                                      ready_tail,
                                      pp);
  }
  while (NULL != (nxt = ready_head))
  {
    GNUNET_CONTAINER_DLL_remove (ready_head,
                                 ready_tail,
                                 nxt);
    route_pending_put (nxt);
  }
  /* Re-queueing above may have armed the task again; we know better. */
  if (NULL != put_retry_task)
  {
    GNUNET_SCHEDULER_cancel (put_retry_task);
    put_retry_task = NULL;
  }
  if (NULL == pp_head)
    return;
  for (struct PendingPut *pp = pp_head; NULL != pp; pp = pp->next)
    next = GNUNET_TIME_absolute_min (next,
                                     pp->retry_time);
  put_retry_task = GNUNET_SCHEDULER_add_at (next,
                                            &put_retry_task_cb,
                                            NULL);
}

References GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_is_past(), GNUNET_TIME_absolute_min(), GNUNET_TIME_UNIT_FOREVER_ABS, PendingPut::next, pp_count, pp_head, pp_tail, put_retry_task, put_retry_task_cb(), ready_head, ready_tail, PendingPut::retry_time, and route_pending_put().

Referenced by put_retry_task_cb(), and schedule_put_retry().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_put_retry()

static void schedule_put_retry ( void  )

static

Make sure the retry task is armed for the earliest pending PUT.

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

{
  if (NULL != put_retry_task)
    GNUNET_SCHEDULER_cancel (put_retry_task);
  put_retry_task = GNUNET_SCHEDULER_add_now (&put_retry_task_cb,
                                             NULL);
}

References GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), put_retry_task, and put_retry_task_cb().

Referenced by cb_forwarded_dht_local_put(), and GDS_CLIENTS_retry_puts().

Here is the call graph for this function:

Here is the caller graph for this function:

cb_forwarded_dht_local_put()

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

static

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

{
  struct PendingPut *pp = cls;
 
  if (GNUNET_OK == forwarded)
  {
    GNUNET_free (pp);
    return;
  }
  /* Nothing was sent, so nothing can store this block and no retry
     happens anywhere else: the DHT keeps no state about a PUT, and the
     client's continuation has already reported success (it fires when
     the request left the client, not when it was routed).  Hold on to
     the block and try again when we have somewhere to send it. */
  GNUNET_STATISTICS_update (GDS_stats,
                            "# Local PUT requests not routed",
                            1,
                            GNUNET_NO);
  if ( (GNUNET_TIME_absolute_is_past (pp->give_up_time)) ||
       (GNUNET_TIME_absolute_is_past (pp->bd.expiration_time)) ||
       (pp_count >= MAX_PENDING_PUTS) )
  {
    GNUNET_STATISTICS_update (GDS_stats,
                              "# Local PUT requests dropped (never routed)",
                              1,
                              GNUNET_NO);
    GNUNET_free (pp);
    return;
  }
  pp->retry_frequency
    = GNUNET_TIME_relative_min (UNROUTED_PUT_RETRY_INTERVAL,
                                GNUNET_TIME_STD_BACKOFF (pp->retry_frequency));
  pp->retry_time = GNUNET_TIME_relative_to_absolute (pp->retry_frequency);
  GNUNET_CONTAINER_DLL_insert (pp_head,
                               pp_tail,
                               pp);
  pp_count++;
  schedule_put_retry ();
}

References PendingPut::bd, GNUNET_DATACACHE_Block::expiration_time, GDS_stats, PendingPut::give_up_time, GNUNET_CONTAINER_DLL_insert, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_is_past(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_STD_BACKOFF, MAX_PENDING_PUTS, pp_count, pp_head, pp_tail, PendingPut::retry_frequency, PendingPut::retry_time, schedule_put_retry(), and UNROUTED_PUT_RETRY_INTERVAL.

Referenced by route_pending_put().

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:

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 830 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 (NULL == GNUNET_PILS_get_identity (GDS_pils))
  {
    /* Without our own identity we can neither decide whether to store
       this block nor route it: GDS_am_closest_peer(),
       GDS_DATACACHE_handle_put() and GDS_NEIGHBOURS_handle_put() all
       require it.  Should not happen -- the service stays suspended
       until PILS answers -- but drop the request rather than abort. */
    GNUNET_break (0);
    GNUNET_STATISTICS_update (GDS_stats,
                              "# PUT requests dropped (no identity yet)",
                              1,
                              GNUNET_NO);
    GNUNET_SERVICE_client_continue (ch->client);
    return;
  }
#if SANITY_CHECKS > 0
  if (GNUNET_OK !=
      GNUNET_BLOCK_check_block (GDS_block_context,
                                bd.type,
                                bd.data,
                                bd.data_size))
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_continue (ch->client);
    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;
    struct PendingPut *pp;
 
    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);
    GNUNET_CONTAINER_bloomfilter_free (peer_bf);
    /* route to other peers; the copy survives a failure to route so that
       we can try again, the client message does not */
    pp = GNUNET_malloc (sizeof (*pp) + bd.data_size);
    pp->bd = bd;
    pp->bd.data = &pp[1];
    GNUNET_memcpy (&pp[1],
                   bd.data,
                   bd.data_size);
    pp->replication_level = replication_level;
    pp->retry_frequency = GNUNET_TIME_UNIT_SECONDS;
    pp->give_up_time
      = GNUNET_TIME_relative_to_absolute (UNROUTED_PUT_TIMEOUT);
    route_pending_put (pp);
  }
  GDS_CLIENTS_process_put (
    &bd,
    0,  /* hop count */
    replication_level);
  GNUNET_SERVICE_client_continue (ch->client);
}

References PendingPut::bd, 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_pils, GDS_stats, PendingPut::give_up_time, 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_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_PILS_get_identity(), GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_SECONDS, GNUNET_DHT_ClientPutMessage::header, GNUNET_DATACACHE_Block::key, GNUNET_DHT_ClientPutMessage::key, LOG, LOG_TRAFFIC, GNUNET_DHT_ClientPutMessage::options, replication_level, PendingPut::replication_level, PendingPut::retry_frequency, GNUNET_DATACACHE_Block::ro, route_pending_put(), GNUNET_MessageHeader::size, size, GNUNET_DATACACHE_Block::type, GNUNET_DHT_ClientPutMessage::type, and UNROUTED_PUT_TIMEOUT.

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 933 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 PendingPut::bd, 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 953 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 970 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));
  if (NULL == GNUNET_PILS_get_identity (GDS_pils))
  {
    /* GDS_NEIGHBOURS_handle_get() requires our identity.  Should not
       happen -- the service stays suspended until PILS answers -- but
       drop the request rather than abort. */
    GNUNET_break (0);
    GNUNET_STATISTICS_update (GDS_stats,
                              "# GET requests dropped (no identity yet)",
                              1,
                              GNUNET_NO);
    GNUNET_SERVICE_client_continue (ch->client);
    return;
  }
 
  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->start_time = cqr->retry_time;
  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);
}

References ch, ClientQueryRecord::ch, forward_map, GDS_CLIENTS_process_get(), GDS_DATACACHE_handle_get(), GDS_pils, GDS_stats, get, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_PILS_get_identity(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_UNIT_SECONDS, handle_local_result(), ClientQueryRecord::hnode, ClientQueryRecord::key, LOG, LOG_TRAFFIC, ClientQueryRecord::msg_options, ClientQueryRecord::replication, ClientQueryRecord::retry_frequency, retry_heap, retry_task, ClientQueryRecord::retry_time, size, ClientQueryRecord::start_time, transmit_next_request_task(), ClientQueryRecord::type, ClientQueryRecord::unique_id, ClientQueryRecord::xquery, and ClientQueryRecord::xquery_size.

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 1081 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 1103 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 1128 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);
  GNUNET_SERVICE_client_continue (ch->client);
}

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_continue(), 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 1192 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 1219 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 1279 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 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:

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 1529 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 1585 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 1609 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 1645 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 1673 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 1730 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 1793 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 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:

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

References ResponseActionContext::bd, GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, env, GNUNET_DATACACHE_Block::expiration_time, GNUNET_DHT_MonitorGetRespMessage::expiration_time, ResponseActionContext::get_path, GNUNET_DHT_MonitorGetRespMessage::get_path_length, ResponseActionContext::get_path_length, GNUNET_DHT_RO_TRUNCATED, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), GNUNET_DATACACHE_Block::key, GNUNET_DHT_MonitorGetRespMessage::key, m, GNUNET_ARM_MonitorHandle::mq, GNUNET_DATACACHE_Block::put_path, GNUNET_DATACACHE_Block::put_path_length, GNUNET_DHT_MonitorGetRespMessage::put_path_length, GNUNET_DATACACHE_Block::ro, GNUNET_DATACACHE_Block::trunc_peer, GNUNET_DATACACHE_Block::type, and GNUNET_DHT_MonitorGetRespMessage::type.

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

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

References PutActionContext::bd, GNUNET_DATACACHE_Block::data, GNUNET_DATACACHE_Block::data_size, GNUNET_DHT_MonitorPutMessage::desired_replication_level, PutActionContext::desired_replication_level, env, GNUNET_DATACACHE_Block::expiration_time, GNUNET_DHT_MonitorPutMessage::expiration_time, GNUNET_DHT_RO_TRUNCATED, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), GNUNET_DHT_MonitorPutMessage::hop_count, PutActionContext::hop_count, GNUNET_DATACACHE_Block::key, GNUNET_DHT_MonitorPutMessage::key, m, GNUNET_ARM_MonitorHandle::mq, GNUNET_DHT_MonitorPutMessage::options, GNUNET_DATACACHE_Block::put_path, GNUNET_DATACACHE_Block::put_path_length, GNUNET_DHT_MonitorPutMessage::put_path_length, GNUNET_DATACACHE_Block::ro, GNUNET_DATACACHE_Block::trunc_peer, GNUNET_DATACACHE_Block::type, and GNUNET_DHT_MonitorPutMessage::type.

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

void GDS_CLIENTS_init

(

void

)

Initialize client subsystem.

Definition at line 2019 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 2033 of file gnunet-service-dht_clients.c.

{
  struct PendingPut *pp;
 
  if (NULL != retry_task)
  {
    GNUNET_SCHEDULER_cancel (retry_task);
    retry_task = NULL;
  }
  if (NULL != put_retry_task)
  {
    GNUNET_SCHEDULER_cancel (put_retry_task);
    put_retry_task = NULL;
  }
  while (NULL != (pp = pp_head))
  {
    GNUNET_CONTAINER_DLL_remove (pp_head,
                                 pp_tail,
                                 pp);
    pp_count--;
    GNUNET_free (pp);
  }
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), pp_count, pp_head, pp_tail, put_retry_task, 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 2112 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;
  }
}

References forward_map, GNUNET_assert, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_size(), and retry_heap.

Here is the call graph for this function:

Variable Documentation

GDS_block_context

struct GNUNET_BLOCK_Context* GDS_block_context

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

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

Handle for the pils service.

(may be NULL but needed for linking)

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

Referenced by cb_path_signed(), find_bucket(), forward_reply(), GDS_am_closest_peer(), GDS_CLIENTS_handle_reply(), GDS_DATACACHE_handle_put(), GDS_helper_sign_path(), GDS_NEIGHBOURS_get_id(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), GDS_NEIGHBOURS_handle_reply(), GDS_try_connect(), GDS_u_connect(), handle_dht_local_get(), handle_dht_local_hello_get(), handle_dht_local_put(), handle_dht_p2p_get(), handle_dht_p2p_put(), handle_dht_p2p_result(), handle_find_my_hello(), pid_change_cb(), run(), select_peer(), send_find_peer_message(), and shutdown_task().

GDS_service

struct GNUNET_SERVICE_Handle* GDS_service

Handle for the service.

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

Referenced by pid_change_cb(), and run().

GDS_cfg

const struct GNUNET_CONFIGURATION_Handle* GDS_cfg

The configuration the DHT service is running with.

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().

monitor_head

struct ClientMonitorRecord* monitor_head

static

List of active monitoring requests.

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

Referenced by client_disconnect_cb(), for_matching_monitors(), handle_dht_local_monitor(), and handle_dht_local_monitor_stop().

monitor_tail

struct ClientMonitorRecord* monitor_tail

static

List of active monitoring requests.

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

Referenced by client_disconnect_cb(), handle_dht_local_monitor(), and handle_dht_local_monitor_stop().

forward_map

struct GNUNET_CONTAINER_MultiHashMap* forward_map

static

Hashmap for fast key based lookup, maps keys to struct ClientQueryRecord entries.

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

Referenced by __attribute__(), GDS_CLIENTS_handle_reply(), GDS_CLIENTS_init(), GDS_CLIENTS_retry_requests(), handle_dht_local_get(), handle_dht_local_get_result_seen(), handle_dht_local_get_stop(), and remove_client_query_record().

retry_heap

struct GNUNET_CONTAINER_Heap* retry_heap

static

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

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

Referenced by __attribute__(), GDS_CLIENTS_init(), handle_dht_local_get(), and transmit_next_request_task().

retry_task

struct GNUNET_SCHEDULER_Task* retry_task

static

Task that re-transmits requests (using retry_heap).

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

Referenced by GDS_CLIENTS_retry_requests(), GDS_CLIENTS_stop(), handle_dht_local_get(), and transmit_next_request_task().

pp_head

struct PendingPut* pp_head

static

Head of the list of PUTs waiting for a usable routing table.

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

Referenced by cb_forwarded_dht_local_put(), GDS_CLIENTS_retry_puts(), GDS_CLIENTS_stop(), and put_retry_task_cb().

pp_tail

struct PendingPut* pp_tail

static

Tail of the list of PUTs waiting for a usable routing table.

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

Referenced by cb_forwarded_dht_local_put(), GDS_CLIENTS_stop(), and put_retry_task_cb().

pp_count

unsigned int pp_count

static

Number of entries in the pp_head DLL.

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

Referenced by cb_forwarded_dht_local_put(), GDS_CLIENTS_retry_puts(), GDS_CLIENTS_stop(), and put_retry_task_cb().

put_retry_task

struct GNUNET_SCHEDULER_Task* put_retry_task

static

Task that re-tries the PUTs in the pp_head DLL.

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

Referenced by GDS_CLIENTS_stop(), put_retry_task_cb(), and schedule_put_retry().