dht_api.c File Reference

library to access the DHT service More...

#include "platform.h"
#include "gnunet_constants.h"
#include "gnunet_signatures.h"
#include "gnunet_arm_service.h"
#include "gnunet_protocols.h"
#include "gnunet_dht_service.h"
#include "dht.h"

Include dependency graph for dht_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_DHT_PutHandle
	Handle to a PUT request. More...
struct	GNUNET_DHT_GetHandle
	Handle to a GET request. More...
struct	GNUNET_DHT_MonitorHandle
	Handle to a monitoring request. More...
struct	GNUNET_DHT_HelloGetHandle
	Handle to get a HELLO URL from the DHT for manual bootstrapping. More...
struct	GNUNET_DHT_Handle
	Connection to the DHT service. More...

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

Functions
static enum GNUNET_GenericReturnValue	try_connect (struct GNUNET_DHT_Handle *h)
	Try to (re)connect to the DHT service.
static void	send_get (struct GNUNET_DHT_GetHandle *gh)
	Send GET message for a get_handle to DHT.
static void	send_get_known_results (struct GNUNET_DHT_GetHandle *gh, unsigned int transmission_offset_start)
	Send GET message(s) for indicating which results are already known for a get_handle to DHT.
static enum GNUNET_GenericReturnValue	add_get_request_to_pending (void *cls, const struct GNUNET_HashCode *key, void *value)
	Add the GET request corresponding to the given route handle to the pending queue (if it is not already in there).
static void	send_monitor_start (struct GNUNET_DHT_MonitorHandle *mh)
	Send GNUNET_MESSAGE_TYPE_DHT_MONITOR_START message.
static void	try_reconnect (void *cls)
	Try reconnecting to the dht service.
static void	do_disconnect (struct GNUNET_DHT_Handle *h)
	Try reconnecting to the DHT service.
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.
static void	handle_monitor_get (void *cls, const struct GNUNET_DHT_MonitorGetMessage *msg)
	Process a get monitor message from the service.
static enum GNUNET_GenericReturnValue	check_monitor_get_resp (void *cls, const struct GNUNET_DHT_MonitorGetRespMessage *msg)
	Validate a get response monitor message from the service.
static void	handle_monitor_get_resp (void *cls, const struct GNUNET_DHT_MonitorGetRespMessage *msg)
	Process a get response monitor message from the service.
static enum GNUNET_GenericReturnValue	check_monitor_put (void *cls, const struct GNUNET_DHT_MonitorPutMessage *msg)
	Check validity of a put monitor message from the service.
static void	handle_monitor_put (void *cls, const struct GNUNET_DHT_MonitorPutMessage *msg)
	Process a put monitor message from the service.
static enum GNUNET_GenericReturnValue	check_client_result (void *cls, const struct GNUNET_DHT_ClientResultMessage *msg)
	Verify that client result message received from the service is well-formed.
static enum GNUNET_GenericReturnValue	process_client_result (void *cls, const struct GNUNET_HashCode *key, void *value)
	Process a given reply that might match the given request.
static void	handle_client_result (void *cls, const struct GNUNET_DHT_ClientResultMessage *msg)
	Process a client result message received from the service.
static enum GNUNET_GenericReturnValue	check_client_hello (void *cls, const struct GNUNET_MessageHeader *hdr)
	Process a client HELLO message received from the service.
static void	handle_client_hello (void *cls, const struct GNUNET_MessageHeader *hdr)
	Process a client HELLO message received from the service.
static void	handle_put_cont (void *cls)
	Process a MQ PUT transmission notification.
struct GNUNET_DHT_Handle *	GNUNET_DHT_connect (const struct GNUNET_CONFIGURATION_Handle *cfg, unsigned int ht_len)
	Initialize the connection with the DHT service.
void	GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle)
	Shutdown connection with the DHT service.
struct GNUNET_DHT_PutHandle *	GNUNET_DHT_put (struct GNUNET_DHT_Handle *handle, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, enum GNUNET_BLOCK_Type type, size_t size, const void *data, struct GNUNET_TIME_Absolute exp, GNUNET_SCHEDULER_TaskCallback cont, void *cont_cls)
	Perform a PUT operation storing data in the DHT.
void	GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph)
	Cancels a DHT PUT operation.
struct GNUNET_DHT_GetHandle *	GNUNET_DHT_get_start (struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, uint32_t desired_replication_level, enum GNUNET_DHT_RouteOption options, const void *xquery, size_t xquery_size, GNUNET_DHT_GetIterator iter, void *iter_cls)
	Perform an asynchronous GET operation on the DHT identified.
void	GNUNET_DHT_get_filter_known_results (struct GNUNET_DHT_GetHandle *get_handle, unsigned int num_results, const struct GNUNET_HashCode *results)
	Tell the DHT not to return any of the following known results to this client.
void	GNUNET_DHT_get_stop (struct GNUNET_DHT_GetHandle *get_handle)
	Stop async DHT-get.
struct GNUNET_DHT_MonitorHandle *	GNUNET_DHT_monitor_start (struct GNUNET_DHT_Handle *handle, enum GNUNET_BLOCK_Type type, const struct GNUNET_HashCode *key, GNUNET_DHT_MonitorGetCB get_cb, GNUNET_DHT_MonitorGetRespCB get_resp_cb, GNUNET_DHT_MonitorPutCB put_cb, void *cb_cls)
	Start monitoring the local DHT service.
void	GNUNET_DHT_monitor_stop (struct GNUNET_DHT_MonitorHandle *mh)
	Stop monitoring.
char *	GNUNET_DHT_pp2s (const struct GNUNET_DHT_PathElement *path, unsigned int path_len)
	Convert a peer path to a human-readable string.
unsigned int	GNUNET_DHT_verify_path (const void *data, size_t data_size, struct GNUNET_TIME_Absolute exp_time, const struct GNUNET_PeerIdentity *bpid, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_len, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_len, const struct GNUNET_PeerIdentity *me)
	Verify signatures on a path consisting of put_path and get_path in reverse order (starting at the last element of the get_path).
struct GNUNET_DHT_HelloGetHandle *	GNUNET_DHT_hello_get (struct GNUNET_DHT_Handle *dht_handle, GNUNET_DHT_HelloGetCallback cb, void *cb_cls)
	Obtain HELLO URL of the DHT identified by dht_handle.
void	GNUNET_DHT_hello_get_cancel (struct GNUNET_DHT_HelloGetHandle *hgh)
	Cancel hello get operation.
void	GNUNET_DHT_hello_offer (struct GNUNET_DHT_Handle *dht_handle, const char *url, GNUNET_SCHEDULER_TaskCallback cb, void *cb_cls)
	Offer HELLO URL of the DHT identified by dht_handle.

Detailed Description

library to access the DHT service

Author

Christian Grothoff

Nathan Evans

Definition in file dht_api.c.

Macro Definition Documentation

LOG

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

Definition at line 36 of file dht_api.c.

Function Documentation

try_connect()

static enum GNUNET_GenericReturnValue try_connect ( struct GNUNET_DHT_Handle *  h )

static

Try to (re)connect to the DHT service.

Parameters

h	DHT handle to reconnect

Returns

GNUNET_YES on success, GNUNET_NO on failure.

Definition at line 992 of file dht_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_fixed_size (monitor_get,
                             GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET,
                             struct GNUNET_DHT_MonitorGetMessage,
                             h),
    GNUNET_MQ_hd_var_size (monitor_get_resp,
                           GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP,
                           struct GNUNET_DHT_MonitorGetRespMessage,
                           h),
    GNUNET_MQ_hd_var_size (monitor_put,
                           GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT,
                           struct GNUNET_DHT_MonitorPutMessage,
                           h),
    GNUNET_MQ_hd_var_size (client_result,
                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT,
                           struct GNUNET_DHT_ClientResultMessage,
                           h),
    GNUNET_MQ_hd_var_size (client_hello,
                           GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL,
                           struct GNUNET_MessageHeader,
                           h),
    GNUNET_MQ_handler_end ()
  };
 
  if (NULL != h->mq)
    return GNUNET_OK;
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "dht",
                                 handlers,
                                 &mq_error_handler,
                                 h);
  if (NULL == h->mq)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Failed to connect to the DHT service!\n");
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

References GNUNET_ARM_Handle::cfg, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_WARNING, GNUNET_MESSAGE_TYPE_DHT_CLIENT_HELLO_URL, GNUNET_MESSAGE_TYPE_DHT_CLIENT_RESULT, GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET, GNUNET_MESSAGE_TYPE_DHT_MONITOR_GET_RESP, GNUNET_MESSAGE_TYPE_DHT_MONITOR_PUT, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_NO, GNUNET_OK, GNUNET_YES, h, handlers, LOG, GNUNET_ARM_Handle::mq, and mq_error_handler().

Referenced by GNUNET_DHT_connect(), and try_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

send_get()

static void send_get ( struct GNUNET_DHT_GetHandle *  gh )

static

Send GET message for a get_handle to DHT.

Parameters

gh	GET to generate messages for.

Definition at line 316 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *h = gh->dht_handle;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_ClientGetMessage *get_msg;
 
  env = GNUNET_MQ_msg_extra (get_msg,
                             gh->xquery_size,
                             GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET);
  get_msg->options = htonl ((uint32_t) gh->options);
  get_msg->desired_replication_level = htonl (gh->desired_replication_level);
  get_msg->type = htonl (gh->type);
  get_msg->key = gh->key;
  get_msg->unique_id = gh->unique_id;
  GNUNET_memcpy (&get_msg[1],
                 &gh[1],
                 gh->xquery_size);
  GNUNET_MQ_send (h->mq,
                  env);
}

References GNUNET_DHT_ClientGetMessage::desired_replication_level, GNUNET_DHT_GetHandle::desired_replication_level, GNUNET_DHT_GetHandle::dht_handle, env, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), h, GNUNET_DHT_ClientGetMessage::key, GNUNET_DHT_GetHandle::key, GNUNET_ARM_Handle::mq, GNUNET_DHT_ClientGetMessage::options, GNUNET_DHT_GetHandle::options, GNUNET_DHT_ClientGetMessage::type, GNUNET_DHT_GetHandle::type, GNUNET_DHT_ClientGetMessage::unique_id, GNUNET_DHT_GetHandle::unique_id, and GNUNET_DHT_GetHandle::xquery_size.

Referenced by add_get_request_to_pending(), and GNUNET_DHT_get_start().

Here is the call graph for this function:

Here is the caller graph for this function:

send_get_known_results()

static void send_get_known_results ( struct GNUNET_DHT_GetHandle *  gh, unsigned int  transmission_offset_start  )

static

Send GET message(s) for indicating which results are already known for a get_handle to DHT.

Complex as we need to send the list of known results, which means we may need multiple messages to block known results from the result set.

Parameters

gh	GET to generate messages for
transmission_offset_start	at which offset should we start?

Definition at line 348 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *h = gh->dht_handle;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_ClientGetResultSeenMessage *msg;
  unsigned int delta;
  unsigned int max;
  unsigned int transmission_offset;
 
  max = (GNUNET_MAX_MESSAGE_SIZE - sizeof(*msg))
        / sizeof(struct GNUNET_HashCode);
  transmission_offset = transmission_offset_start;
  while (transmission_offset < gh->seen_results_end)
  {
    delta = gh->seen_results_end - transmission_offset;
    if (delta > max)
      delta = max;
    env = GNUNET_MQ_msg_extra (msg,
                               delta * sizeof(struct GNUNET_HashCode),
                               GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN)
    ;
    msg->key = gh->key;
    msg->unique_id = gh->unique_id;
    GNUNET_memcpy (&msg[1],
                   &gh->seen_results[transmission_offset],
                   sizeof(struct GNUNET_HashCode) * delta);
    GNUNET_MQ_send (h->mq,
                    env);
    transmission_offset += delta;
  }
}

References delta, GNUNET_DHT_GetHandle::dht_handle, env, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), h, GNUNET_DHT_GetHandle::key, max, GNUNET_ARM_Handle::mq, msg, GNUNET_DHT_GetHandle::seen_results, GNUNET_DHT_GetHandle::seen_results_end, and GNUNET_DHT_GetHandle::unique_id.

Referenced by add_get_request_to_pending(), and GNUNET_DHT_get_filter_known_results().

Here is the call graph for this function:

Here is the caller graph for this function:

add_get_request_to_pending()

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

static

Add the GET request corresponding to the given route handle to the pending queue (if it is not already in there).

Parameters

cls	the struct GNUNET_DHT_Handle *
key	key for the request (not used)
value	the struct GNUNET_DHT_GetHandle *

Returns

GNUNET_YES (always)

Definition at line 392 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = cls;
  struct GNUNET_DHT_GetHandle *gh = value;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Retransmitting request related to %s to DHT %p\n",
       GNUNET_h2s (key),
       handle);
  send_get (gh);
  send_get_known_results (gh, 0);
  return GNUNET_YES;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_h2s(), GNUNET_YES, handle, key, LOG, send_get(), send_get_known_results(), and value.

Referenced by try_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

send_monitor_start()

static void send_monitor_start ( struct GNUNET_DHT_MonitorHandle *  mh )

static

Send GNUNET_MESSAGE_TYPE_DHT_MONITOR_START message.

Parameters

mh	monitor handle to generate start message for

Definition at line 415 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *h = mh->dht_handle;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_DHT_MonitorStartStopMessage *m;
 
  env = GNUNET_MQ_msg (m,
                       GNUNET_MESSAGE_TYPE_DHT_MONITOR_START);
  m->type = htonl (mh->type);
  m->get = htons (NULL != mh->get_cb);
  m->get_resp = htons (NULL != mh->get_resp_cb);
  m->put = htons (NULL != mh->put_cb);
  if (NULL != mh->key)
  {
    m->filter_key = htons (1);
    m->key = *mh->key;
  }
  GNUNET_MQ_send (h->mq,
                  env);
}

References env, GNUNET_MESSAGE_TYPE_DHT_MONITOR_START, GNUNET_MQ_msg, GNUNET_MQ_send(), h, m, mh, and GNUNET_ARM_Handle::mq.

Referenced by GNUNET_DHT_monitor_start(), and try_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

try_reconnect()

static void try_reconnect ( void *  cls )

static

Try reconnecting to the dht service.

Parameters

cls	a struct GNUNET_DHT_Handle

Definition at line 443 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *h = cls;
  struct GNUNET_DHT_MonitorHandle *mh;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Reconnecting with DHT %p\n",
       h);
  h->retry_time = GNUNET_TIME_STD_BACKOFF (h->retry_time);
  h->reconnect_task = NULL;
  if (GNUNET_YES != try_connect (h))
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "DHT reconnect failed!\n");
    h->reconnect_task
      = GNUNET_SCHEDULER_add_delayed (h->retry_time,
                                      &try_reconnect,
                                      h);
    return;
  }
  GNUNET_CONTAINER_multihashmap_iterate (h->active_requests,
                                         &add_get_request_to_pending,
                                         h);
  for (mh = h->monitor_head; NULL != mh; mh = mh->next)
    send_monitor_start (mh);
}

References add_get_request_to_pending(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, GNUNET_YES, h, LOG, mh, GNUNET_ARM_Handle::reconnect_task, send_monitor_start(), try_connect(), and try_reconnect().

Referenced by do_disconnect(), and try_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

do_disconnect()

static void do_disconnect ( struct GNUNET_DHT_Handle *  h )

static

Try reconnecting to the DHT service.

Parameters

h	handle to dht to (possibly) disconnect and reconnect

Definition at line 477 of file dht_api.c.

{
  struct GNUNET_DHT_PutHandle *ph;
  GNUNET_SCHEDULER_TaskCallback cont;
  void *cont_cls;
 
  if (NULL == h->mq)
    return;
  GNUNET_MQ_destroy (h->mq);
  h->mq = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Disconnecting from DHT service, will try to reconnect in %s\n",
              GNUNET_STRINGS_relative_time_to_string (h->retry_time,
                                                      GNUNET_YES));
  /* notify client about all PUTs that (may) have failed due to disconnect */
  while (NULL != (ph = h->put_head))
  {
    cont = ph->cont;
    cont_cls = ph->cont_cls;
    ph->env = NULL;
    GNUNET_DHT_put_cancel (ph);
    if (NULL != cont)
      cont (cont_cls);
  }
  GNUNET_assert (NULL == h->reconnect_task);
  h->reconnect_task
    = GNUNET_SCHEDULER_add_delayed (h->retry_time,
                                    &try_reconnect,
                                    h);
}

References GNUNET_DHT_PutHandle::cont, GNUNET_DHT_PutHandle::cont_cls, GNUNET_DHT_PutHandle::env, GNUNET_assert, GNUNET_DHT_put_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, h, GNUNET_ARM_Handle::mq, GNUNET_ARM_Handle::reconnect_task, and try_reconnect().

Here is the call graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	closure with the struct GNUNET_DHT_Handle *
error	error code

Definition at line 518 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *h = cls;
 
  do_disconnect (h);
}

References do_disconnect, and h.

Referenced by try_connect().

Here is the caller graph for this function:

handle_monitor_get()

static void handle_monitor_get ( void *  cls, const struct GNUNET_DHT_MonitorGetMessage *  msg  )

static

Process a get monitor message from the service.

Parameters

cls	The DHT handle.
msg	Monitor get message from the service.

Definition at line 534 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = cls;
  enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
 
  for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
       NULL != mh;
       mh = mh->next)
  {
    if (NULL == mh->get_cb)
      continue;
    if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
         (mh->type != ntohl (msg->type)))
      continue;
    if ( (NULL != mh->key) &&
         (0 != GNUNET_memcmp (mh->key,
                              &msg->key)) )
      continue;
    mh->get_cb (mh->cb_cls,
                ro,
                ntohl (msg->type),
                ntohl (msg->hop_count),
                ntohl (msg->desired_replication_level),
                &msg->key);
  }
}

References GNUNET_BLOCK_TYPE_ANY, GNUNET_memcmp, handle, mh, msg, and GNUNET_MessageHeader::type.

check_monitor_get_resp()

static enum GNUNET_GenericReturnValue check_monitor_get_resp ( void *  cls, const struct GNUNET_DHT_MonitorGetRespMessage *  msg  )

static

Validate a get response monitor message from the service.

Parameters

cls	The DHT handle.
msg	monitor get response message from the service

Returns

GNUNET_OK if everything went fine, GNUNET_SYSERR if the message is malformed.

Definition at line 572 of file dht_api.c.

{
  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
  uint32_t getl = ntohl (msg->get_path_length);
  uint32_t putl = ntohl (msg->put_path_length);
  enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
 
  if (truncated)
  {
    if (msize < sizeof (struct GNUNET_PeerIdentity))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    msize -= sizeof (struct GNUNET_PeerIdentity);
  }
  if ((getl + putl < getl) ||
      ((msize / sizeof(struct GNUNET_DHT_PathElement)) < getl + putl))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

handle_monitor_get_resp()

static void handle_monitor_get_resp ( void *  cls, const struct GNUNET_DHT_MonitorGetRespMessage *  msg  )

static

Process a get response monitor message from the service.

Parameters

cls	The DHT handle.
msg	monitor get response message from the service

Definition at line 607 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = cls;
  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
  enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
  uint32_t getl = ntohl (msg->get_path_length);
  uint32_t putl = ntohl (msg->put_path_length);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? (const struct GNUNET_PeerIdentity *) &msg[1]
    : NULL;
  const struct GNUNET_DHT_PathElement *path
    = truncated
    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
    : (const struct GNUNET_DHT_PathElement *) &msg[1];
 
  if (truncated)
    msize -= sizeof (struct GNUNET_PeerIdentity);
  msize -= sizeof(struct GNUNET_DHT_PathElement) * (putl + getl);
  for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
       NULL != mh;
       mh = mh->next)
  {
    if (NULL == mh->get_resp_cb)
      continue;
    if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
         (mh->type != ntohl (msg->type)) )
      continue;
    if ( (NULL != mh->key) &&
         (0 != GNUNET_memcmp (mh->key,
                              &msg->key)) )
      continue;
    mh->get_resp_cb (mh->cb_cls,
                     ntohl (msg->type),
                     trunc_peer,
                     &path[putl],
                     getl,
                     path,
                     putl,
                     GNUNET_TIME_absolute_ntoh (msg->expiration_time),
                     &msg->key,
                     (const void *) &path[getl + putl],
                     msize);
  }
}

References GNUNET_BLOCK_TYPE_ANY, GNUNET_DHT_RO_TRUNCATED, GNUNET_memcmp, GNUNET_TIME_absolute_ntoh(), handle, mh, msg, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

check_monitor_put()

static enum GNUNET_GenericReturnValue check_monitor_put ( void *  cls, const struct GNUNET_DHT_MonitorPutMessage *  msg  )

static

Check validity of a put monitor message from the service.

Parameters

cls	The DHT handle.
msg	Monitor put message from the service.

Returns

GNUNET_OK if everything went fine, GNUNET_SYSERR if the message is malformed.

Definition at line 665 of file dht_api.c.

{
  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
  uint32_t putl = ntohl (msg->put_path_length);
  enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
 
  if (truncated)
  {
    if (msize < sizeof (struct GNUNET_PeerIdentity))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    msize -= sizeof (struct GNUNET_PeerIdentity);
  }
  if ((msize / sizeof(struct GNUNET_DHT_PathElement)) < putl)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

handle_monitor_put()

static void handle_monitor_put ( void *  cls, const struct GNUNET_DHT_MonitorPutMessage *  msg  )

static

Process a put monitor message from the service.

Parameters

cls	The DHT handle.
msg	Monitor put message from the service.

Definition at line 698 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = cls;
  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
  uint32_t putl = ntohl (msg->put_path_length);
  enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? (const struct GNUNET_PeerIdentity *) &msg[1]
    : NULL;
  const struct GNUNET_DHT_PathElement *path
    = truncated
    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
    : (const struct GNUNET_DHT_PathElement *) &msg[1];
 
  if (truncated)
    msize -= sizeof (struct GNUNET_PeerIdentity);
  msize -= sizeof(struct GNUNET_DHT_PathElement) * putl;
  for (struct GNUNET_DHT_MonitorHandle *mh = handle->monitor_head;
       NULL != mh;
       mh = mh->next)
  {
    if (NULL == mh->put_cb)
      continue;
    if ( (GNUNET_BLOCK_TYPE_ANY != mh->type) &&
         (mh->type != ntohl (msg->type)) )
      continue;
    if ( (NULL != mh->key) &&
         (0 != GNUNET_memcmp (mh->key,
                              &msg->key)) )
      continue;
    mh->put_cb (mh->cb_cls,
                ro,
                ntohl (msg->type),
                ntohl (msg->hop_count),
                ntohl (msg->desired_replication_level),
                trunc_peer,
                putl,
                path,
                GNUNET_TIME_absolute_ntoh (msg->expiration_time),
                &msg->key,
                (const void *) &path[putl],
                msize);
  }
}

References GNUNET_BLOCK_TYPE_ANY, GNUNET_DHT_RO_TRUNCATED, GNUNET_memcmp, GNUNET_TIME_absolute_ntoh(), handle, mh, msg, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Here is the call graph for this function:

check_client_result()

static enum GNUNET_GenericReturnValue check_client_result ( void *  cls, const struct GNUNET_DHT_ClientResultMessage *  msg  )

static

Verify that client result message received from the service is well-formed.

Parameters

cls	The DHT handle.
msg	Monitor put message from the service.

Returns

GNUNET_OK if everything went fine, GNUNET_SYSERR if the message is malformed.

Definition at line 756 of file dht_api.c.

{
  size_t msize = ntohs (msg->header.size) - sizeof(*msg);
  uint32_t put_path_length = ntohl (msg->put_path_length);
  uint32_t get_path_length = ntohl (msg->get_path_length);
  enum GNUNET_DHT_RouteOption ro = ntohl (msg->options);
  bool truncated = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  size_t meta_length;
 
  if (truncated)
  {
    if (msize < sizeof (struct GNUNET_PeerIdentity))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    msize -= sizeof (struct GNUNET_PeerIdentity);
  }
  meta_length = msize / sizeof(struct GNUNET_DHT_PathElement);
  if ( (get_path_length + put_path_length >
        meta_length) ||
       (get_path_length + put_path_length <
        get_path_length) )
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

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

process_client_result()

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

static

Process a given reply that might match the given request.

Parameters

cls	the struct GNUNET_DHT_ClientResultMessage
key	query of the request
value	the struct GNUNET_DHT_GetHandle of a request matching the same key

Returns

GNUNET_YES to continue to iterate over all results

Definition at line 797 of file dht_api.c.

{
  const struct GNUNET_DHT_ClientResultMessage *crm = cls;
  struct GNUNET_DHT_GetHandle *get_handle = value;
  size_t msize = ntohs (crm->header.size) - sizeof(*crm);
  uint16_t type = ntohl (crm->type);
  enum GNUNET_DHT_RouteOption ro = ntohl (crm->options);
  bool truncated
    = (0 != (ro & GNUNET_DHT_RO_TRUNCATED));
  uint32_t put_path_length
    = ntohl (crm->put_path_length);
  uint32_t get_path_length
    = ntohl (crm->get_path_length);
  const struct GNUNET_PeerIdentity *trunc_peer
    = truncated
    ? (const struct GNUNET_PeerIdentity *) &crm[1]
    : NULL;
  const struct GNUNET_DHT_PathElement *put_path
    = truncated
    ? (const struct GNUNET_DHT_PathElement *) &trunc_peer[1]
    : (const struct GNUNET_DHT_PathElement *) &crm[1];
  const struct GNUNET_DHT_PathElement *get_path
    = &put_path[put_path_length];
  const void *data
    = &get_path[get_path_length];
  size_t meta_length
    = sizeof(struct GNUNET_DHT_PathElement)
      * (get_path_length + put_path_length);
  size_t data_length
    = msize - meta_length;
  struct GNUNET_HashCode hc;
 
  if (truncated)
    data_length -= sizeof (struct GNUNET_PeerIdentity);
  if (crm->unique_id != get_handle->unique_id)
  {
    /* UID mismatch */
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Ignoring reply for %s: UID mismatch: %llu/%llu\n",
         GNUNET_h2s (key),
         (unsigned long long) crm->unique_id,
         (unsigned long long) get_handle->unique_id);
    return GNUNET_YES;
  }
  if ( (get_handle->type != GNUNET_BLOCK_TYPE_ANY) &&
       (get_handle->type != type) )
  {
    /* type mismatch */
    GNUNET_break (0);
    return GNUNET_YES;
  }
 
  {
    char *pp;
    char *gp;
 
    gp = GNUNET_DHT_pp2s (get_path,
                          get_path_length);
    pp = GNUNET_DHT_pp2s (put_path,
                          put_path_length);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Giving %u byte reply for %s to application (GP: %s, PP: %s)\n",
         (unsigned int) data_length,
         GNUNET_h2s (key),
         gp,
         pp);
    GNUNET_free (gp);
    GNUNET_free (pp);
  }
  /* remember that we've seen this result */
  GNUNET_CRYPTO_hash (data,
                      data_length,
                      &hc);
  if (get_handle->seen_results_size == get_handle->seen_results_end)
    GNUNET_array_grow (get_handle->seen_results,
                       get_handle->seen_results_size,
                       get_handle->seen_results_size * 2 + 1);
  get_handle->seen_results[get_handle->seen_results_end++] = hc;
  /* no need to block it explicitly, service already knows about it! */
  get_handle->iter (get_handle->iter_cls,
                    GNUNET_TIME_absolute_ntoh (crm->expiration),
                    key,
                    trunc_peer,
                    get_path,
                    get_path_length,
                    put_path,
                    put_path_length,
                    type,
                    data_length,
                    data);
  return GNUNET_YES;
}

References data, GNUNET_DHT_ClientResultMessage::expiration, get_handle, GNUNET_DHT_ClientResultMessage::get_path_length, GNUNET_array_grow, GNUNET_BLOCK_TYPE_ANY, GNUNET_break, GNUNET_CRYPTO_hash(), GNUNET_DHT_pp2s(), GNUNET_DHT_RO_TRUNCATED, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_h2s(), GNUNET_TIME_absolute_ntoh(), GNUNET_YES, GNUNET_DHT_ClientResultMessage::header, GNUNET_DHT_GetHandle::iter, GNUNET_DHT_GetHandle::iter_cls, key, LOG, GNUNET_DHT_ClientResultMessage::options, GNUNET_DHT_ClientResultMessage::put_path_length, GNUNET_DHT_GetHandle::seen_results, GNUNET_DHT_GetHandle::seen_results_end, GNUNET_DHT_GetHandle::seen_results_size, GNUNET_MessageHeader::size, type, GNUNET_DHT_ClientResultMessage::type, GNUNET_DHT_GetHandle::type, GNUNET_DHT_ClientResultMessage::unique_id, GNUNET_DHT_GetHandle::unique_id, and value.

Referenced by handle_client_result().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_client_result()

static void handle_client_result ( void *  cls, const struct GNUNET_DHT_ClientResultMessage *  msg  )

static

Process a client result message received from the service.

Parameters

cls	The DHT handle.
msg	Monitor put message from the service.

Definition at line 900 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = cls;
 
  GNUNET_CONTAINER_multihashmap_get_multiple (handle->active_requests,
                                              &msg->key,
                                              &process_client_result,
                                              (void *) msg);
}

References GNUNET_CONTAINER_multihashmap_get_multiple(), handle, msg, and process_client_result().

Here is the call graph for this function:

check_client_hello()

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

static

Process a client HELLO message received from the service.

Parameters

cls	The DHT handle.
hdr	HELLO URL message from the service.

Returns

GNUNET_OK if hdr is well-formed

Definition at line 920 of file dht_api.c.

{
  uint16_t len = ntohs (hdr->size);
  const char *buf = (const char *) &hdr[1];
 
  (void) cls;
  if (len == sizeof (*hdr))
    return GNUNET_OK;
 
  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_client_hello()

static void handle_client_hello ( void *  cls, const struct GNUNET_MessageHeader *  hdr  )

static

Process a client HELLO message received from the service.

Parameters

cls	The DHT handle.
hdr	HELLO URL message from the service.

Definition at line 946 of file dht_api.c.

{
  struct GNUNET_DHT_Handle *handle = cls;
  uint16_t len = ntohs (hdr->size);
  const char *url = len == sizeof (*hdr)?
                    NULL : (const char *) &hdr[1];
  struct GNUNET_DHT_HelloGetHandle *hgh;
 
  while (NULL != (hgh = handle->hgh_head))
  {
    hgh->cb (hgh->cb_cls,
             url);
    GNUNET_DHT_hello_get_cancel (hgh);
  }
}

References GNUNET_DHT_HelloGetHandle::cb, GNUNET_DHT_HelloGetHandle::cb_cls, GNUNET_DHT_hello_get_cancel(), handle, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

handle_put_cont()

static void handle_put_cont ( void *  cls )

static

Process a MQ PUT transmission notification.

Parameters

cls	The DHT handle.

Definition at line 970 of file dht_api.c.

{
  struct GNUNET_DHT_PutHandle *ph = cls;
  GNUNET_SCHEDULER_TaskCallback cont;
  void *cont_cls;
 
  cont = ph->cont;
  cont_cls = ph->cont_cls;
  ph->env = NULL;
  GNUNET_DHT_put_cancel (ph);
  if (NULL != cont)
    cont (cont_cls);
}

References GNUNET_DHT_PutHandle::cont, GNUNET_DHT_PutHandle::cont_cls, GNUNET_DHT_PutHandle::env, and GNUNET_DHT_put_cancel().

Referenced by GNUNET_DHT_put().

Here is the call graph for this function:

Here is the caller graph for this function: