gnunet-service-dht_clients.c File Reference

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

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_statistics_service.h"
#include "gnunet-service-dht.h"
#include "gnunet-service-dht_datacache.h"
#include "gnunet-service-dht_neighbours.h"
#include "dht.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 paremeters 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...

Macros
#define	LOG_TRAFFIC(kind, ...)   GNUNET_log_from(kind, "dht-traffic", __VA_ARGS__)
	Should routing details be logged to stderr (for debugging)? More...
#define	LOG(kind, ...)   GNUNET_log_from(kind, "dht-clients", __VA_ARGS__)
#define	GDS_DHT_SERVICE_INIT(name, run)
	Define "main" method using service macro. More...

Functions
static void	remove_client_record (struct ClientQueryRecord *record)
	Free data structures associated with the given query. More...
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. More...
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. More...
static void	transmit_request (struct ClientQueryRecord *cqr)
	Route the given request via the DHT. More...
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. More...
static int	check_dht_local_put (void *cls, const struct GNUNET_DHT_ClientPutMessage *dht_msg)
	Check DHT PUT messages from the client. More...
static void	handle_dht_local_put (void *cls, const struct GNUNET_DHT_ClientPutMessage *dht_msg)
	Handler for PUT messages. More...
static int	check_dht_local_get (void *cls, const struct GNUNET_DHT_ClientGetMessage *get)
	Check DHT GET messages from the client. More...
static void	handle_local_result (void *cls, enum GNUNET_BLOCK_Type type, struct GNUNET_TIME_Absolute expiration_time, const struct GNUNET_HashCode *key, unsigned int put_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *get_path, const void *data, size_t data_size)
	Handle a result from local datacache for a GET operation. More...
static void	handle_dht_local_get (void *cls, const struct GNUNET_DHT_ClientGetMessage *get)
	Handler for DHT GET messages from the client. More...
static int	find_by_unique_id (void *cls, const struct GNUNET_HashCode *key, void *value)
	Function called for each existing DHT record for the given query. More...
static int	check_dht_local_get_result_seen (void *cls, const struct GNUNET_DHT_ClientGetResultSeenMessage *seen)
	Check "GET result seen" messages from the client. More...
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. More...
static int	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. More...
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) More...
static void	handle_dht_local_monitor (void *cls, const struct GNUNET_DHT_MonitorStartStopMessage *msg)
	Handler for monitor start messages. More...
static void	handle_dht_local_monitor_stop (void *cls, const struct GNUNET_DHT_MonitorStartStopMessage *msg)
	Handler for monitor stop messages. More...
static int	forward_reply (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator over hash map entries that send a given reply to each of the matching clients. More...
void	GDS_CLIENTS_handle_reply (struct GNUNET_TIME_Absolute expiration, const struct GNUNET_HashCode *key, unsigned int get_path_length, const struct GNUNET_PeerIdentity *get_path, unsigned int put_path_length, const struct GNUNET_PeerIdentity *put_path, enum GNUNET_BLOCK_Type type, size_t data_size, const void *data)
	Handle a reply we've received from another peer. More...
void	GDS_CLIENTS_process_get (uint32_t options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, unsigned int path_length, const struct GNUNET_PeerIdentity *path, const struct GNUNET_HashCode *key)
	Check if some client is monitoring GET messages and notify them in that case. More...
void	GDS_CLIENTS_process_get_resp (enum GNUNET_BLOCK_Type type, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, unsigned int put_path_length, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)
	Check if some client is monitoring GET RESP messages and notify them in that case. More...
void	GDS_CLIENTS_process_put (uint32_t options, enum GNUNET_BLOCK_Type type, uint32_t hop_count, uint32_t desired_replication_level, unsigned int path_length, const struct GNUNET_PeerIdentity *path, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const void *data, size_t size)
	Check if some client is monitoring PUT messages and notify them in that case. More...
static void	GDS_CLIENTS_init ()
	Initialize client subsystem. More...
static void	GDS_CLIENTS_stop ()
	Shutdown client subsystem. More...
void	__attribute__ ((destructor))
	MINIMIZE heap size (way below 128k) since this process doesn't need much. More...

Variables
struct GNUNET_BLOCK_Context *	GDS_block_context
	Our handle to the BLOCK library. More...
struct GNUNET_STATISTICS_Handle *	GDS_stats
	Handle for the statistics service. More...
struct GNUNET_SERVICE_Handle *	GDS_service
	Handle for the service. More...
const struct GNUNET_CONFIGURATION_Handle *	GDS_cfg
	The configuration the DHT service is running with. More...
static struct ClientMonitorRecord *	monitor_head
	List of active monitoring requests. More...
static struct ClientMonitorRecord *	monitor_tail
	List of active monitoring requests. More...
static struct GNUNET_CONTAINER_MultiHashMap *	forward_map
	Hashmap for fast key based lookup, maps keys to struct ClientQueryRecord entries. More...
static struct GNUNET_CONTAINER_Heap *	retry_heap
	Heap with all of our client's request, sorted by retry time (earliest on top). More...
static struct GNUNET_SCHEDULER_Task *	retry_task
	Task that re-transmits requests (using retry_heap). More...

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

LOG_TRAFFIC

#define LOG_TRAFFIC	(		kind,
			...
	)		GNUNET_log_from(kind, "dht-traffic", __VA_ARGS__)

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

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

Referenced by forward_reply(), handle_dht_local_get(), and handle_dht_local_put().

LOG

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

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

Referenced by forward_reply(), GDS_CLIENTS_handle_reply(), handle_dht_local_get(), handle_dht_local_get_stop(), handle_dht_local_put(), and transmit_request().

GDS_DHT_SERVICE_INIT

#define GDS_DHT_SERVICE_INIT	(		name,
			run
	)

Define "main" method using service macro.

Parameters

name	name of the service, i.e. "dht" or "xdht"
run	name of the initializaton method for the service

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

Referenced by run().

Function Documentation

remove_client_record()

static void remove_client_record ( struct ClientQueryRecord *  record )

static

Free data structures associated with the given query.

Parameters

record

record to remove

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

References ClientQueryRecord::ch, ClientHandle::cqr_head, ClientHandle::cqr_tail, GNUNET_array_grow, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_remove_node(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_free, GNUNET_YES, ClientQueryRecord::hnode, ClientQueryRecord::key, ClientQueryRecord::seen_replies, and ClientQueryRecord::seen_replies_count.

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

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

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 291 of file gnunet-service-dht_clients.c.

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

{
  struct ClientHandle *ch;

  ch = GNUNET_new(struct ClientHandle);
  ch->client = client;
  ch->mq = mq;
  return ch;
}

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 313 of file gnunet-service-dht_clients.c.

References ClientQueryRecord::ch, ClientMonitorRecord::ch, ClientHandle::cqr_head, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_free_non_null, GNUNET_log, ClientMonitorRecord::key, monitor, monitor_head, ClientQueryRecord::next, ClientMonitorRecord::next, and remove_client_record().

{
  struct ClientHandle *ch = app_ctx;
  struct ClientQueryRecord *cqr;
  struct ClientMonitorRecord *monitor;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Local client %p disconnects\n",
             ch);
  monitor = monitor_head;
  while (NULL != monitor)
    {
      if (monitor->ch == ch)
        {
          struct ClientMonitorRecord *next;

          next = monitor->next;
          GNUNET_free_non_null(monitor->key);
          GNUNET_CONTAINER_DLL_remove(monitor_head,
                                      monitor_tail,
                                      monitor);
          GNUNET_free(monitor);
          monitor = next;
        }
      else
        {
          monitor = monitor->next;
        }
    }
  while (NULL != (cqr = ch->cqr_head))
    remove_client_record(cqr);
  GNUNET_free(ch);
}

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.

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

References DHT_BLOOM_SIZE, GDS_NEIGHBOURS_handle_get(), gettext_noop, 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_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_STD_BACKOFF, ClientQueryRecord::key, LOG, ClientQueryRecord::msg_options, ClientQueryRecord::replication, ClientQueryRecord::retry_frequency, ClientQueryRecord::retry_time, ClientQueryRecord::seen_replies, ClientQueryRecord::seen_replies_count, ClientQueryRecord::type, ClientQueryRecord::xquery, and ClientQueryRecord::xquery_size.

Referenced by transmit_next_request_task().

{
  struct GNUNET_BLOCK_Group *bg;
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;

  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# GET requests from clients injected"),
                           1,
                           GNUNET_NO);
  bg = GNUNET_BLOCK_group_create(GDS_block_context,
                                 cqr->type,
                                 GNUNET_CRYPTO_random_u32(GNUNET_CRYPTO_QUALITY_WEAK,
                                                          UINT32_MAX),
                                 NULL,
                                 0,
                                 "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 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);
}

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 413 of file gnunet-service-dht_clients.c.

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_SCHEDULER_add_at(), GNUNET_TIME_absolute_get_remaining(), ClientQueryRecord::hnode, GNUNET_TIME_Relative::rel_value_us, ClientQueryRecord::retry_time, and transmit_request().

Referenced by handle_dht_local_get().

{
  struct ClientQueryRecord *cqr;
  struct GNUNET_TIME_Relative delay;

  retry_task = NULL;
  while (NULL != (cqr = GNUNET_CONTAINER_heap_remove_root(retry_heap)))
    {
      cqr->hnode = NULL;
      delay = GNUNET_TIME_absolute_get_remaining(cqr->retry_time);
      if (delay.rel_value_us > 0)
        {
          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);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_dht_local_put()

static int 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 452 of file gnunet-service-dht_clients.c.

References GNUNET_OK.

{
  /* always well-formed */
  return GNUNET_OK;
}

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 467 of file gnunet-service-dht_clients.c.

References ClientQueryRecord::ch, ClientHandle::client, GNUNET_DHT_ClientPutMessage::desired_replication_level, DHT_BLOOM_SIZE, GNUNET_DHT_ClientPutMessage::expiration, GDS_CLIENTS_handle_reply(), GDS_CLIENTS_process_put(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_get_id(), GDS_NEIGHBOURS_handle_put(), gettext_noop, GNUNET_CONSTANTS_BLOOMFILTER_K, GNUNET_CONTAINER_bloomfilter_free(), GNUNET_CONTAINER_bloomfilter_init(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_ntoh(), GNUNET_DHT_ClientPutMessage::header, GNUNET_DHT_ClientPutMessage::key, LOG, LOG_TRAFFIC, GNUNET_DHT_ClientPutMessage::options, size, GNUNET_MessageHeader::size, and GNUNET_DHT_ClientPutMessage::type.

{
  struct ClientHandle *ch = cls;
  struct GNUNET_CONTAINER_BloomFilter *peer_bf;
  uint16_t size;

  size = ntohs(dht_msg->header.size);
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# 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 */
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Handling local PUT of %u-bytes for query %s\n",
      size - sizeof(struct GNUNET_DHT_ClientPutMessage),
      GNUNET_h2s(&dht_msg->key));
  GDS_CLIENTS_handle_reply(GNUNET_TIME_absolute_ntoh(dht_msg->expiration),
                           &dht_msg->key,
                           0,
                           NULL,
                           0,
                           NULL,
                           ntohl(dht_msg->type),
                           size - sizeof(struct GNUNET_DHT_ClientPutMessage),
                           &dht_msg[1]);
  /* store locally */
  GDS_DATACACHE_handle_put(GNUNET_TIME_absolute_ntoh(dht_msg->expiration),
                           &dht_msg->key,
                           0,
                           NULL,
                           ntohl(dht_msg->type),
                           size - sizeof(struct GNUNET_DHT_ClientPutMessage),
                           &dht_msg[1]);
  /* route to other peers */
  peer_bf
    = GNUNET_CONTAINER_bloomfilter_init(NULL,
                                        DHT_BLOOM_SIZE,
                                        GNUNET_CONSTANTS_BLOOMFILTER_K);
  GDS_NEIGHBOURS_handle_put(ntohl(dht_msg->type),
                            ntohl(dht_msg->options),
                            ntohl(dht_msg->desired_replication_level),
                            GNUNET_TIME_absolute_ntoh(dht_msg->expiration),
                            0 /* hop count */,
                            peer_bf,
                            &dht_msg->key,
                            0,
                            NULL,
                            &dht_msg[1],
                            size - sizeof(struct GNUNET_DHT_ClientPutMessage));
  GDS_CLIENTS_process_put(ntohl(dht_msg->options),
                          ntohl(dht_msg->type),
                          0,
                          ntohl(dht_msg->desired_replication_level),
                          1,
                          GDS_NEIGHBOURS_get_id(),
                          GNUNET_TIME_absolute_ntoh(dht_msg->expiration),
                          &dht_msg->key,
                          &dht_msg[1],
                          size - sizeof(struct GNUNET_DHT_ClientPutMessage));
  GNUNET_CONTAINER_bloomfilter_free(peer_bf);
  GNUNET_SERVICE_client_continue(ch->client);
}

Here is the call graph for this function:

check_dht_local_get()

static int 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
message	the actual message received

Returns

GNUNET_OK (always)

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

References GNUNET_OK.

{
  /* always well-formed */
  return GNUNET_OK;
}

handle_local_result()

static void handle_local_result ( void *  cls, enum GNUNET_BLOCK_Type  type, struct GNUNET_TIME_Absolute  expiration_time, const struct GNUNET_HashCode *  key, unsigned int  put_path_length, const struct GNUNET_PeerIdentity *  put_path, unsigned int  get_path_length, const struct GNUNET_PeerIdentity *  get_path, const void *  data, size_t  data_size  )

static

Handle a result from local datacache for a GET operation.

Parameters

cls	the struct ClientHandle of the client doing the query
type	type of the block
expiration_time	when does the content expire
key	key for the content
put_path_length	number of entries in put_path
put_path	peers the original PUT traversed (if tracked)
get_path_length	number of entries in get_path
get_path	peers this reply has traversed so far (if tracked)
data	payload of the reply
data_size	number of bytes in data

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

References GDS_CLIENTS_handle_reply().

Referenced by handle_dht_local_get().

{
  // FIXME: this needs some clean up: inline the function,
  // possibly avoid even looking up the client!
  GDS_CLIENTS_handle_reply(expiration_time,
                           key,
                           0, NULL,
                           put_path_length, put_path,
                           type,
                           data_size, data);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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
message	the actual message received

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

References ClientQueryRecord::ch, ClientHandle::client, ClientHandle::cqr_head, ClientHandle::cqr_tail, GDS_CLIENTS_process_get(), GDS_DATACACHE_handle_get(), GDS_NEIGHBOURS_get_id(), gettext_noop, 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_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, ClientQueryRecord::retry_time, size, transmit_next_request_task(), ClientQueryRecord::type, ClientQueryRecord::unique_id, ClientQueryRecord::xquery, and ClientQueryRecord::xquery_size.

{
  struct ClientHandle *ch = cls;
  struct ClientQueryRecord *cqr;
  size_t xquery_size;
  const char *xquery;
  uint16_t size;

  size = ntohs(get->header.size);
  xquery_size = size - sizeof(struct GNUNET_DHT_ClientGetMessage);
  xquery = (const char *)&get[1];
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop
                             ("# GET requests received from clients"), 1,
                           GNUNET_NO);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Received GET request for %s from local client %p, xq: %.*s\n",
      GNUNET_h2s(&get->key),
      ch->client,
      xquery_size,
      xquery);
  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 = (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(ntohl(get->options),
                          ntohl(get->type),
                          0,
                          ntohl(get->desired_replication_level),
                          1,
                          GDS_NEIGHBOURS_get_id(),
                          &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 int 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 689 of file gnunet-service-dht_clients.c.

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

Referenced by handle_dht_local_get_result_seen().

{
  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;
}

Here is the caller graph for this function:

check_dht_local_get_result_seen()

static int 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
message	the actual message received

Returns

GNUNET_OK if seen is well-formed

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

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

{
  uint16_t size;
  unsigned int hash_count;

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

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
message	the actual message received

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

References ClientQueryRecord::ch, ClientHandle::client, FindByUniqueIdContext::cqr, find_by_unique_id(), 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, size, GNUNET_MessageHeader::size, GNUNET_DHT_ClientGetResultSeenMessage::unique_id, and FindByUniqueIdContext::unique_id.

{
  struct ClientHandle *ch = cls;
  uint16_t size;
  unsigned int hash_count;
  unsigned int old_count;
  const struct GNUNET_HashCode *hc;
  struct FindByUniqueIdContext fui_ctx;
  struct ClientQueryRecord *cqr;

  size = ntohs(seen->header.size);
  hash_count = (size - sizeof(struct GNUNET_DHT_ClientGetResultSeenMessage)) / sizeof(struct GNUNET_HashCode);
  hc = (const struct GNUNET_HashCode*)&seen[1];
  fui_ctx.unique_id = seen->unique_id;
  fui_ctx.cqr = NULL;
  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);
}

Here is the call graph for this function:

remove_by_unique_id()

static int 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 798 of file gnunet-service-dht_clients.c.

References RemoveByUniqueIdContext::ch, ClientHandle::client, ctx, GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_log, GNUNET_YES, remove_client_record(), ClientQueryRecord::unique_id, RemoveByUniqueIdContext::unique_id, and value.

Referenced by handle_dht_local_get_stop().

{
  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_record(cqr);
  return GNUNET_YES;
}

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
message	the actual message received

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

References ClientQueryRecord::ch, RemoveByUniqueIdContext::ch, ClientHandle::client, gettext_noop, 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(), GNUNET_DHT_ClientGetStopMessage::unique_id, and RemoveByUniqueIdContext::unique_id.

{
  struct ClientHandle *ch = cls;
  struct RemoveByUniqueIdContext ctx;

  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop
                             ("# 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);
}

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 857 of file gnunet-service-dht_clients.c.

References ClientQueryRecord::ch, ClientMonitorRecord::ch, ClientHandle::client, GNUNET_DHT_MonitorStartStopMessage::filter_key, ClientMonitorRecord::get, GNUNET_DHT_MonitorStartStopMessage::get, ClientMonitorRecord::get_resp, GNUNET_DHT_MonitorStartStopMessage::get_resp, GNUNET_CONTAINER_DLL_insert, GNUNET_memcpy, GNUNET_new, GNUNET_SERVICE_client_continue(), ClientMonitorRecord::key, GNUNET_DHT_MonitorStartStopMessage::key, ClientMonitorRecord::put, GNUNET_DHT_MonitorStartStopMessage::put, ClientMonitorRecord::type, and GNUNET_DHT_MonitorStartStopMessage::type.

{
  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 = NULL;
    }
  else
    {
      r->key = GNUNET_new(struct GNUNET_HashCode);
      GNUNET_memcpy(r->key,
                    &msg->key,
                    sizeof(struct GNUNET_HashCode));
    }
  GNUNET_CONTAINER_DLL_insert(monitor_head,
                              monitor_tail,
                              r);
  GNUNET_SERVICE_client_continue(ch->client);
}

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 894 of file gnunet-service-dht_clients.c.

References ClientQueryRecord::ch, ClientMonitorRecord::ch, ClientHandle::client, GNUNET_DHT_MonitorStartStopMessage::filter_key, ClientMonitorRecord::get, GNUNET_DHT_MonitorStartStopMessage::get, ClientMonitorRecord::get_resp, GNUNET_DHT_MonitorStartStopMessage::get_resp, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_free_non_null, GNUNET_SERVICE_client_continue(), ClientMonitorRecord::key, GNUNET_DHT_MonitorStartStopMessage::key, ClientMonitorRecord::next, ClientMonitorRecord::put, GNUNET_DHT_MonitorStartStopMessage::put, ClientMonitorRecord::type, and GNUNET_DHT_MonitorStartStopMessage::type.

{
  struct ClientHandle *ch = cls;
  struct ClientMonitorRecord *r;
  int keys_match;

  GNUNET_SERVICE_client_continue(ch->client);
  for (r = monitor_head; NULL != r; r = r->next)
    {
      if (NULL == r->key)
        {
          keys_match = (0 == ntohs(msg->filter_key));
        }
      else
        {
          keys_match = ((0 != ntohs(msg->filter_key)) &&
                        (!memcmp(r->key,
                                 &msg->key,
                                 sizeof(struct GNUNET_HashCode))));
        }
      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_non_null(r->key);
          GNUNET_free(r);
          return; /* Delete only ONE entry */
        }
    }
}

Here is the call graph for this function:

forward_reply()

static int forward_reply ( void *  cls, const struct GNUNET_HashCode *  key, 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'
key	current key
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 991 of file gnunet-service-dht_clients.c.

References _, ClientQueryRecord::ch, ClientHandle::client, ForwardReplyContext::data, ForwardReplyContext::data_size, env, GNUNET_DHT_ClientResultMessage::expiration, ForwardReplyContext::expiration, ForwardReplyContext::get_path, GNUNET_DHT_ClientResultMessage::get_path_length, ForwardReplyContext::get_path_length, gettext_noop, GNUNET_array_append, GNUNET_BLOCK_EO_NONE, GNUNET_BLOCK_evaluate(), GNUNET_BLOCK_EVALUATION_OK_DUPLICATE, GNUNET_BLOCK_EVALUATION_OK_LAST, GNUNET_BLOCK_EVALUATION_OK_MORE, GNUNET_BLOCK_EVALUATION_REQUEST_INVALID, GNUNET_BLOCK_EVALUATION_REQUEST_VALID, GNUNET_BLOCK_EVALUATION_RESULT_INVALID, GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT, GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED, GNUNET_BLOCK_TYPE_ANY, GNUNET_break, GNUNET_break_op, GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_h2s(), GNUNET_h2s_full(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_hton(), GNUNET_YES, GNUNET_DHT_ClientResultMessage::key, ClientQueryRecord::key, LOG, LOG_TRAFFIC, ClientHandle::mq, ForwardReplyContext::put_path, GNUNET_DHT_ClientResultMessage::put_path_length, ForwardReplyContext::put_path_length, record(), remove_client_record(), ClientQueryRecord::seen_replies, ClientQueryRecord::seen_replies_count, ClientQueryRecord::type, GNUNET_DHT_ClientResultMessage::type, ForwardReplyContext::type, ClientQueryRecord::unique_id, GNUNET_DHT_ClientResultMessage::unique_id, value, ClientQueryRecord::xquery, and ClientQueryRecord::xquery_size.

Referenced by GDS_CLIENTS_handle_reply().

{
  struct ForwardReplyContext *frc = cls;
  struct ClientQueryRecord *record = value;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_ClientResultMessage *reply;
  enum GNUNET_BLOCK_EvaluationResult eval;
  int do_free;
  struct GNUNET_HashCode ch;
  struct GNUNET_PeerIdentity *paths;

  LOG_TRAFFIC(GNUNET_ERROR_TYPE_DEBUG,
              "CLIENT-RESULT %s\n",
              GNUNET_h2s_full(key));
  if ((record->type != GNUNET_BLOCK_TYPE_ANY) &&
      (record->type != frc->type))
    {
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "Record type mismatch, not passing request for key %s to local client\n",
          GNUNET_h2s(key));
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop
                                 ("# Key match, type mismatches in REPLY to CLIENT"),
                               1, GNUNET_NO);
      return GNUNET_YES;        /* type mismatch */
    }
  GNUNET_CRYPTO_hash(frc->data, frc->data_size, &ch);
  for (unsigned int i = 0; i < record->seen_replies_count; i++)
    if (0 == memcmp(&record->seen_replies[i],
                    &ch,
                    sizeof(struct GNUNET_HashCode)))
      {
        LOG(GNUNET_ERROR_TYPE_DEBUG,
            "Duplicate reply, not passing request for key %s to local client\n",
            GNUNET_h2s(key));
        GNUNET_STATISTICS_update(GDS_stats,
                                 gettext_noop
                                   ("# Duplicate REPLIES to CLIENT request dropped"),
                                 1, GNUNET_NO);
        return GNUNET_YES;      /* duplicate */
      }
  eval
    = GNUNET_BLOCK_evaluate(GDS_block_context,
                            record->type,
                            NULL,
                            GNUNET_BLOCK_EO_NONE,
                            key,
                            record->xquery,
                            record->xquery_size,
                            frc->data,
                            frc->data_size);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Evaluation result is %d for key %s for local client's query\n",
      (int)eval,
      GNUNET_h2s(key));
  switch (eval)
    {
    case GNUNET_BLOCK_EVALUATION_OK_LAST:
      do_free = GNUNET_YES;
      break;

    case GNUNET_BLOCK_EVALUATION_OK_MORE:
      GNUNET_array_append(record->seen_replies,
                          record->seen_replies_count,
                          ch);
      do_free = GNUNET_NO;
      break;

    case GNUNET_BLOCK_EVALUATION_OK_DUPLICATE:
      /* should be impossible to encounter here */
      GNUNET_break(0);
      return GNUNET_YES;

    case GNUNET_BLOCK_EVALUATION_RESULT_INVALID:
      GNUNET_break_op(0);
      return GNUNET_NO;

    case GNUNET_BLOCK_EVALUATION_REQUEST_VALID:
      GNUNET_break(0);
      return GNUNET_NO;

    case GNUNET_BLOCK_EVALUATION_REQUEST_INVALID:
      GNUNET_break(0);
      return GNUNET_NO;

    case GNUNET_BLOCK_EVALUATION_RESULT_IRRELEVANT:
      return GNUNET_YES;

    case GNUNET_BLOCK_EVALUATION_TYPE_NOT_SUPPORTED:
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 _("Unsupported block type (%u) in request!\n"), record->type);
      return GNUNET_NO;

    default:
      GNUNET_break(0);
      return GNUNET_NO;
    }
  GNUNET_STATISTICS_update(GDS_stats,
                           gettext_noop("# RESULTS queued for clients"),
                           1,
                           GNUNET_NO);
  env = GNUNET_MQ_msg_extra(reply,
                            frc->data_size +
                            (frc->get_path_length + frc->put_path_length) * sizeof(struct GNUNET_PeerIdentity),
                            GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT);
  reply->type = htonl(frc->type);
  reply->get_path_length = htonl(frc->get_path_length);
  reply->put_path_length = htonl(frc->put_path_length);
  reply->unique_id = record->unique_id;
  reply->expiration = GNUNET_TIME_absolute_hton(frc->expiration);
  reply->key = *key;
  paths = (struct GNUNET_PeerIdentity *)&reply[1];
  GNUNET_memcpy(paths,
                frc->put_path,
                sizeof(struct GNUNET_PeerIdentity) * frc->put_path_length);
  GNUNET_memcpy(&paths[frc->put_path_length],
                frc->get_path,
                sizeof(struct GNUNET_PeerIdentity) * frc->get_path_length);
  GNUNET_memcpy(&paths[frc->get_path_length + frc->put_path_length],
                frc->data,
                frc->data_size);
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Sending reply to query %s for client %p\n",
      GNUNET_h2s(key),
      record->ch->client);
  GNUNET_MQ_send(record->ch->mq,
                 env);
  if (GNUNET_YES == do_free)
    remove_client_record(record);
  return GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_handle_reply()

void GDS_CLIENTS_handle_reply	(	struct GNUNET_TIME_Absolute	expiration,
		const struct GNUNET_HashCode *	key,
		unsigned int	get_path_length,
		const struct GNUNET_PeerIdentity *	get_path,
		unsigned int	put_path_length,
		const struct GNUNET_PeerIdentity *	put_path,
		enum GNUNET_BLOCK_Type	type,
		size_t	data_size,
		const void *	data
	)

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

expiration	when will the reply expire
key	the query this reply is for
get_path_length	number of peers in get_path
get_path	path the reply took on get
put_path_length	number of peers in put_path
put_path	path the reply took on put
type	type of the reply
data_size	number of bytes in data
data	application payload data

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

References data, ForwardReplyContext::data, data_size, ForwardReplyContext::data_size, expiration, ForwardReplyContext::expiration, forward_reply(), ForwardReplyContext::get_path, ForwardReplyContext::get_path_length, gettext_noop, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_get_multiple(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_NO, GNUNET_STATISTICS_update(), LOG, ForwardReplyContext::put_path, ForwardReplyContext::put_path_length, ClientQueryRecord::type, and ForwardReplyContext::type.

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

{
  struct ForwardReplyContext frc;
  size_t msize;

  msize = sizeof(struct GNUNET_DHT_ClientResultMessage) + data_size +
          (get_path_length + put_path_length) * sizeof(struct GNUNET_PeerIdentity);
  if (msize >= GNUNET_MAX_MESSAGE_SIZE)
    {
      GNUNET_break(0);
      return;
    }
  if (NULL == GNUNET_CONTAINER_multihashmap_get(forward_map,
                                                key))
    {
      LOG(GNUNET_ERROR_TYPE_DEBUG,
          "No matching client for reply for key %s\n",
          GNUNET_h2s(key));
      GNUNET_STATISTICS_update(GDS_stats,
                               gettext_noop("# REPLIES ignored for CLIENTS (no match)"),
                               1,
                               GNUNET_NO);
      return;                   /* no matching request, fast exit! */
    }
  frc.expiration = expiration;
  frc.get_path = get_path;
  frc.put_path = put_path;
  frc.data = data;
  frc.data_size = data_size;
  frc.get_path_length = get_path_length;
  frc.put_path_length = put_path_length;
  frc.type = type;
  LOG(GNUNET_ERROR_TYPE_DEBUG,
      "Forwarding reply for key %s to client\n",
      GNUNET_h2s(key));
  GNUNET_CONTAINER_multihashmap_get_multiple(forward_map,
                                             key,
                                             &forward_reply,
                                             &frc);
}

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	(	uint32_t	options,
		enum GNUNET_BLOCK_Type	type,
		uint32_t	hop_count,
		uint32_t	desired_replication_level,
		unsigned int	path_length,
		const struct GNUNET_PeerIdentity *	path,
		const struct GNUNET_HashCode *	key
	)

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

Parameters

options	Options, for instance RecordRoute, DemultiplexEverywhere.
type	The type of data in the request.
hop_count	Hop count so far.
path_length	number of entries in path (or 0 if not recorded).
path	peers on the GET path (or NULL if not recorded).
desired_replication_level	Desired replication level.
key	Key of the requested data.

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

References ClientMonitorRecord::ch, GNUNET_DHT_MonitorGetMessage::desired_replication_level, env, GNUNET_DHT_MonitorGetMessage::get_path_length, GNUNET_array_append, GNUNET_BLOCK_TYPE_ANY, GNUNET_free_non_null, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_DHT_MonitorGetMessage::hop_count, ClientMonitorRecord::key, GNUNET_DHT_MonitorGetMessage::key, ClientQueryRecord::key, m, ClientHandle::mq, ClientMonitorRecord::next, GNUNET_DHT_MonitorGetMessage::options, ClientMonitorRecord::type, and GNUNET_DHT_MonitorGetMessage::type.

Referenced by handle_dht_local_get(), and handle_dht_p2p_get().

{
  struct ClientMonitorRecord *m;
  struct ClientHandle **cl;
  unsigned int cl_size;

  cl = NULL;
  cl_size = 0;
  for (m = monitor_head; NULL != m; m = m->next)
    {
      if (((GNUNET_BLOCK_TYPE_ANY == m->type) ||
           (m->type == type)) &&
          ((NULL == m->key) ||
           (0 == memcmp(key,
                        m->key,
                        sizeof(struct GNUNET_HashCode)))))
        {
          struct GNUNET_MQ_Envelope *env;
          struct GNUNET_DHT_MonitorGetMessage *mmsg;
          struct GNUNET_PeerIdentity *msg_path;
          size_t msize;
          unsigned int i;

          /* Don't send duplicates */
          for (i = 0; i < cl_size; i++)
            if (cl[i] == m->ch)
              break;
          if (i < cl_size)
            continue;
          GNUNET_array_append(cl,
                              cl_size,
                              m->ch);

          msize = path_length * sizeof(struct GNUNET_PeerIdentity);
          env = GNUNET_MQ_msg_extra(mmsg,
                                    msize,
                                    GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET);
          mmsg->options = htonl(options);
          mmsg->type = htonl(type);
          mmsg->hop_count = htonl(hop_count);
          mmsg->desired_replication_level = htonl(desired_replication_level);
          mmsg->get_path_length = htonl(path_length);
          mmsg->key = *key;
          msg_path = (struct GNUNET_PeerIdentity *)&mmsg[1];
          GNUNET_memcpy(msg_path,
                        path,
                        path_length * sizeof(struct GNUNET_PeerIdentity));
          GNUNET_MQ_send(m->ch->mq,
                         env);
        }
    }
  GNUNET_free_non_null(cl);
}

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	(	enum GNUNET_BLOCK_Type	type,
		const struct GNUNET_PeerIdentity *	get_path,
		unsigned int	get_path_length,
		const struct GNUNET_PeerIdentity *	put_path,
		unsigned int	put_path_length,
		struct GNUNET_TIME_Absolute	exp,
		const struct GNUNET_HashCode *	key,
		const void *	data,
		size_t	size
	)

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

Parameters

type	The type of data in the result.
get_path	Peers on GET path (or NULL if not recorded).
get_path_length	number of entries in get_path.
put_path	peers on the PUT path (or NULL if not recorded).
put_path_length	number of entries in get_path.
exp	Expiration time of the data.
key	Key of the data.
data	Pointer to the result data.
size	Number of bytes in data.

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

References ClientMonitorRecord::ch, env, GNUNET_DHT_MonitorGetRespMessage::expiration_time, GNUNET_DHT_MonitorGetRespMessage::get_path_length, GNUNET_array_append, GNUNET_BLOCK_TYPE_ANY, GNUNET_free_non_null, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), ClientMonitorRecord::key, GNUNET_DHT_MonitorGetRespMessage::key, ClientQueryRecord::key, m, ClientHandle::mq, ClientMonitorRecord::next, GNUNET_DHT_MonitorGetRespMessage::put_path_length, size, ClientMonitorRecord::type, and GNUNET_DHT_MonitorGetRespMessage::type.

Referenced by process_reply_with_path().

{
  struct ClientMonitorRecord *m;
  struct ClientHandle **cl;
  unsigned int cl_size;

  cl = NULL;
  cl_size = 0;
  for (m = monitor_head; NULL != m; m = m->next)
    {
      if ((GNUNET_BLOCK_TYPE_ANY == m->type || m->type == type) &&
          (NULL == m->key ||
           memcmp(key, m->key, sizeof(struct GNUNET_HashCode)) == 0))
        {
          struct GNUNET_MQ_Envelope *env;
          struct GNUNET_DHT_MonitorGetRespMessage *mmsg;
          struct GNUNET_PeerIdentity *path;
          size_t msize;
          unsigned int i;

          /* Don't send duplicates */
          for (i = 0; i < cl_size; i++)
            if (cl[i] == m->ch)
              break;
          if (i < cl_size)
            continue;
          GNUNET_array_append(cl,
                              cl_size,
                              m->ch);

          msize = size;
          msize += (get_path_length + put_path_length)
                   * sizeof(struct GNUNET_PeerIdentity);
          env = GNUNET_MQ_msg_extra(mmsg,
                                    msize,
                                    GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP);
          mmsg->type = htonl(type);
          mmsg->put_path_length = htonl(put_path_length);
          mmsg->get_path_length = htonl(get_path_length);
          mmsg->expiration_time = GNUNET_TIME_absolute_hton(exp);
          mmsg->key = *key;
          path = (struct GNUNET_PeerIdentity *)&mmsg[1];
          GNUNET_memcpy(path,
                        put_path,
                        put_path_length * sizeof(struct GNUNET_PeerIdentity));
          GNUNET_memcpy(path,
                        get_path,
                        get_path_length * sizeof(struct GNUNET_PeerIdentity));
          GNUNET_memcpy(&path[get_path_length],
                        data,
                        size);
          GNUNET_MQ_send(m->ch->mq,
                         env);
        }
    }
  GNUNET_free_non_null(cl);
}

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	(	uint32_t	options,
		enum GNUNET_BLOCK_Type	type,
		uint32_t	hop_count,
		uint32_t	desired_replication_level,
		unsigned int	path_length,
		const struct GNUNET_PeerIdentity *	path,
		struct GNUNET_TIME_Absolute	exp,
		const struct GNUNET_HashCode *	key,
		const void *	data,
		size_t	size
	)

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

Parameters

options	Options, for instance RecordRoute, DemultiplexEverywhere.
type	The type of data in the request.
hop_count	Hop count so far.
path_length	number of entries in path (or 0 if not recorded).
path	peers on the PUT path (or NULL if not recorded).
desired_replication_level	Desired replication level.
exp	Expiration time of the data.
key	Key under which data is to be stored.
data	Pointer to the data carried.
size	Number of bytes in data.

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

References ClientMonitorRecord::ch, GNUNET_DHT_MonitorPutMessage::desired_replication_level, env, GNUNET_DHT_MonitorPutMessage::expiration_time, GNUNET_array_append, GNUNET_BLOCK_TYPE_ANY, GNUNET_free_non_null, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_TIME_absolute_hton(), GNUNET_DHT_MonitorPutMessage::hop_count, ClientMonitorRecord::key, GNUNET_DHT_MonitorPutMessage::key, ClientQueryRecord::key, m, ClientHandle::mq, ClientMonitorRecord::next, GNUNET_DHT_MonitorPutMessage::options, GNUNET_DHT_MonitorPutMessage::put_path_length, size, ClientMonitorRecord::type, and GNUNET_DHT_MonitorPutMessage::type.

Referenced by handle_dht_local_put(), and handle_dht_p2p_put().

{
  struct ClientMonitorRecord *m;
  struct ClientHandle **cl;
  unsigned int cl_size;

  cl = NULL;
  cl_size = 0;
  for (m = monitor_head; NULL != m; m = m->next)
    {
      if ((GNUNET_BLOCK_TYPE_ANY == m->type || m->type == type) &&
          (NULL == m->key ||
           memcmp(key, m->key, sizeof(struct GNUNET_HashCode)) == 0))
        {
          struct GNUNET_MQ_Envelope *env;
          struct GNUNET_DHT_MonitorPutMessage *mmsg;
          struct GNUNET_PeerIdentity *msg_path;
          size_t msize;
          unsigned int i;

          /* Don't send duplicates */
          for (i = 0; i < cl_size; i++)
            if (cl[i] == m->ch)
              break;
          if (i < cl_size)
            continue;
          GNUNET_array_append(cl,
                              cl_size,
                              m->ch);

          msize = size;
          msize += path_length * sizeof(struct GNUNET_PeerIdentity);
          env = GNUNET_MQ_msg_extra(mmsg,
                                    msize,
                                    GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT);
          mmsg->options = htonl(options);
          mmsg->type = htonl(type);
          mmsg->hop_count = htonl(hop_count);
          mmsg->desired_replication_level = htonl(desired_replication_level);
          mmsg->put_path_length = htonl(path_length);
          mmsg->key = *key;
          mmsg->expiration_time = GNUNET_TIME_absolute_hton(exp);
          msg_path = (struct GNUNET_PeerIdentity *)&mmsg[1];
          GNUNET_memcpy(msg_path,
                        path,
                        path_length * sizeof(struct GNUNET_PeerIdentity));
          GNUNET_memcpy(&msg_path[path_length],
                        data,
                        size);
          GNUNET_MQ_send(m->ch->mq,
                         env);
        }
    }
  GNUNET_free_non_null(cl);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_init()

static void GDS_CLIENTS_init ( )

static

Initialize client subsystem.

Parameters

server

the initialized server

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

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

Referenced by run().

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

Here is the call graph for this function:

Here is the caller graph for this function:

GDS_CLIENTS_stop()

static void GDS_CLIENTS_stop ( )

static

Shutdown client subsystem.

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

References GNUNET_SCHEDULER_cancel().

Referenced by shutdown_task().

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

Here is the call graph for this function:

Here is the caller graph for this function:

__attribute__()

void __attribute__

(

(destructor)

)

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

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

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

{
  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;
    }
}

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 212 of file gnunet-service-dht_clients.c.

Referenced by datacache_get_iterator(), handle_dht_p2p_get(), handle_dht_p2p_put(), handle_find_peer(), process(), run(), send_find_peer_message(), and shutdown_task().

GDS_stats

struct GNUNET_STATISTICS_Handle* GDS_stats

Handle for the statistics service.

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

Referenced by datacache_get_iterator(), expire_oldest_entry(), GDS_DATACACHE_handle_get(), GDS_DATACACHE_handle_put(), GDS_NEIGHBOURS_handle_get(), GDS_NEIGHBOURS_handle_put(), GDS_NEIGHBOURS_handle_reply(), GDS_ROUTING_add(), get_forward_count(), handle_core_connect(), handle_core_disconnect(), handle_dht_p2p_get(), handle_dht_p2p_put(), handle_dht_p2p_result(), handle_find_peer(), process(), process_hello(), run(), select_peer(), send_find_peer_message(), shutdown_task(), and update_network_size_estimate().

GDS_service

struct GNUNET_SERVICE_Handle* GDS_service

Handle for the service.

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

Referenced by core_init(), 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 227 of file gnunet-service-dht_clients.c.

Referenced by GDS_DATACACHE_init(), GDS_HELLO_init(), GDS_NEIGHBOURS_init(), GDS_NSE_init(), run(), and try_connect().

monitor_head

struct ClientMonitorRecord* monitor_head

static

List of active monitoring requests.

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

Referenced by client_disconnect_cb().

monitor_tail

struct ClientMonitorRecord* monitor_tail

static

List of active monitoring requests.

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

forward_map

struct GNUNET_CONTAINER_MultiHashMap* forward_map

static

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

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

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 247 of file gnunet-service-dht_clients.c.

retry_task

struct GNUNET_SCHEDULER_Task* retry_task

static

Task that re-transmits requests (using retry_heap).

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