namecache_api.c File Reference

API to access the NAMECACHE service. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_constants.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_signatures.h"
#include "gnunet_namecache_service.h"
#include "namecache.h"

Include dependency graph for namecache_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_NAMECACHE_QueueEntry
	An QueueEntry used to store information for a pending NAMECACHE record operation. More...
struct	GNUNET_NAMECACHE_Handle
	Connection to the NAMECACHE service. More...

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

Functions
static void	force_reconnect (struct GNUNET_NAMECACHE_Handle *h)
	Disconnect from service and then reconnect.
static struct GNUNET_NAMECACHE_QueueEntry *	find_qe (struct GNUNET_NAMECACHE_Handle *h, uint32_t rid)
	Find queue entry for the given rid.
static int	check_lookup_block_response (void *cls, const struct LookupBlockResponseMessage *msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE.
static void	handle_lookup_block_response (void *cls, const struct LookupBlockResponseMessage *msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE.
static void	handle_block_cache_response (void *cls, const struct BlockCacheResponseMessage *msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE.
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	reconnect (struct GNUNET_NAMECACHE_Handle *h)
	Reconnect to namecache service.
static void	reconnect_task (void *cls)
	Re-establish the connection to the service.
static uint32_t	get_op_id (struct GNUNET_NAMECACHE_Handle *h)
	Get a fresh operation id to distinguish between namecache requests.
struct GNUNET_NAMECACHE_Handle *	GNUNET_NAMECACHE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize the connection with the NAMECACHE service.
void	GNUNET_NAMECACHE_disconnect (struct GNUNET_NAMECACHE_Handle *h)
	Disconnect from the namecache service (and free associated resources).
struct GNUNET_NAMECACHE_QueueEntry *	GNUNET_NAMECACHE_block_cache (struct GNUNET_NAMECACHE_Handle *h, const struct GNUNET_GNSRECORD_Block *block, GNUNET_NAMECACHE_ContinuationWithStatus cont, void *cont_cls)
	Store an item in the namecache.
struct GNUNET_NAMECACHE_QueueEntry *	GNUNET_NAMECACHE_lookup_block (struct GNUNET_NAMECACHE_Handle *h, const struct GNUNET_HashCode *derived_hash, GNUNET_NAMECACHE_BlockProcessor proc, void *proc_cls)
	Get a result for a particular key from the namecache.
void	GNUNET_NAMECACHE_cancel (struct GNUNET_NAMECACHE_QueueEntry *qe)
	Cancel a namecache operation.

Detailed Description

API to access the NAMECACHE service.

Author

Martin Schanzenbach

Matthias Wachs

Christian Grothoff

Definition in file namecache_api.c.

Macro Definition Documentation

LOG

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

Definition at line 38 of file namecache_api.c.

Function Documentation

force_reconnect()

static void force_reconnect ( struct GNUNET_NAMECACHE_Handle *  h )

static

Disconnect from service and then reconnect.

Parameters

h	our handle

Definition at line 356 of file namecache_api.c.

{
  struct GNUNET_NAMECACHE_QueueEntry *qe;
 
  h->reconnect = GNUNET_NO;
  GNUNET_MQ_destroy (h->mq);
  h->mq = NULL;
  while (NULL != (qe = h->op_head))
  {
    GNUNET_CONTAINER_DLL_remove (h->op_head,
                                 h->op_tail,
                                 qe);
    if (NULL != qe->cont)
      qe->cont (qe->cont_cls,
                GNUNET_SYSERR,
                _ ("Error communicating with namecache service"));
    GNUNET_free (qe);
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Reconnecting to namecache\n");
  h->reconnect_delay = GNUNET_TIME_STD_BACKOFF (h->reconnect_delay);
  h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->reconnect_delay,
                                                    &reconnect_task,
                                                    h);
}

References _, GNUNET_DATASTORE_QueueEntry::cont, GNUNET_DATASTORE_QueueEntry::cont_cls, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, GNUNET_TIME_STD_BACKOFF, h, GNUNET_ARM_Handle::mq, qe, GNUNET_ARM_Handle::reconnect_task, and reconnect_task().

Referenced by handle_lookup_block_response(), and mq_error_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

find_qe()

static struct GNUNET_NAMECACHE_QueueEntry * find_qe ( struct GNUNET_NAMECACHE_Handle *  h, uint32_t  rid  )

static

Find queue entry for the given rid.

Parameters

h	handle to search
rid	request ID to look for

Returns

NULL if not found, otherwise the queue entry (removed from the queue)

Definition at line 158 of file namecache_api.c.

{
  struct GNUNET_NAMECACHE_QueueEntry *qe;
 
  for (qe = h->op_head; qe != NULL; qe = qe->next)
  {
    if (qe->op_id == rid)
    {
      GNUNET_CONTAINER_DLL_remove (h->op_head,
                                   h->op_tail,
                                   qe);
      return qe;
    }
  }
  return NULL;
}

References GNUNET_CONTAINER_DLL_remove, h, GNUNET_DATASTORE_QueueEntry::next, and qe.

Referenced by handle_block_cache_response(), and handle_lookup_block_response().

Here is the caller graph for this function:

check_lookup_block_response()

static int check_lookup_block_response ( void *  cls, const struct LookupBlockResponseMessage *  msg  )

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE.

Parameters

cls	the struct GNUNET_NAMECACHE_Handle
msg	the message we received

Definition at line 185 of file namecache_api.c.

{
  /* any length will do, format validation is in handler */
  return GNUNET_OK;
}

References GNUNET_OK.

handle_lookup_block_response()

static void handle_lookup_block_response ( void *  cls, const struct LookupBlockResponseMessage *  msg  )

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE.

Parameters

cls	the struct GNUNET_NAMECACHE_Handle
msg	the message we received

Definition at line 201 of file namecache_api.c.

{
  struct GNUNET_NAMECACHE_Handle *h = cls;
  size_t size;
  struct GNUNET_NAMECACHE_QueueEntry *qe;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received LOOKUP_BLOCK_RESPONSE\n");
  qe = find_qe (h,
                ntohl (msg->gns_header.r_id));
  if (NULL == qe)
    return;
  if (0 == GNUNET_TIME_absolute_ntoh (msg->expire).abs_value_us)
  {
    /* no match found */
    if (NULL != qe->block_proc)
      qe->block_proc (qe->block_proc_cls,
                      NULL);
    GNUNET_free (qe);
    return;
  }
  size = ntohs (msg->gns_header.header.size)
         - sizeof(struct LookupBlockResponseMessage);
  {
    char buf[size] GNUNET_ALIGN;
    struct GNUNET_GNSRECORD_Block *block;
 
    memset (buf, 0, size);
    block = (struct GNUNET_GNSRECORD_Block *) buf;
    GNUNET_memcpy (block,
                   &msg[1],
                   size);
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_block_verify (block))
    {
      GNUNET_break (0);
      if (NULL != qe->block_proc)
        qe->block_proc (qe->block_proc_cls,
                        NULL);
      force_reconnect (h);
    }
    else
    {
      if (NULL != qe->block_proc)
        qe->block_proc (qe->block_proc_cls,
                        block);
    }
  }
  GNUNET_free (qe);
}

References GNUNET_TIME_Absolute::abs_value_us, find_qe(), force_reconnect(), GNUNET_ALIGN, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_block_verify(), GNUNET_memcpy, GNUNET_OK, GNUNET_TIME_absolute_ntoh(), h, LOG, msg, qe, GNUNET_MessageHeader::size, and size.

Here is the call graph for this function:

handle_block_cache_response()

static void handle_block_cache_response ( void *  cls, const struct BlockCacheResponseMessage *  msg  )

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE.

Parameters

cls	the struct GNUNET_NAMECACHE_Handle
msg	the message we received

Returns

GNUNET_OK on success, GNUNET_SYSERR on error and we did NOT notify the client

Definition at line 263 of file namecache_api.c.

{
  struct GNUNET_NAMECACHE_Handle *h = cls;
  struct GNUNET_NAMECACHE_QueueEntry *qe;
  int res;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received BLOCK_CACHE_RESPONSE\n");
  qe = find_qe (h,
                ntohl (msg->gns_header.r_id));
  if (NULL == qe)
    return;
  res = ntohl (msg->op_result);
  /* TODO: add actual error message from namecache to response... */
  if (NULL != qe->cont)
    qe->cont (qe->cont_cls,
              res,
              (GNUNET_OK == res)
              ? NULL
              : _ ("Namecache failed to cache block"));
  GNUNET_free (qe);
}

References _, GNUNET_DATASTORE_QueueEntry::cont, GNUNET_DATASTORE_QueueEntry::cont_cls, find_qe(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_OK, h, LOG, msg, qe, and res.

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_NAMECACHE_Handle *
error	error code

Definition at line 297 of file namecache_api.c.

{
  struct GNUNET_NAMECACHE_Handle *h = cls;
 
  force_reconnect (h);
}

References force_reconnect(), and h.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

reconnect()

static void reconnect ( struct GNUNET_NAMECACHE_Handle *  h )

static

Reconnect to namecache service.

Parameters

h	the handle to the NAMECACHE service

Definition at line 312 of file namecache_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (lookup_block_response,
                           GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE,
                           struct LookupBlockResponseMessage,
                           h),
    GNUNET_MQ_hd_fixed_size (block_cache_response,
                             GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE,
                             struct BlockCacheResponseMessage,
                             h),
    GNUNET_MQ_handler_end ()
  };
 
  GNUNET_assert (NULL == h->mq);
  h->mq = GNUNET_CLIENT_connect (h->cfg,
                                 "namecache",
                                 handlers,
                                 &mq_error_handler,
                                 h);
}

References GNUNET_ARM_Handle::cfg, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_NAMECACHE_BLOCK_CACHE_RESPONSE, GNUNET_MESSAGE_TYPE_NAMECACHE_LOOKUP_BLOCK_RESPONSE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, h, handlers, GNUNET_ARM_Handle::mq, and mq_error_handler().

Here is the call graph for this function:

reconnect_task()

static void reconnect_task ( void *  cls )

static

Re-establish the connection to the service.

Parameters

cls	handle to use to re-connect.

Definition at line 341 of file namecache_api.c.

{
  struct GNUNET_NAMECACHE_Handle *h = cls;
 
  h->reconnect_task = NULL;
  reconnect (h);
}

References h, reconnect(), and GNUNET_ARM_Handle::reconnect_task.

Referenced by force_reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

get_op_id()

static uint32_t get_op_id ( struct GNUNET_NAMECACHE_Handle *  h )

static

Get a fresh operation id to distinguish between namecache requests.

Parameters

h	the namecache handle

Returns

next operation id to use

Definition at line 390 of file namecache_api.c.

{
  return h->last_op_id_used++;
}

References h.

Referenced by GNUNET_NAMECACHE_block_cache(), and GNUNET_NAMECACHE_lookup_block().

Here is the caller graph for this function: