API to access the NAMESTORE service. More...

#include "gnunet_protocols.h"
#include "gnunet_error_codes.h"
#include "gnunet_util_lib.h"
#include "gnunet_namestore_service.h"
#include "namestore.h"

Include dependency graph for namestore_api.c:

Data Structures
struct	GNUNET_NAMESTORE_QueueEntry
	An QueueEntry used to store information for a pending NAMESTORE record operation. More...

struct	GNUNET_NAMESTORE_ZoneIterator
	Handle for a zone iterator operation. More...

struct	GNUNET_NAMESTORE_Handle
	Connection to the NAMESTORE service. More...

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

#define	NAMESTORE_DELAY_TOLERANCE GNUNET_TIME_UNIT_MINUTES
	We grant the namestore up to 1 minute of latency, if it is slower than that, store queries will fail.

Functions
static void	force_reconnect (struct GNUNET_NAMESTORE_Handle *h)
	Disconnect from service and then reconnect.

static struct GNUNET_NAMESTORE_QueueEntry *	find_qe (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
	Find the queue entry that matches the rid.

static struct GNUNET_NAMESTORE_ZoneIterator *	find_zi (struct GNUNET_NAMESTORE_Handle *h, uint32_t rid)
	Find the zone iteration entry that matches the rid.

static void	free_qe (struct GNUNET_NAMESTORE_QueueEntry *qe)
	Free qe.

static void	free_ze (struct GNUNET_NAMESTORE_ZoneIterator *ze)
	Free ze.

static int	check_rd (size_t rd_len, const void *rd_buf, unsigned int rd_count)
	Check that rd_buf of length rd_len contains rd_count records.

static void	handle_generic_response (void cls, const struct NamestoreResponseMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_GENERIC_RESPONSE.

static int	check_lookup_result (void cls, const struct LabelLookupResponseMessage msg)
	Check validity of an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.

static void	handle_lookup_result (void cls, const struct LabelLookupResponseMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.

static int	check_edit_record_set_response (void cls, const struct EditRecordSetResponseMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_RESPONSE.

static void	handle_edit_record_set_response (void cls, const struct EditRecordSetResponseMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_RESPONSE.

static int	check_record_result (void cls, const struct RecordResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.

static void	handle_record_result (void cls, const struct RecordResultMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.

static void	handle_record_result_end (void cls, const struct GNUNET_NAMESTORE_Header msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END.

static int	check_zone_to_name_response (void cls, const struct ZoneToNameResponseMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.

static void	handle_zone_to_name_response (void cls, const struct ZoneToNameResponseMessage msg)
	Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_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_NAMESTORE_Handle *h)
	Reconnect to namestore service.

static void	reconnect_task (void *cls)
	Re-establish the connection to the service.

static uint32_t	get_op_id (struct GNUNET_NAMESTORE_Handle *h)
	Get a fresh operation id to distinguish between namestore requests.

struct GNUNET_NAMESTORE_Handle *	GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize the connection with the NAMESTORE service.

void	GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
	Disconnect from the namestore service (and free associated resources).

static void	warn_delay (void *cls)
	Task launched to warn the user that the namestore is excessively slow and that a query was thus dropped.

struct GNUNET_NAMESTORE_QueueEntry *	GNUNET_NAMESTORE_record_set_store (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, const char label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data rd, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
	Store an item in the namestore.

struct GNUNET_NAMESTORE_QueueEntry *	GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, unsigned int rd_set_count, const struct GNUNET_NAMESTORE_RecordInfo record_info, unsigned int rds_sent, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
	Store one or more record sets in the namestore.

static struct GNUNET_NAMESTORE_QueueEntry *	records_lookup (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, const char label, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls, enum GNUNET_GNSRECORD_Filter filter)

struct GNUNET_NAMESTORE_QueueEntry *	GNUNET_NAMESTORE_records_lookup (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, const char label, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls)
	Lookup an item in the namestore.

struct GNUNET_NAMESTORE_QueueEntry *	GNUNET_NAMESTORE_records_lookup2 (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, const char label, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_NAMESTORE_RecordMonitor rm, void *rm_cls, enum GNUNET_GNSRECORD_Filter filter)
	Lookup an item in the namestore with GNSRECORD filter.

struct GNUNET_NAMESTORE_QueueEntry *	GNUNET_NAMESTORE_zone_to_name (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey zone, const struct GNUNET_CRYPTO_BlindablePublicKey value_zone, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void *proc_cls)
	Look for an existing PKEY delegation record for a given public key.

struct GNUNET_NAMESTORE_ZoneIterator *	GNUNET_NAMESTORE_zone_iteration_start (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey zone, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_NAMESTORE_RecordMonitor proc, void proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls)

struct GNUNET_NAMESTORE_ZoneIterator *	GNUNET_NAMESTORE_zone_iteration_start2 (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey zone, GNUNET_SCHEDULER_TaskCallback error_cb, void error_cb_cls, GNUNET_NAMESTORE_RecordSetMonitor proc, void proc_cls, GNUNET_SCHEDULER_TaskCallback finish_cb, void *finish_cb_cls, enum GNUNET_GNSRECORD_Filter filter)
	Starts a new zone iteration (used to periodically PUT all of our records into our DHT).

void	GNUNET_NAMESTORE_zone_iterator_next (struct GNUNET_NAMESTORE_ZoneIterator *it, uint64_t limit)
	Calls the record processor specified in GNUNET_NAMESTORE_zone_iteration_start for the next record.

void	GNUNET_NAMESTORE_zone_iteration_stop (struct GNUNET_NAMESTORE_ZoneIterator *it)
	Stops iteration and releases the namestore handle for further calls.

void	GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe)
	Cancel a namestore operation.

struct GNUNET_NAMESTORE_QueueEntry *	GNUNET_NAMESTORE_record_set_edit_begin (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, const char label, const char editor_hint, GNUNET_NAMESTORE_EditRecordSetBeginCallback edit_cb, void *edit_cb_cls)
	New API draft.

struct GNUNET_NAMESTORE_QueueEntry *	GNUNET_NAMESTORE_record_set_edit_cancel (struct GNUNET_NAMESTORE_Handle h, const struct GNUNET_CRYPTO_BlindablePrivateKey pkey, const char label, const char editor_hint, const char editor_hint_replacement, GNUNET_NAMESTORE_ContinuationWithStatus finished_cb, void finished_cls)
	If the current advisory lock is set to the provided editor hint, this API cancels the editing of a record set and unsets the advisory lock in database.

Detailed Description

API to access the NAMESTORE service.

Author: Martin Schanzenbach; Matthias Wachs; Christian Grothoff

Definition in file namestore_api.c.

Macro Definition Documentation

◆ LOG

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

Definition at line 36 of file namestore_api.c.

◆ NAMESTORE_DELAY_TOLERANCE

#define NAMESTORE_DELAY_TOLERANCE GNUNET_TIME_UNIT_MINUTES

We grant the namestore up to 1 minute of latency, if it is slower than that, store queries will fail.

Definition at line 42 of file namestore_api.c.

Function Documentation

◆ force_reconnect()

static void force_reconnect ( struct GNUNET_NAMESTORE_Handle * h )

static

Disconnect from service and then reconnect.

Parameters

h	our handle

Definition at line 990 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_ZoneIterator *ze;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
 
  GNUNET_MQ_destroy (h->mq);
  h->mq = NULL;
  while (NULL != (ze = h->z_head))
  {
    if (NULL != ze->error_cb)
      ze->error_cb (ze->error_cb_cls);
    free_ze (ze);
  }
  while (NULL != (qe = h->op_head))
  {
    if (NULL != qe->error_cb)
      qe->error_cb (qe->error_cb_cls);
    if (NULL != qe->cont)
      qe->cont (qe->cont_cls,
                GNUNET_EC_NAMESTORE_UNKNOWN);
    free_qe (qe);
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting to namestore\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_NAMESTORE_ZoneIterator::error_cb, GNUNET_NAMESTORE_ZoneIterator::error_cb_cls, free_qe(), free_ze(), GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_STD_BACKOFF, h, GNUNET_ARM_Handle::mq, qe, GNUNET_ARM_Handle::reconnect_task, and reconnect_task().

Referenced by handle_record_result(), handle_record_result_end(), 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_NAMESTORE_QueueEntry * find_qe	(	struct GNUNET_NAMESTORE_Handle *	h,
		uint32_t	rid
	)

static

Find the queue entry that matches the rid.

Parameters

h	namestore handle
rid	id to look up

Returns: NULL if rid was not found

Definition at line 270 of file namestore_api.c.

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

References h, GNUNET_DATASTORE_QueueEntry::next, and qe.

Referenced by handle_edit_record_set_response(), handle_generic_response(), handle_lookup_result(), handle_record_result(), handle_record_result_end(), and handle_zone_to_name_response().

Here is the caller graph for this function:

◆ find_zi()

static struct GNUNET_NAMESTORE_ZoneIterator * find_zi	(	struct GNUNET_NAMESTORE_Handle *	h,
		uint32_t	rid
	)

static

Find the zone iteration entry that matches the rid.

Parameters

h	namestore handle
rid	id to look up

Returns: NULL if rid was not found

Definition at line 289 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_ZoneIterator *ze;
 
  for (ze = h->z_head; ze != NULL; ze = ze->next)
    if (ze->op_id == rid)
      return ze;
  return NULL;
}

References h, GNUNET_NAMESTORE_ZoneIterator::next, and GNUNET_NAMESTORE_ZoneIterator::op_id.

Referenced by handle_record_result(), and handle_record_result_end().

Here is the caller graph for this function:

◆ free_qe()

static void free_qe ( struct GNUNET_NAMESTORE_QueueEntry * qe )

static

Free qe.

Parameters

qe	entry to free

Definition at line 306 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = qe->h;
 
  GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, qe);
  if (NULL != qe->env)
    GNUNET_MQ_discard (qe->env);
  if (NULL != qe->timeout_task)
    GNUNET_SCHEDULER_cancel (qe->timeout_task);
  GNUNET_free (qe);
}

References GNUNET_DATASTORE_QueueEntry::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_discard(), GNUNET_SCHEDULER_cancel(), h, GNUNET_DATASTORE_QueueEntry::h, and qe.

Referenced by force_reconnect(), GNUNET_NAMESTORE_cancel(), handle_edit_record_set_response(), handle_generic_response(), handle_lookup_result(), handle_record_result(), and handle_zone_to_name_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ free_ze()

static void free_ze ( struct GNUNET_NAMESTORE_ZoneIterator * ze )

static

Free ze.

Parameters

ze	entry to free

Definition at line 325 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = ze->h;
 
  GNUNET_CONTAINER_DLL_remove (h->z_head, h->z_tail, ze);
  if (NULL != ze->env)
    GNUNET_MQ_discard (ze->env);
  GNUNET_free (ze);
}

References GNUNET_NAMESTORE_ZoneIterator::env, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_discard(), h, and GNUNET_NAMESTORE_ZoneIterator::h.

Referenced by force_reconnect(), GNUNET_NAMESTORE_zone_iteration_stop(), and handle_record_result_end().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ check_rd()

static int check_rd	(	size_t	rd_len,
		const void *	rd_buf,
		unsigned int	rd_count
	)

static

Check that rd_buf of length rd_len contains rd_count records.

Parameters

rd_len	length of rd_buf
rd_buf	buffer with serialized records
rd_count	number of records expected

Returns: GNUNET_OK if rd_buf is well-formed

Definition at line 346 of file namestore_api.c.

{
  struct GNUNET_GNSRECORD_Data rd[rd_count];
 
  if (GNUNET_OK !=
      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_buf, rd_count, rd))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_GNSRECORD_records_deserialize(), GNUNET_OK, GNUNET_SYSERR, rd, and rd_count.

Referenced by check_edit_record_set_response(), check_lookup_result(), check_record_result(), and check_zone_to_name_response().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_generic_response()

static void handle_generic_response	(	void *	cls,
		const struct NamestoreResponseMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_GENERIC_RESPONSE.

Parameters

cls
msg	the message we received

Definition at line 368 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = cls;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  enum GNUNET_ErrorCode res;
 
  qe = find_qe (h, ntohl (msg->gns_header.r_id));
  res = ntohl (msg->ec);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Received GENERIC_RESPONSE with result %s\n",
       GNUNET_ErrorCode_get_hint (res));
  if (NULL == qe)
    return;
  if (NULL != qe->cont)
    qe->cont (qe->cont_cls, res);
  free_qe (qe);
}

References GNUNET_DATASTORE_QueueEntry::cont, GNUNET_DATASTORE_QueueEntry::cont_cls, find_qe(), free_qe(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ErrorCode_get_hint(), h, LOG, msg, qe, and res.

Here is the call graph for this function:

◆ check_lookup_result()

static int check_lookup_result	(	void *	cls,
		const struct LabelLookupResponseMessage *	msg
	)

static

Check validity of an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.

Parameters

cls
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 397 of file namestore_api.c.

{
  const char *name;
  size_t exp_msg_len;
  size_t msg_len;
  size_t name_len;
  size_t rd_len;
  size_t key_len;
 
  (void) cls;
  rd_len = ntohs (msg->rd_len);
  msg_len = ntohs (msg->gns_header.header.size);
  name_len = ntohs (msg->name_len);
  key_len = ntohs (msg->key_len);
  exp_msg_len = sizeof(*msg) + name_len + rd_len + key_len;
  if (0 != ntohs (msg->reserved))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (msg_len != exp_msg_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name = (const char *) &msg[1] + key_len;
  if ((name_len > 0) && ('\0' != name[name_len - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (GNUNET_NO == ntohs (msg->found))
  {
    if (0 != ntohs (msg->rd_count))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    return GNUNET_OK;
  }
  return check_rd (rd_len, &name[name_len], ntohs (msg->rd_count));
}

References check_rd(), GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, msg, name, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_lookup_result()

static void handle_lookup_result	(	void *	cls,
		const struct LabelLookupResponseMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE.

Parameters

cls
msg	the message we received

Definition at line 449 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = cls;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_CRYPTO_BlindablePrivateKey private_key;
  const char *name;
  const char *rd_tmp;
  size_t name_len;
  size_t rd_len;
  size_t key_len;
  size_t kbytes_read;
  unsigned int rd_count;
  int16_t found = (int16_t) ntohs (msg->found);
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_LOOKUP_RESULT (found=%i)\n",
       found);
  qe = find_qe (h, ntohl (msg->gns_header.r_id));
  if (NULL == qe)
    return;
  rd_len = ntohs (msg->rd_len);
  rd_count = ntohs (msg->rd_count);
  name_len = ntohs (msg->name_len);
  key_len = ntohs (msg->key_len);
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_CRYPTO_read_private_key_from_buffer (&msg[1],
                                                             key_len,
                                                             &private_key,
                                                             &kbytes_read));
  GNUNET_assert (kbytes_read == key_len);
  name = (const char *) &msg[1] + key_len;
  if (GNUNET_NO == found)
  {
    /* label was not in namestore */
    if (NULL != qe->proc)
      qe->proc (qe->proc_cls, &private_key, name, 0, NULL);
    free_qe (qe);
    return;
  }
  if (GNUNET_SYSERR == found)
  {
    if (NULL != qe->error_cb)
      qe->error_cb (qe->error_cb_cls);
    free_qe (qe);
    return;
  }
 
  rd_tmp = &name[name_len];
  {
    struct GNUNET_GNSRECORD_Data rd[rd_count];
 
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_tmp, rd_count, rd));
    if (0 == name_len)
      name = NULL;
    if (NULL != qe->proc)
      qe->proc (qe->proc_cls,
                &private_key,
                name,
                rd_count,
                (rd_count > 0) ? rd : NULL);
  }
  free_qe (qe);
}

References find_qe(), free_qe(), GNUNET_assert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_deserialize(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, h, LOG, msg, name, qe, rd, and rd_count.

Here is the call graph for this function:

◆ check_edit_record_set_response()

static int check_edit_record_set_response	(	void *	cls,
		const struct EditRecordSetResponseMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_RESPONSE.

Parameters

cls
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 524 of file namestore_api.c.

{
  const char *editor_hint;
  size_t msg_len;
  size_t editor_hint_len;
  size_t rd_len;
 
  (void) cls;
  rd_len = ntohs (msg->rd_len);
  msg_len = ntohs (msg->gns_header.header.size);
  editor_hint_len = ntohs (msg->editor_hint_len);
  if (msg_len != sizeof(struct EditRecordSetResponseMessage) + editor_hint_len
      + rd_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  editor_hint = (const char *) &msg[1];
  if ((0 == editor_hint_len) || ('\0' != editor_hint[editor_hint_len - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return check_rd (rd_len, &editor_hint[editor_hint_len], ntohs (
                     msg->rd_count));
}

References check_rd(), GNUNET_break, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_edit_record_set_response()

static void handle_edit_record_set_response	(	void *	cls,
		const struct EditRecordSetResponseMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_RESPONSE.

Parameters

cls
msg	the message we received

Definition at line 561 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = cls;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  const char *editor_hint;
  const char *rd_tmp;
  size_t rd_len;
  size_t editor_hint_len;
  unsigned int rd_count;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received EDIT_RECORD_SET_RESPONSE\n");
  rd_len = ntohs (msg->rd_len);
  rd_count = ntohs (msg->rd_count);
  editor_hint_len = ntohs (msg->editor_hint_len);
  qe = find_qe (h, ntohl (msg->gns_header.r_id));
  if (NULL == qe)
    return; /* rid not found */
  editor_hint = (const char *) &msg[1];
  rd_tmp = &editor_hint[editor_hint_len];
  {
    struct GNUNET_GNSRECORD_Data rd[rd_count];
 
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_tmp, rd_count, rd));
    if (0 == editor_hint_len)
      editor_hint = NULL;
    if (NULL != qe->edit_proc)
      qe->edit_proc (qe->proc_cls,
                     ntohs (msg->ec),
                     rd_count,
                     (rd_count > 0) ? rd : NULL,
                     editor_hint);
    free_qe (qe);
    return;
  }
  GNUNET_assert (0);
}

References find_qe(), free_qe(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_deserialize(), GNUNET_OK, h, LOG, msg, qe, rd, and rd_count.

Here is the call graph for this function:

◆ check_record_result()

static int check_record_result	(	void *	cls,
		const struct RecordResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.

Parameters

cls
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 611 of file namestore_api.c.

{
  const char *name;
  size_t msg_len;
  size_t name_len;
  size_t rd_len;
  size_t key_len;
 
  (void) cls;
  rd_len = ntohs (msg->rd_len);
  msg_len = ntohs (msg->gns_header.header.size);
  key_len = ntohs (msg->key_len);
  name_len = ntohs (msg->name_len);
  if (msg_len != sizeof(struct RecordResultMessage) + key_len + name_len
      + rd_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name = (const char *) &msg[1] + key_len;
  if ((0 == name_len) || ('\0' != name[name_len - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  if (0 == key_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return check_rd (rd_len, &name[name_len], ntohs (msg->rd_count));
}

References check_rd(), GNUNET_break, GNUNET_SYSERR, msg, name, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_record_result()

static void handle_record_result	(	void *	cls,
		const struct RecordResultMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT.

Parameters

cls
msg	the message we received

Definition at line 653 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = cls;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_NAMESTORE_ZoneIterator *ze;
  struct GNUNET_CRYPTO_BlindablePrivateKey private_key;
  const char *name;
  const char *rd_tmp;
  size_t name_len;
  size_t rd_len;
  size_t key_len;
  size_t kbytes_read;
  unsigned int rd_count;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT\n");
  rd_len = ntohs (msg->rd_len);
  rd_count = ntohs (msg->rd_count);
  name_len = ntohs (msg->name_len);
  key_len = ntohs (msg->key_len);
  ze = find_zi (h, ntohl (msg->gns_header.r_id));
  qe = find_qe (h, ntohl (msg->gns_header.r_id));
  if ((NULL == ze) && (NULL == qe))
    return; /* rid not found */
  if ((NULL != ze) && (NULL != qe))
  {
    GNUNET_break (0);  /* rid ambiguous */
    force_reconnect (h);
    return;
  }
  name = (const char *) &msg[1] + key_len;
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_CRYPTO_read_private_key_from_buffer (&msg[1],
                                                             key_len,
                                                             &private_key,
                                                             &kbytes_read));
  GNUNET_assert (kbytes_read == key_len);
  rd_tmp = &name[name_len];
  {
    struct GNUNET_GNSRECORD_Data rd[rd_count];
 
    GNUNET_assert (
      GNUNET_OK ==
      GNUNET_GNSRECORD_records_deserialize (rd_len, rd_tmp, rd_count, rd));
    if (0 == name_len)
      name = NULL;
    if (NULL != qe)
    {
      if (NULL != qe->proc)
        qe->proc (qe->proc_cls,
                  &private_key,
                  name,
                  rd_count,
                  (rd_count > 0) ? rd : NULL);
      free_qe (qe);
      return;
    }
    if (NULL != ze)
    {
      // Store them here because a callback could free ze
      GNUNET_NAMESTORE_RecordMonitor proc;
      GNUNET_NAMESTORE_RecordSetMonitor proc2;
      void *proc_cls = ze->proc_cls;
      proc = ze->proc;
      proc2 = ze->proc2;
      if (NULL != proc)
        proc (proc_cls, &private_key, name, rd_count, rd);
      if (NULL != proc2)
        proc2 (proc_cls, &private_key, name,
               rd_count, rd, GNUNET_TIME_absolute_ntoh (msg->expire));
      return;
    }
  }
  GNUNET_assert (0);
}

References find_qe(), find_zi(), force_reconnect(), free_qe(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_records_deserialize(), GNUNET_OK, GNUNET_SYSERR, GNUNET_TIME_absolute_ntoh(), h, LOG, msg, name, GNUNET_NAMESTORE_ZoneIterator::proc, GNUNET_NAMESTORE_ZoneIterator::proc2, GNUNET_NAMESTORE_ZoneIterator::proc_cls, qe, rd, and rd_count.

Here is the call graph for this function:

◆ handle_record_result_end()

static void handle_record_result_end	(	void *	cls,
		const struct GNUNET_NAMESTORE_Header *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END.

Parameters

cls
msg	the message we received

Definition at line 737 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = cls;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_NAMESTORE_ZoneIterator *ze;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received RECORD_RESULT_END\n");
  ze = find_zi (h, ntohl (msg->r_id));
  qe = find_qe (h, ntohl (msg->r_id));
  if ((NULL == ze) && (NULL == qe))
    return; /* rid not found */
  if ((NULL != ze) && (NULL != qe))
  {
    GNUNET_break (0);  /* rid ambiguous */
    force_reconnect (h);
    return;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Zone iteration completed!\n");
  if (NULL == ze)
  {
    GNUNET_break (0);
    force_reconnect (h);
    return;
  }
  if (NULL != ze->finish_cb)
    ze->finish_cb (ze->finish_cb_cls);
  free_ze (ze);
}

References find_qe(), find_zi(), GNUNET_NAMESTORE_ZoneIterator::finish_cb, GNUNET_NAMESTORE_ZoneIterator::finish_cb_cls, force_reconnect(), free_ze(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, h, LOG, msg, and qe.

Here is the call graph for this function:

◆ check_zone_to_name_response()

static int check_zone_to_name_response	(	void *	cls,
		const struct ZoneToNameResponseMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.

Parameters

qe	the respective entry in the message queue
msg	the message we received

Returns: GNUNET_OK on success, GNUNET_SYSERR if message malformed

Definition at line 776 of file namestore_api.c.

{
  size_t name_len;
  size_t rd_ser_len;
  size_t key_len;
  const char *name_tmp;
 
  (void) cls;
  if (GNUNET_EC_NONE != ntohl (msg->ec))
    return GNUNET_OK;
  key_len = ntohs (msg->key_len);
  name_len = ntohs (msg->name_len);
  rd_ser_len = ntohs (msg->rd_len);
  if (ntohs (msg->gns_header.header.size) !=
      sizeof(struct ZoneToNameResponseMessage) + key_len + name_len
      + rd_ser_len)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  name_tmp = (const char *) &msg[1] + key_len;
  if ((name_len > 0) && ('\0' != name_tmp[name_len - 1]))
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return check_rd (rd_ser_len, &name_tmp[name_len], ntohs (msg->rd_count));
}

References check_rd(), GNUNET_break, GNUNET_EC_NONE, GNUNET_OK, GNUNET_SYSERR, msg, and GNUNET_MessageHeader::size.

Here is the call graph for this function:

◆ handle_zone_to_name_response()

static void handle_zone_to_name_response	(	void *	cls,
		const struct ZoneToNameResponseMessage *	msg
	)

static

Handle an incoming message of type GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE.

Parameters

cls
msg	the message we received

Definition at line 815 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = cls;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_CRYPTO_BlindablePrivateKey zone;
  enum GNUNET_ErrorCode res;
  size_t name_len;
  size_t rd_ser_len;
  unsigned int rd_count;
  const char *name_tmp;
  const char *rd_tmp;
  size_t key_len;
  size_t kbytes_read;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Received ZONE_TO_NAME_RESPONSE\n");
  qe = find_qe (h, ntohl (msg->gns_header.r_id));
  if (NULL == qe)
  {
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Response queue already gone...\n");
    return;
  }
  res = ntohl (msg->ec);
  key_len = ntohs (msg->key_len);
  GNUNET_assert (GNUNET_SYSERR !=
                 GNUNET_CRYPTO_read_private_key_from_buffer (&msg[1],
                                                             key_len,
                                                             &zone,
                                                             &kbytes_read));
  GNUNET_assert (kbytes_read == key_len);
  switch (res)
  {
  break;
 
  case GNUNET_EC_NAMESTORE_NO_RESULTS:
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Namestore has no result for zone to name mapping \n");
    if (NULL != qe->proc)
      qe->proc (qe->proc_cls, &zone, NULL, 0, NULL);
    free_qe (qe);
    return;
 
  case GNUNET_EC_NONE:
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Namestore has result for zone to name mapping \n");
    name_len = ntohs (msg->name_len);
    rd_count = ntohs (msg->rd_count);
    rd_ser_len = ntohs (msg->rd_len);
    name_tmp = (const char *) &msg[1] + key_len;
    rd_tmp = &name_tmp[name_len];
    {
      struct GNUNET_GNSRECORD_Data rd[rd_count];
 
      GNUNET_assert (GNUNET_OK ==
                     GNUNET_GNSRECORD_records_deserialize (rd_ser_len,
                                                           rd_tmp,
                                                           rd_count,
                                                           rd));
      /* normal end, call continuation with result */
      if (NULL != qe->proc)
        qe->proc (qe->proc_cls, &zone, name_tmp, rd_count, rd);
      /* return is important here: break would call continuation with error! */
      free_qe (qe);
      return;
    }
 
  default:
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "An error occurred during zone to name operation: %s\n",
         GNUNET_ErrorCode_get_hint (res));
    break;
  }
  /* error case, call continuation with error */
  if (NULL != qe->error_cb)
    qe->error_cb (qe->error_cb_cls);
  free_qe (qe);
}

References find_qe(), free_qe(), GNUNET_assert, GNUNET_CRYPTO_read_private_key_from_buffer(), GNUNET_EC_NAMESTORE_NO_RESULTS, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_ErrorCode_get_hint(), GNUNET_GNSRECORD_records_deserialize(), GNUNET_OK, GNUNET_SYSERR, h, LOG, msg, qe, rd, rd_count, 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_NAMESTORE_Handle *`
error	error code

Definition at line 904 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = cls;
 
  (void) error;
  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_NAMESTORE_Handle * h )

static

Reconnect to namestore service.

Parameters

h	the handle to the NAMESTORE service

Definition at line 919 of file namestore_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] =
  { GNUNET_MQ_hd_fixed_size (generic_response,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_GENERIC_RESPONSE,
                             struct NamestoreResponseMessage,
                             h),
    GNUNET_MQ_hd_var_size (zone_to_name_response,
                           GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE,
                           struct ZoneToNameResponseMessage,
                           h),
    GNUNET_MQ_hd_var_size (record_result,
                           GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT,
                           struct RecordResultMessage,
                           h),
    GNUNET_MQ_hd_fixed_size (record_result_end,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END,
                             struct GNUNET_NAMESTORE_Header,
                             h),
    GNUNET_MQ_hd_var_size (lookup_result,
                           GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE,
                           struct LabelLookupResponseMessage,
                           h),
    GNUNET_MQ_hd_var_size (edit_record_set_response,
                           GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_RESPONSE,
                           struct EditRecordSetResponseMessage,
                           h),
    GNUNET_MQ_handler_end () };
  struct GNUNET_NAMESTORE_ZoneIterator *it;
  struct GNUNET_NAMESTORE_QueueEntry *qe;
 
  GNUNET_assert (NULL == h->mq);
  h->mq =
    GNUNET_CLIENT_connect (h->cfg, "namestore", handlers, &mq_error_handler, h);
  if (NULL == h->mq)
    return;
  /* re-transmit pending requests that waited for a reconnect... */
  for (it = h->z_head; NULL != it; it = it->next)
  {
    GNUNET_MQ_send (h->mq, it->env);
    it->env = NULL;
  }
  for (qe = h->op_head; NULL != qe; qe = qe->next)
  {
    GNUNET_MQ_send (h->mq, qe->env);
    qe->env = NULL;
  }
}

References GNUNET_ARM_Handle::cfg, GNUNET_DATASTORE_QueueEntry::env, GNUNET_NAMESTORE_ZoneIterator::env, GNUNET_assert, GNUNET_CLIENT_connect(), GNUNET_MESSAGE_TYPE_NAMESTORE_GENERIC_RESPONSE, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP_RESPONSE, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_RESULT_END, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_RESPONSE, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME_RESPONSE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_fixed_size, GNUNET_MQ_hd_var_size, GNUNET_MQ_send(), h, handlers, GNUNET_ARM_Handle::mq, mq_error_handler(), GNUNET_DATASTORE_QueueEntry::next, GNUNET_NAMESTORE_ZoneIterator::next, and qe.

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 975 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_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_NAMESTORE_Handle * h )

static

Get a fresh operation id to distinguish between namestore requests.

Parameters

h	the namestore handle

Returns: next operation id to use

Definition at line 1027 of file namestore_api.c.

{
  return h->last_op_id_used++;
}

References h.

Referenced by GNUNET_NAMESTORE_record_set_edit_begin(), GNUNET_NAMESTORE_record_set_edit_cancel(), GNUNET_NAMESTORE_records_store(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_NAMESTORE_zone_to_name(), and records_lookup().

Here is the caller graph for this function:

◆ warn_delay()

static void warn_delay ( void * cls )

static

Task launched to warn the user that the namestore is excessively slow and that a query was thus dropped.

Parameters

cls	a `struct GNUNET_NAMESTORE_QueueEntry *`

Definition at line 1102 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_QueueEntry *qe = cls;
 
  qe->timeout_task = NULL;
  LOG (GNUNET_ERROR_TYPE_WARNING,
       "Did not receive response from namestore after %s!\n",
       GNUNET_STRINGS_relative_time_to_string (NAMESTORE_DELAY_TOLERANCE,
                                               GNUNET_YES));
  if (NULL != qe->cont)
  {
    qe->cont (qe->cont_cls, GNUNET_EC_NAMESTORE_UNKNOWN);
    qe->cont = NULL;
  }
  GNUNET_NAMESTORE_cancel (qe);
}

References GNUNET_DATASTORE_QueueEntry::cont, GNUNET_DATASTORE_QueueEntry::cont_cls, GNUNET_EC_NAMESTORE_UNKNOWN, GNUNET_ERROR_TYPE_WARNING, GNUNET_NAMESTORE_cancel(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, LOG, NAMESTORE_DELAY_TOLERANCE, and qe.

Referenced by GNUNET_NAMESTORE_records_store().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ records_lookup()

static struct GNUNET_NAMESTORE_QueueEntry * records_lookup	(	struct GNUNET_NAMESTORE_Handle *	h,
		const struct GNUNET_CRYPTO_BlindablePrivateKey *	pkey,
		const char *	label,
		GNUNET_SCHEDULER_TaskCallback	error_cb,
		void *	error_cb_cls,
		GNUNET_NAMESTORE_RecordMonitor	rm,
		void *	rm_cls,
		enum GNUNET_GNSRECORD_Filter	filter
	)

static

Definition at line 1269 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_MQ_Envelope *env;
  struct LabelLookupMessage *msg;
  size_t label_len;
  size_t key_len;
 
  if (1 == (label_len = strlen (label) + 1))
  {
    GNUNET_break (0);
    return NULL;
  }
 
  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
  qe->h = h;
  qe->error_cb = error_cb;
  qe->error_cb_cls = error_cb_cls;
  qe->proc = rm;
  qe->proc_cls = rm_cls;
  qe->op_id = get_op_id (h);
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
 
  key_len = GNUNET_CRYPTO_blindable_sk_get_length (pkey);
  env = GNUNET_MQ_msg_extra (msg,
                             label_len +  key_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP);
  msg->gns_header.r_id = htonl (qe->op_id);
  GNUNET_CRYPTO_write_blindable_sk_to_buffer (pkey,
                                              &msg[1],
                                              key_len);
 
  msg->key_len = htons (key_len);
  msg->label_len = htons (label_len);
  msg->filter = htons (filter);
  GNUNET_memcpy (((char*) &msg[1]) + key_len, label, label_len);
  if (NULL == h->mq)
    qe->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return qe;
}

References env, GNUNET_DATASTORE_QueueEntry::env, error_cb(), filter, get_op_id(), GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_CRYPTO_write_blindable_sk_to_buffer(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_LOOKUP, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_DATASTORE_QueueEntry::h, LabelLookupMessage::key_len, LabelLookupMessage::label_len, GNUNET_ARM_Handle::mq, msg, pkey, and qe.

Referenced by GNUNET_NAMESTORE_records_lookup(), and GNUNET_NAMESTORE_records_lookup2().

Here is the call graph for this function:

Here is the caller graph for this function:

Data Structures

Macros

Functions

Detailed Description

Macro Definition Documentation

◆ LOG

◆ NAMESTORE_DELAY_TOLERANCE

Function Documentation

◆ force_reconnect()

◆ find_qe()

◆ find_zi()

◆ free_qe()

◆ free_ze()

◆ check_rd()

◆ handle_generic_response()

◆ check_lookup_result()

◆ handle_lookup_result()

◆ check_edit_record_set_response()

◆ handle_edit_record_set_response()

◆ check_record_result()

◆ handle_record_result()

◆ handle_record_result_end()

◆ check_zone_to_name_response()

◆ handle_zone_to_name_response()

◆ mq_error_handler()

◆ reconnect()

◆ reconnect_task()

◆ get_op_id()

◆ warn_delay()

◆ records_lookup()