Name Store service

Store naming information on a GNUnet node. More...

Collaboration diagram for Name Store service:

Data Structures
struct	GNUNET_NAMESTORE_RecordInfo
	A struct for record bulk import. More...

Typedefs
typedef void(*	GNUNET_NAMESTORE_ContinuationWithStatus) (void *cls, enum GNUNET_ErrorCode ec)
	Continuation called to notify client about result of the operation.
typedef void(*	GNUNET_NAMESTORE_RecordMonitor) (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Process a record that was stored in the namestore.
typedef void(*	GNUNET_NAMESTORE_EditRecordSetBeginCallback) (void *cls, enum GNUNET_ErrorCode ec, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, const char *editor_hint)
	Process a record that was stored in the namestore.
typedef void(*	GNUNET_NAMESTORE_RecordSetMonitor) (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
	Process a record set that was stored in the namestore.

Enumerations
enum	GNUNET_NAMESTORE_TxControl { GNUNET_NAMESTORE_TX_BEGIN = 0 , GNUNET_NAMESTORE_TX_COMMIT = 1 , GNUNET_NAMESTORE_TX_ROLLBACK = 2 }
	Transaction control types. More...

Functions
struct GNUNET_NAMESTORE_Handle *	GNUNET_NAMESTORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Connect to the namestore service.
void	GNUNET_NAMESTORE_disconnect (struct GNUNET_NAMESTORE_Handle *h)
	Disconnect from the namestore service (and free associated resources).
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.
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, int is_zonemaster, GNUNET_NAMESTORE_ContinuationWithStatus cont, void *cont_cls)
	Store an item in the namestore.
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.
void	GNUNET_NAMESTORE_cancel (struct GNUNET_NAMESTORE_QueueEntry *qe)
	Cancel a namestore operation.
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.
struct GNUNET_NAMESTORE_ZoneMonitor *	GNUNET_NAMESTORE_zone_monitor_start (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, int iterate_first, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordMonitor monitor, void *monitor_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls)
struct GNUNET_NAMESTORE_ZoneMonitor *	GNUNET_NAMESTORE_zone_monitor_start2 (const struct GNUNET_CONFIGURATION_Handle *cfg, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, int iterate_first, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_NAMESTORE_RecordSetMonitor monitor, void *monitor_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls, enum GNUNET_GNSRECORD_Filter filter)
	Begin monitoring a zone for changes.
void	GNUNET_NAMESTORE_zone_monitor_next (struct GNUNET_NAMESTORE_ZoneMonitor *zm, uint64_t limit)
	Calls the monitor processor specified in GNUNET_NAMESTORE_zone_monitor_start for the next record(s).
void	GNUNET_NAMESTORE_zone_monitor_stop (struct GNUNET_NAMESTORE_ZoneMonitor *zm)
	Stop monitoring a zone for changes.
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

Store naming information on a GNUnet node.

Naming information can either be records for which this peer/user is authoritative, or blocks which are cached, encrypted naming data from other peers.

See also

Documentation

Typedef Documentation

GNUNET_NAMESTORE_ContinuationWithStatus

typedef void(* GNUNET_NAMESTORE_ContinuationWithStatus) (void *cls, enum GNUNET_ErrorCode ec)

Continuation called to notify client about result of the operation.

Parameters

cls	closure
success	GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) GNUNET_NO if content was already there or not found GNUNET_YES (or other positive value) on success
ec	the GNUNET_ErrorCode, GNUNET_EC_NONE on success.

Definition at line 127 of file gnunet_namestore_service.h.

GNUNET_NAMESTORE_RecordMonitor

typedef void(* GNUNET_NAMESTORE_RecordMonitor) (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)

Process a record that was stored in the namestore.

Parameters

cls	closure
zone	private key of the zone
label	label of the records
rd_count	number of entries in rd array, 0 if label was deleted
rd	array of records with data to store

Definition at line 245 of file gnunet_namestore_service.h.

GNUNET_NAMESTORE_EditRecordSetBeginCallback

typedef void(* GNUNET_NAMESTORE_EditRecordSetBeginCallback) (void *cls, enum GNUNET_ErrorCode ec, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, const char *editor_hint)

Process a record that was stored in the namestore.

Parameters

cls	closure
ec	the error code. GNUNET_EC_NONE on success.
rd_count	number of entries in rd array, 0 if label was deleted
rd	array of records with data to store
editor_hint	the advisory lock value that was replaced. NULL of not advisory lock was set or if lock was equal to provided editor hint.

Definition at line 262 of file gnunet_namestore_service.h.

GNUNET_NAMESTORE_RecordSetMonitor

typedef void(* GNUNET_NAMESTORE_RecordSetMonitor) (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)

Process a record set that was stored in the namestore.

The record set expiration value takes existing TOMBSTONE records into account even if those are not returned.

Parameters

cls	closure
zone	private key of the zone
label	label of the records
rd_count	number of entries in rd array, 0 if label was deleted
rd	array of records with data to store
expiry	the expiration of this record set.

Definition at line 282 of file gnunet_namestore_service.h.

Enumeration Type Documentation

GNUNET_NAMESTORE_TxControl

enum GNUNET_NAMESTORE_TxControl

Transaction control types.

They roughly correspond to DB transaction controls

Enumerator
GNUNET_NAMESTORE_TX_BEGIN
GNUNET_NAMESTORE_TX_COMMIT
GNUNET_NAMESTORE_TX_ROLLBACK

Definition at line 77 of file gnunet_namestore_service.h.

{
  GNUNET_NAMESTORE_TX_BEGIN = 0,
  GNUNET_NAMESTORE_TX_COMMIT = 1,
  GNUNET_NAMESTORE_TX_ROLLBACK = 2,
};

Function Documentation

GNUNET_NAMESTORE_connect()

struct GNUNET_NAMESTORE_Handle * GNUNET_NAMESTORE_connect

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Connect to the namestore service.

Parameters

cfg	configuration to use

Returns

handle to use to access the service

Connect to the namestore service.

Parameters

cfg	configuration to use

Returns

handle to the GNS service, or NULL on error

Definition at line 1040 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h;
 
  h = GNUNET_new (struct GNUNET_NAMESTORE_Handle);
  h->cfg = cfg;
  reconnect (h);
  if (NULL == h->mq)
  {
    GNUNET_free (h);
    return NULL;
  }
  return h;
}

References cfg, GNUNET_ARM_Handle::cfg, GNUNET_free, GNUNET_new, h, GNUNET_ARM_Handle::mq, and reconnect().

Referenced by create_handle(), GNUNET_CONVERSATION_phone_create(), namestore_import(), RECLAIM_TICKETS_init(), REST_namestore_init(), run(), run(), run(), run(), run(), run(), run(), run(), and store_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_disconnect()

void GNUNET_NAMESTORE_disconnect

(

struct GNUNET_NAMESTORE_Handle *

h

)

Disconnect from the namestore service (and free associated resources).

Must not be called from within operation callbacks of the API.

Parameters

h	handle to the namestore
h	handle to the namestore

Definition at line 1063 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_QueueEntry *q;
  struct GNUNET_NAMESTORE_ZoneIterator *z;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Cleaning up\n");
  GNUNET_break (NULL == h->op_head);
  while (NULL != (q = h->op_head))
  {
    GNUNET_CONTAINER_DLL_remove (h->op_head, h->op_tail, q);
    GNUNET_free (q);
  }
  GNUNET_break (NULL == h->z_head);
  while (NULL != (z = h->z_head))
  {
    GNUNET_CONTAINER_DLL_remove (h->z_head, h->z_tail, z);
    GNUNET_free (z);
  }
  if (NULL != h->mq)
  {
    GNUNET_MQ_destroy (h->mq);
    h->mq = NULL;
  }
  if (NULL != h->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (h->reconnect_task);
    h->reconnect_task = NULL;
  }
  GNUNET_free (h);
}

References GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), h, LOG, GNUNET_ARM_Handle::mq, q, and GNUNET_ARM_Handle::reconnect_task.

Referenced by cleanup(), cleanup(), cleanup_handle(), destroy_handle(), do_shutdown(), do_shutdown(), do_shutdown(), do_shutdown(), GNUNET_CONVERSATION_phone_destroy(), RECLAIM_TICKETS_deinit(), REST_namestore_done(), shutdown_task(), shutdown_task(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_record_set_store()

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.

If the item is already present, it is replaced with the new record. Use an empty array to remove all records under the given name.

The continuation is called after the value has been stored in the database. Monitors may be notified asynchronously (basically with a buffer). However, if any monitor is consistently too slow to keep up with the changes, calling cont will be delayed until the monitors do keep up.

This always overwrites the record set and unsets any advisory lock inrrespective of the currently set editor hint/advisory lock value.

Parameters

h	handle to the namestore
pkey	private key of the zone
label	name that is being mapped
rd_count	number of records in the 'rd' array
rd	array of records with data to store
cont	continuation to call when done
cont_cls	closure for cont

Returns

handle to abort the request

Definition at line 1121 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_RecordInfo ri;
  unsigned int rds_sent;
  ri.a_label = label;
  ri.a_rd_count = rd_count;
  ri.a_rd = (struct GNUNET_GNSRECORD_Data *) rd;
  return GNUNET_NAMESTORE_records_store (h, pkey, 1, &ri, &rds_sent,
                                         cont, cont_cls);
}

References GNUNET_NAMESTORE_RecordInfo::a_label, GNUNET_NAMESTORE_records_store(), h, pkey, rd, rd_count, and ri.

Referenced by attr_store_task(), cred_add_cb(), del_monitor(), DID_create_namestore_lookup_cb(), get_existing_record(), get_existing_record(), handle_attribute_delete_message(), handle_credential_delete_message(), issue_ticket(), missing_zone_creation_cont(), move_attr_finished(), namestore_delete(), ns_lookup_cb(), process_queue(), process_result(), process_tickets(), purge_attributes(), purge_next_record(), remove_did_document_ego_lookup_cb(), revoke_attrs_cb(), run_with_zone_pkey(), rvk_move_attr_cb(), store_handle_epoch_key(), and update_tickets().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_records_store()

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.

If any item is already present, it is replaced with the new record. Use an empty array to remove all records under the given name.

The continuation is called after the records have been stored in the database. They may not yet have been committed. Monitors may be notified asynchronously (basically with a buffer when committed). However, if any monitor is consistently too slow to keep up with the changes, calling cont will be delayed until the monitors do keep up. Uncommitted store requests within a transaction (GNUNET_NAMESTORE_transaction_begin) cause cont to be called immediately before the commit and before notification of monitors.

This always overwrites the record set and unsets any advisory lock inrrespective of the currently set editor hint/advisory lock value.

Parameters

h	handle to the namestore
pkey	private key of the zone
rd_set_count	the number of record sets
record_info	the records to add containing rd_set_count records
cont	continuation to call when done
rds_sent	set to how many record sets could actually be sent
cont_cls	closure for cont

Returns

handle to abort the request

Definition at line 1141 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_MQ_Envelope *env;
  const char *label;
  unsigned int rd_count;
  const struct GNUNET_GNSRECORD_Data *rd;
  char *name_tmp;
  char *rd_ser;
  ssize_t rd_ser_len[rd_set_count];
  size_t name_len;
  uint32_t rid;
  struct RecordStoreMessage *msg;
  struct RecordSet *rd_set;
  ssize_t sret;
  int i;
  size_t rd_set_len = 0;
  size_t key_len = 0;
  size_t max_len;
  key_len = GNUNET_CRYPTO_blindable_sk_get_length (pkey);
  max_len = UINT16_MAX - key_len - sizeof (struct RecordStoreMessage);
 
  *rds_sent = 0;
  for (i = 0; i < rd_set_count; i++)
  {
    label = record_info[i].a_label;
    rd_count = record_info[i].a_rd_count;
    rd = record_info[i].a_rd;
    name_len = strlen (label) + 1;
    if (name_len > MAX_NAME_LEN)
    {
      GNUNET_break (0);
      *rds_sent = 0;
      return NULL;
    }
    rd_ser_len[i] = GNUNET_GNSRECORD_records_get_size (rd_count, rd);
    if (rd_ser_len[i] < 0)
    {
      GNUNET_break (0);
      *rds_sent = 0;
      return NULL;
    }
    if (rd_ser_len[i] > max_len)
    {
      GNUNET_break (0);
      *rds_sent = 0;
      return NULL;
    }
    if ((rd_set_len + sizeof (struct RecordSet) + name_len + rd_ser_len[i]) >
        max_len)
      break;
    rd_set_len += sizeof (struct RecordSet) + name_len + rd_ser_len[i];
  }
  *rds_sent = i;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending %u of %u records!\n", *rds_sent, rd_set_count);
  rid = get_op_id (h);
  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
  qe->h = h;
  qe->cont = cont;
  qe->cont_cls = cont_cls;
  qe->op_id = rid;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
  /* setup msg */
  env = GNUNET_MQ_msg_extra (msg,
                             key_len + rd_set_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE);
  GNUNET_assert (NULL != msg);
  GNUNET_assert (NULL != env);
  msg->gns_header.r_id = htonl (rid);
  msg->key_len = htons (key_len);
  msg->single_tx = htons (GNUNET_YES);
  msg->rd_set_count = htons ((uint16_t) (*rds_sent));
  GNUNET_CRYPTO_write_blindable_sk_to_buffer (pkey,
                                              &msg[1],
                                              key_len);
  rd_set = (struct RecordSet*) (((char*) &msg[1]) + key_len);
  for (i = 0; i < *rds_sent; i++)
  {
    label = record_info[i].a_label;
    rd = record_info[i].a_rd;
    name_len = strlen (label) + 1;
    rd_set->name_len = htons (name_len);
    rd_set->rd_count = htons (record_info[i].a_rd_count);
    rd_set->rd_len = htons (rd_ser_len[i]);
    rd_set->reserved = ntohs (0);
    name_tmp = (char *) &rd_set[1];
    GNUNET_memcpy (name_tmp, label, name_len);
    rd_ser = &name_tmp[name_len];
    sret = GNUNET_GNSRECORD_records_serialize (record_info[i].a_rd_count,
                                               rd, rd_ser_len[i], rd_ser);
    if ((0 > sret) || (sret != rd_ser_len[i]))
    {
      GNUNET_break (0);
      GNUNET_free (env);
      return NULL;
    }
    // Point to next RecordSet
    rd_set = (struct RecordSet*) &name_tmp[name_len + rd_ser_len[i]];
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending NAMESTORE_RECORD_STORE message for name %u record sets\n",
       *rds_sent);
  qe->timeout_task =
    GNUNET_SCHEDULER_add_delayed (NAMESTORE_DELAY_TOLERANCE, &warn_delay, qe);
  if (NULL == h->mq)
  {
    qe->env = env;
    LOG (GNUNET_ERROR_TYPE_WARNING,
         "Delaying NAMESTORE_RECORD_STORE message as namestore is not ready!\n")
    ;
  }
  else
  {
    GNUNET_MQ_send (h->mq, env);
  }
  return qe;
}

References GNUNET_NAMESTORE_RecordInfo::a_label, GNUNET_NAMESTORE_RecordInfo::a_rd, GNUNET_NAMESTORE_RecordInfo::a_rd_count, GNUNET_DATASTORE_QueueEntry::cont, GNUNET_DATASTORE_QueueEntry::cont_cls, env, GNUNET_DATASTORE_QueueEntry::env, get_op_id(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_CRYPTO_write_blindable_sk_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_STORE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_SCHEDULER_add_delayed(), GNUNET_YES, h, GNUNET_DATASTORE_QueueEntry::h, LOG, MAX_NAME_LEN, GNUNET_ARM_Handle::mq, msg, RecordSet::name_len, NAMESTORE_DELAY_TOLERANCE, pkey, qe, rd, rd_count, RecordSet::rd_count, RecordSet::rd_len, RecordStoreMessage::rd_set_count, record_info, RecordSet::reserved, and warn_delay().

Referenced by batch_insert_recordinfo(), bulk_tx_start(), GNUNET_NAMESTORE_record_set_store(), and import_next_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_record_set_store_()

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,
		int	is_zonemaster,
		GNUNET_NAMESTORE_ContinuationWithStatus	cont,
		void *	cont_cls
	)

Store an item in the namestore.

If the item is already present, it is replaced with the new record. Use an empty array to remove all records under the given name.

The continuation is called after the value has been stored in the database. Monitors may be notified asynchronously (basically with a buffer). However, if any monitor is consistently too slow to keep up with the changes, calling cont will be delayed until the monitors do keep up.

Parameters

h	handle to the namestore
pkey	private key of the zone
label	name that is being mapped
rd_count	number of records in the 'rd' array
rd	array of records with data to store
is_zonemaster	update tombstones, do not process monitors
cont	continuation to call when done
cont_cls	closure for cont

Returns

handle to abort the request

GNUNET_NAMESTORE_records_lookup()

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.

Parameters

h	handle to the namestore
pkey	private key of the zone
label	name that is being mapped
error_cb	function to call on error (i.e. disconnect) the handle is afterwards invalid
error_cb_cls	closure for error_cb
rm	function to call with the result (with 0 records if we don't have that label); the handle is afterwards invalid
rm_cls	closure for rm

Returns

handle to abort the request

Definition at line 1322 of file namestore_api.c.

{
  return records_lookup (h, pkey, label,
                         error_cb, error_cb_cls,
                         rm, rm_cls, GNUNET_GNSRECORD_FILTER_NONE);
 
}

References error_cb(), GNUNET_NAMESTORE_QueueEntry::error_cb_cls, GNUNET_GNSRECORD_FILTER_NONE, h, pkey, and records_lookup().

Referenced by cred_store_task(), DID_create(), handle_collect(), move_attrs(), namestore_add_or_update(), RECLAIM_TICKETS_revoke(), run_with_zone_pkey(), and store_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_records_lookup2()

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.

Parameters

h	handle to the namestore
pkey	private key of the zone
label	name that is being mapped
error_cb	function to call on error (i.e. disconnect) the handle is afterwards invalid
error_cb_cls	closure for error_cb
rm	function to call with the result (with 0 records if we don't have that label); the handle is afterwards invalid
rm_cls	closure for rm
filter	the record set filter to use

Returns

handle to abort the request

Definition at line 1339 of file namestore_api.c.

{
  return records_lookup (h, pkey, label,
                         error_cb, error_cb_cls,
                         rm, rm_cls, filter);
 
}

References error_cb(), GNUNET_NAMESTORE_QueueEntry::error_cb_cls, filter, h, pkey, and records_lookup().

Referenced by namestore_get(), and run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_to_name()

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.

Returns at most one result to the processor.

Parameters

h	handle to the namestore
zone	private key of the zone to look up in, never NULL
value_zone	public key of the target zone (value), never NULL
error_cb	function to call on error (i.e. disconnect) the handle is afterwards invalid
error_cb_cls	closure for error_cb
proc	function to call on the matching records, or with NULL (rd_count == 0) if there are no matching records; the handle is afterwards invalid
proc_cls	closure for proc

Returns

a handle that can be used to cancel

Definition at line 1357 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_MQ_Envelope *env;
  struct ZoneToNameMessage *msg;
  uint32_t rid;
  size_t key_len;
  ssize_t pkey_len;
 
  rid = get_op_id (h);
  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
  qe->h = h;
  qe->error_cb = error_cb;
  qe->error_cb_cls = error_cb_cls;
  qe->proc = proc;
  qe->proc_cls = proc_cls;
  qe->op_id = rid;
  GNUNET_CONTAINER_DLL_insert_tail (h->op_head, h->op_tail, qe);
 
  key_len = GNUNET_CRYPTO_blindable_sk_get_length (zone);
  pkey_len = GNUNET_CRYPTO_public_key_get_length (value_zone);
  env = GNUNET_MQ_msg_extra (msg, key_len + pkey_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME);
  msg->gns_header.r_id = htonl (rid);
  msg->key_len = htons (key_len);
  msg->pkey_len = htons (pkey_len);
  GNUNET_CRYPTO_write_blindable_sk_to_buffer (zone, &msg[1], key_len);
  GNUNET_CRYPTO_write_blindable_pk_to_buffer (value_zone,
                                              (char*) &msg[1] + key_len,
                                              pkey_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(), get_op_id(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_CRYPTO_write_blindable_pk_to_buffer(), GNUNET_CRYPTO_write_blindable_sk_to_buffer(), GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_TO_NAME, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_DATASTORE_QueueEntry::h, ZoneToNameMessage::key_len, GNUNET_ARM_Handle::mq, msg, ZoneToNameMessage::pkey_len, and qe.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_cancel()

void GNUNET_NAMESTORE_cancel

(

struct GNUNET_NAMESTORE_QueueEntry *

qe

)

Cancel a namestore operation.

The final callback from the operation must not have been done yet. Must be called on any namestore operation that has not yet completed prior to calling GNUNET_NAMESTORE_disconnect.

Parameters

qe	operation to cancel

The final callback from the operation must not have been done yet.

Parameters

qe	operation to cancel

Definition at line 1553 of file namestore_api.c.

{
  free_qe (qe);
}

References free_qe(), and qe.

Referenced by cleanup_adh(), cleanup_as_handle(), cleanup_handle(), cleanup_issue_handle(), cleanup_rvk(), destroy_epoch_announcement(), destroy_epoch_group(), do_shutdown(), do_shutdown(), do_shutdown(), do_shutdown(), reset_handles(), store_handle_epoch_key(), and warn_delay().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_iteration_start()

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
	)

Deprecated:

since 0.16.7 will be replaced in 0.18

See also

GNUNET_NAMESTORE_zone_iteration_start2()

Starts a new zone iteration (used to periodically PUT all of our records into our DHT). This MUST lock the struct GNUNET_NAMESTORE_Handle for any other calls than GNUNET_NAMESTORE_zone_iterator_next() and GNUNET_NAMESTORE_zone_iteration_stop. proc will be called once immediately, and then again after GNUNET_NAMESTORE_zone_iterator_next() is invoked.

On error (disconnect), error_cb will be invoked. On normal completion, finish_cb proc will be invoked.

Parameters

h	handle to the namestore
zone	zone to access, NULL for all zones
error_cb	function to call on error (i.e. disconnect), the handle is afterwards invalid
error_cb_cls	closure for error_cb
proc	function to call on each name from the zone; it will be called repeatedly with a value (if available)
proc_cls	closure for proc
finish_cb	function to call on completion the handle is afterwards invalid
finish_cb_cls	closure for finish_cb

Returns

an iterator handle to use for iteration

Definition at line 1403 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_ZoneIterator *it;
  struct GNUNET_MQ_Envelope *env;
  struct ZoneIterationStartMessage *msg;
  uint32_t rid;
  size_t key_len = 0;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n");
  rid = get_op_id (h);
  it = GNUNET_new (struct GNUNET_NAMESTORE_ZoneIterator);
  it->h = h;
  it->error_cb = error_cb;
  it->error_cb_cls = error_cb_cls;
  it->finish_cb = finish_cb;
  it->finish_cb_cls = finish_cb_cls;
  it->proc = proc;
  it->proc_cls = proc_cls;
  it->op_id = rid;
  if (NULL != zone)
  {
    it->zone = *zone;
    key_len = GNUNET_CRYPTO_blindable_sk_get_length (zone);
  }
  GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it);
  env = GNUNET_MQ_msg_extra (msg,
                             key_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START)
  ;
  msg->gns_header.r_id = htonl (rid);
  msg->key_len = htons (key_len);
  if (NULL != zone)
    GNUNET_CRYPTO_write_blindable_sk_to_buffer (zone, &msg[1], key_len);
  if (NULL == h->mq)
    it->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return it;
}

References env, GNUNET_NAMESTORE_ZoneIterator::env, error_cb(), GNUNET_NAMESTORE_ZoneIterator::error_cb, GNUNET_NAMESTORE_ZoneIterator::error_cb_cls, GNUNET_NAMESTORE_ZoneIterator::finish_cb, GNUNET_NAMESTORE_ZoneIterator::finish_cb_cls, get_op_id(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_CRYPTO_write_blindable_sk_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_NAMESTORE_ZoneIterator::h, ZoneIterationStartMessage::key_len, LOG, GNUNET_ARM_Handle::mq, msg, GNUNET_NAMESTORE_ZoneIterator::op_id, GNUNET_NAMESTORE_ZoneIterator::proc, GNUNET_NAMESTORE_ZoneIterator::proc_cls, and GNUNET_NAMESTORE_ZoneIterator::zone.

Referenced by get_ego(), handle_credential_iteration_start(), handle_iteration_start(), iterate_zones(), move_attrs(), RECLAIM_TICKETS_issue(), RECLAIM_TICKETS_iteration_start(), and start_consistency_update().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_iteration_start2()

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

This MUST lock the struct GNUNET_NAMESTORE_Handle for any other calls than GNUNET_NAMESTORE_zone_iterator_next() and GNUNET_NAMESTORE_zone_iteration_stop. proc will be called once immediately, and then again after GNUNET_NAMESTORE_zone_iterator_next() is invoked.

On error (disconnect), error_cb will be invoked. On normal completion, finish_cb proc will be invoked.

Parameters

h	handle to the namestore
zone	zone to access, NULL for all zones
error_cb	function to call on error (i.e. disconnect), the handle is afterwards invalid
error_cb_cls	closure for error_cb
proc	function to call on each name from the zone; it will be called repeatedly with a value (if available)
proc_cls	closure for proc
finish_cb	function to call on completion the handle is afterwards invalid
finish_cb_cls	closure for finish_cb
filter	the record set filter to use

Returns

an iterator handle to use for iteration

Definition at line 1453 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_ZoneIterator *it;
  struct GNUNET_MQ_Envelope *env;
  struct ZoneIterationStartMessage *msg;
  uint32_t rid;
  size_t key_len = 0;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_START message\n");
  rid = get_op_id (h);
  it = GNUNET_new (struct GNUNET_NAMESTORE_ZoneIterator);
  it->h = h;
  it->error_cb = error_cb;
  it->error_cb_cls = error_cb_cls;
  it->finish_cb = finish_cb;
  it->finish_cb_cls = finish_cb_cls;
  it->proc2 = proc;
  it->proc_cls = proc_cls;
  it->op_id = rid;
  if (NULL != zone)
  {
    it->zone = *zone;
    key_len = GNUNET_CRYPTO_blindable_sk_get_length (zone);
  }
  GNUNET_CONTAINER_DLL_insert_tail (h->z_head, h->z_tail, it);
  env = GNUNET_MQ_msg_extra (msg,
                             key_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START)
  ;
  msg->gns_header.r_id = htonl (rid);
  msg->key_len = htons (key_len);
  msg->filter = htons ((uint16_t) filter);
  if (NULL != zone)
    GNUNET_CRYPTO_write_blindable_sk_to_buffer (zone, &msg[1], key_len);
  if (NULL == h->mq)
    it->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return it;
}

References env, GNUNET_NAMESTORE_ZoneIterator::env, error_cb(), GNUNET_NAMESTORE_ZoneIterator::error_cb, GNUNET_NAMESTORE_ZoneIterator::error_cb_cls, filter, GNUNET_NAMESTORE_ZoneIterator::finish_cb, GNUNET_NAMESTORE_ZoneIterator::finish_cb_cls, get_op_id(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_CRYPTO_write_blindable_sk_to_buffer(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_START, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_NAMESTORE_ZoneIterator::h, ZoneIterationStartMessage::key_len, LOG, GNUNET_ARM_Handle::mq, msg, GNUNET_NAMESTORE_ZoneIterator::op_id, GNUNET_NAMESTORE_ZoneIterator::proc2, GNUNET_NAMESTORE_ZoneIterator::proc_cls, and GNUNET_NAMESTORE_ZoneIterator::zone.

Referenced by namestore_get(), publish_zone_dht_start(), and run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_iterator_next()

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.

Parameters

it	the iterator
limit	number of records to return to the iterator in one shot (before GNUNET_NAMESTORE_zone_iterator_next is to be called again)

Definition at line 1505 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = it->h;
  struct ZoneIterationNextMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Sending ZONE_ITERATION_NEXT message with limit %llu\n",
       (unsigned long long) limit);
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT);
  msg->gns_header.r_id = htonl (it->op_id);
  msg->limit = GNUNET_htonll (limit);
  GNUNET_MQ_send (h->mq, env);
}

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_NEXT, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_NAMESTORE_ZoneIterator::h, LOG, GNUNET_ARM_Handle::mq, msg, and GNUNET_NAMESTORE_ZoneIterator::op_id.

Referenced by attr_iter_cb(), collect_tickets_cb(), consistency_iter(), cred_iter_cb(), display_record_iterator(), filter_tickets_cb(), handle_credential_iteration_next(), handle_iteration_next(), namestore_list_iteration(), ns_lookup_result_cb(), publish_zone_namestore_next(), purge_orphans_iterator(), purge_zone_iterator(), RECLAIM_TICKETS_iteration_next(), rvk_ticket_update(), and zone_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_iteration_stop()

void GNUNET_NAMESTORE_zone_iteration_stop

(

struct GNUNET_NAMESTORE_ZoneIterator *

it

)

Stops iteration and releases the namestore handle for further calls.

Must be called on any iteration that has not yet completed prior to calling GNUNET_NAMESTORE_disconnect.

Parameters

it	the iterator
it	the iterator

Definition at line 1528 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_Handle *h = it->h;
  struct GNUNET_MQ_Envelope *env;
  struct ZoneIterationStopMessage *msg;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending ZONE_ITERATION_STOP message\n");
  if (NULL != h->mq)
  {
    env =
      GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP);
    msg->gns_header.r_id = htonl (it->op_id);
    GNUNET_MQ_send (h->mq, env);
  }
  free_ze (it);
}

References env, free_ze(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_NAMESTORE_ZONE_ITERATION_STOP, GNUNET_MQ_msg, GNUNET_MQ_send(), h, GNUNET_NAMESTORE_ZoneIterator::h, GNUNET_ARM_Handle::mq, msg, and GNUNET_NAMESTORE_ZoneIterator::op_id.

Referenced by cleanup_adh(), cleanup_handle(), cleanup_iter(), cleanup_rvk(), do_shutdown(), filter_tickets_cb(), RECLAIM_TICKETS_iteration_stop(), reset_handles(), shutdown_task(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_monitor_start()

struct GNUNET_NAMESTORE_ZoneMonitor * GNUNET_NAMESTORE_zone_monitor_start	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_CRYPTO_BlindablePrivateKey *	zone,
		int	iterate_first,
		GNUNET_SCHEDULER_TaskCallback	error_cb,
		void *	error_cb_cls,
		GNUNET_NAMESTORE_RecordMonitor	monitor,
		void *	monitor_cls,
		GNUNET_SCHEDULER_TaskCallback	sync_cb,
		void *	sync_cb_cls
	)

Deprecated:

since 0.16.7 will be replaced in 0.18

See also

GNUNET_NAMESTORE_zone_monitor_start2()

Begin monitoring a zone for changes. Will first call the monitor function on all existing records in the selected zone(s) if iterate_first is GNUNET_YES. In any case, we will then call sync_cb, and then afterwards call the monitor whenever a record changes. If the namestore disconnects, the error_cb function is called with a disconnect event. Once the connection is re-established, the process begins from the start (depending on iterate_first, we will again first do all existing records, then sync, then updates).

Parameters

cfg	configuration to use to connect to namestore
zone	zone to monitor, NULL for all zones
iterate_first	GNUNET_YES to first iterate over all existing records, GNUNET_NO to only return changes that happen from now on
error_cb	function to call on error (i.e. disconnect); note that unlike the other error callbacks in this API, a call to this function does NOT destroy the monitor handle, it merely signals that monitoring is down. You need to still explicitly call GNUNET_NAMESTORE_zone_monitor_stop().
error_cb_cls	closure for error_cb
monitor	function to call on zone changes, with an initial limit of 1
monitor_cls	closure for monitor
sync_cb	function called when we're in sync with the namestore
sync_cb_cls	closure for sync_cb

Returns

handle to stop monitoring

Definition at line 317 of file namestore_api_monitor.c.

{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 
  zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
  if (NULL != zone)
  {
    zm->key_len = GNUNET_CRYPTO_blindable_sk_get_length (zone);
    zm->zone = *zone;
  }
  zm->iterate_first = iterate_first;
  zm->error_cb = error_cb;
  zm->error_cb_cls = error_cb_cls;
  zm->monitor = monitor;
  zm->monitor_cls = monitor_cls;
  zm->sync_cb = sync_cb;
  zm->sync_cb_cls = sync_cb_cls;
  zm->cfg = cfg;
  reconnect (zm);
  if (NULL == zm->mq)
  {
    GNUNET_free (zm);
    return NULL;
  }
  return zm;
}

References cfg, GNUNET_NAMESTORE_ZoneMonitor::cfg, error_cb(), GNUNET_NAMESTORE_ZoneMonitor::error_cb, GNUNET_NAMESTORE_ZoneMonitor::error_cb_cls, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_free, GNUNET_new, GNUNET_NAMESTORE_ZoneMonitor::iterate_first, GNUNET_NAMESTORE_ZoneMonitor::key_len, monitor, GNUNET_NAMESTORE_ZoneMonitor::monitor, GNUNET_NAMESTORE_ZoneMonitor::monitor_cls, GNUNET_NAMESTORE_ZoneMonitor::mq, reconnect(), sync_cb(), GNUNET_NAMESTORE_ZoneMonitor::sync_cb, GNUNET_NAMESTORE_ZoneMonitor::sync_cb_cls, zm, and GNUNET_NAMESTORE_ZoneMonitor::zone.

Here is the call graph for this function:

GNUNET_NAMESTORE_zone_monitor_start2()

struct GNUNET_NAMESTORE_ZoneMonitor * GNUNET_NAMESTORE_zone_monitor_start2	(	const struct GNUNET_CONFIGURATION_Handle *	cfg,
		const struct GNUNET_CRYPTO_BlindablePrivateKey *	zone,
		int	iterate_first,
		GNUNET_SCHEDULER_TaskCallback	error_cb,
		void *	error_cb_cls,
		GNUNET_NAMESTORE_RecordSetMonitor	monitor,
		void *	monitor_cls,
		GNUNET_SCHEDULER_TaskCallback	sync_cb,
		void *	sync_cb_cls,
		enum GNUNET_GNSRECORD_Filter	filter
	)

Begin monitoring a zone for changes.

Will first call the monitor function on all existing records in the selected zone(s) if iterate_first is GNUNET_YES. In any case, we will then call sync_cb, and then afterwards call the monitor whenever a record changes. If the namestore disconnects, the error_cb function is called with a disconnect event. Once the connection is re-established, the process begins from the start (depending on iterate_first, we will again first do all existing records, then sync, then updates).

Parameters

cfg	configuration to use to connect to namestore
zone	zone to monitor, NULL for all zones
iterate_first	GNUNET_YES to first iterate over all existing records, GNUNET_NO to only return changes that happen from now on
error_cb	function to call on error (i.e. disconnect); note that unlike the other error callbacks in this API, a call to this function does NOT destroy the monitor handle, it merely signals that monitoring is down. You need to still explicitly call GNUNET_NAMESTORE_zone_monitor_stop().
error_cb_cls	closure for error_cb
monitor	function to call on zone changes, with an initial limit of 1
monitor_cls	closure for monitor
sync_cb	function called when we're in sync with the namestore
sync_cb_cls	closure for sync_cb
filter	the record set filter to use

Returns

handle to stop monitoring

Definition at line 355 of file namestore_api_monitor.c.

{
  struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 
  zm = GNUNET_new (struct GNUNET_NAMESTORE_ZoneMonitor);
  if (NULL != zone)
  {
    zm->key_len = GNUNET_CRYPTO_blindable_sk_get_length (zone);
    zm->zone = *zone;
  }
  zm->iterate_first = iterate_first;
  zm->error_cb = error_cb;
  zm->error_cb_cls = error_cb_cls;
  zm->monitor2 = monitor;
  zm->monitor_cls = monitor_cls;
  zm->sync_cb = sync_cb;
  zm->sync_cb_cls = sync_cb_cls;
  zm->cfg = cfg;
  zm->filter = filter;
  reconnect (zm);
  if (NULL == zm->mq)
  {
    GNUNET_free (zm);
    return NULL;
  }
  return zm;
}

References cfg, GNUNET_NAMESTORE_ZoneMonitor::cfg, error_cb(), GNUNET_NAMESTORE_ZoneMonitor::error_cb, GNUNET_NAMESTORE_ZoneMonitor::error_cb_cls, filter, GNUNET_NAMESTORE_ZoneMonitor::filter, GNUNET_CRYPTO_blindable_sk_get_length(), GNUNET_free, GNUNET_new, GNUNET_NAMESTORE_ZoneMonitor::iterate_first, GNUNET_NAMESTORE_ZoneMonitor::key_len, monitor, GNUNET_NAMESTORE_ZoneMonitor::monitor2, GNUNET_NAMESTORE_ZoneMonitor::monitor_cls, GNUNET_NAMESTORE_ZoneMonitor::mq, reconnect(), sync_cb(), GNUNET_NAMESTORE_ZoneMonitor::sync_cb, GNUNET_NAMESTORE_ZoneMonitor::sync_cb_cls, zm, and GNUNET_NAMESTORE_ZoneMonitor::zone.

Referenced by run(), run_with_zone_pkey(), and set_handle_key().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_monitor_next()

void GNUNET_NAMESTORE_zone_monitor_next	(	struct GNUNET_NAMESTORE_ZoneMonitor *	zm,
		uint64_t	limit
	)

Calls the monitor processor specified in GNUNET_NAMESTORE_zone_monitor_start for the next record(s).

This function is used to allow clients that merely monitor the NAMESTORE to still throttle namestore operations, so we can be sure that the monitors can keep up.

Note that GNUNET_NAMESTORE_records_store() only waits for this call if the previous limit set by the client was already reached. Thus, by using a limit greater than 1, monitors basically enable a queue of notifications to be processed asynchronously with some delay. Note that even with a limit of 1 the GNUNET_NAMESTORE_records_store() function will run asynchronously and the continuation may be invoked before the monitors completed (or even started) processing the notification. Thus, monitors will only closely track the current state of the namestore, but not be involved in the transactions.

Parameters

zm	the monitor
limit	number of records to return to the iterator in one shot (before GNUNET_NAMESTORE_zone_monitor_next is to be called again)

Definition at line 416 of file namestore_api_monitor.c.

{
  struct GNUNET_MQ_Envelope *env;
  struct ZoneMonitorNextMessage *nm;
 
  env = GNUNET_MQ_msg (nm, GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT);
  nm->limit = GNUNET_htonll (limit);
  GNUNET_MQ_send (zm->mq, env);
}

References env, GNUNET_htonll(), GNUNET_MESSAGE_TYPE_NAMESTORE_MONITOR_NEXT, GNUNET_MQ_msg, GNUNET_MQ_send(), ZoneMonitorNextMessage::limit, GNUNET_NAMESTORE_ZoneMonitor::mq, and zm.

Referenced by cb_key_monitor(), cleanup_job(), display_record_monitor(), handle_monitor_event(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_zone_monitor_stop()

void GNUNET_NAMESTORE_zone_monitor_stop

(

struct GNUNET_NAMESTORE_ZoneMonitor *

zm

)

Stop monitoring a zone for changes.

Parameters

zm	handle to the monitor activity to stop

Definition at line 434 of file namestore_api_monitor.c.

{
  if (NULL != zm->mq)
  {
    GNUNET_MQ_destroy (zm->mq);
    zm->mq = NULL;
  }
  GNUNET_free (zm);
}

References GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NAMESTORE_ZoneMonitor::mq, and zm.

Referenced by destroy_handle(), reset_handles(), set_handle_key(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_NAMESTORE_record_set_edit_begin()

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.

Experimental This function is used to initiate the editing of a record set under #label. It will set the editor hint of the record set to #editor_hint. The editor hint serves as an advisory lock that is used in #GNUNET_NAMESTORE_EdtirRecordSetBeginCallback if #editor_hint differs from the currently set advisory lock in the database.

Parameters

h	handle to the namestore
pkey	the private key of the zone to edit
label	the label of the record set to edit
editor_hint	the editor hint to set as advisory lock
error_cb	the error callback
error_cb_cls	closure to error_cb
edit_cb	the GNUNET_NAMESTORE_EditRecordSetBeginCallback
edit_cb_cls	closure to #edit_cb

Returns

handle to the operation

Experimental

Definition at line 1564 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_MQ_Envelope *env;
  struct EditRecordSetMessage *msg;
  size_t label_len;
  size_t key_len;
  size_t editor_hint_len;
 
  if (1 == (label_len = strlen (label) + 1))
  {
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_assert (editor_hint != NULL);
  editor_hint_len = strlen (editor_hint) + 1;
  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
  qe->h = h;
  qe->edit_proc = edit_cb;
  qe->proc_cls = edit_cb_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 + editor_hint_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT);
  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->editor_hint_len = htons (editor_hint_len);
  GNUNET_memcpy (((char*) &msg[1]) + key_len, label, label_len);
  GNUNET_memcpy (((char*) &msg[1]) + key_len + label_len, editor_hint,
                 editor_hint_len);
  if (NULL == h->mq)
    qe->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return qe;
}

References EditRecordSetMessage::editor_hint_len, env, GNUNET_DATASTORE_QueueEntry::env, get_op_id(), GNUNET_assert, 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_SET_EDIT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_DATASTORE_QueueEntry::h, EditRecordSetMessage::key_len, EditRecordSetMessage::label_len, GNUNET_ARM_Handle::mq, msg, pkey, and qe.

Here is the call graph for this function:

GNUNET_NAMESTORE_record_set_edit_cancel()

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.

Optionally, a new editor hint can be provided: For example, the value that was returned in in the callback to GNUNET_NAMESTORE_record_set_edit_begin.

If provided editor hint does not match the current advisory lock, this function is not doing anything (NOP).

Parameters

h	handle to the namestore
pkey	the private key of the zone to edit
label	the label of the record set to edit
editor_hint	the editor hint to set as advisory lock
editor_hint_replacement	the editor hint to set as advisory lock instead of clearing it
finished_cb	the callback called when cancelled
finished_cb_cls	closure to finished_cb

Returns

handle to the operation

Definition at line 1618 of file namestore_api.c.

{
  struct GNUNET_NAMESTORE_QueueEntry *qe;
  struct GNUNET_MQ_Envelope *env;
  struct EditRecordSetCancelMessage *msg;
  size_t label_len;
  size_t key_len;
  size_t editor_hint_len;
  size_t editor_hint_replacement_len;
 
  if (1 == (label_len = strlen (label) + 1))
  {
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_assert (editor_hint != NULL);
  editor_hint_len = strlen (editor_hint) + 1;
  GNUNET_assert (editor_hint != NULL);
  editor_hint_replacement_len = strlen (editor_hint_replacement) + 1;
  qe = GNUNET_new (struct GNUNET_NAMESTORE_QueueEntry);
  qe->h = h;
  qe->op_id = get_op_id (h);
  qe->cont = finished_cb;
  qe->cont_cls = finished_cls;
  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 + editor_hint_len
                             + editor_hint_replacement_len,
                             GNUNET_MESSAGE_TYPE_NAMESTORE_RECORD_SET_EDIT_CANCEL);
  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->editor_hint_len = htons (editor_hint_len);
  msg->editor_hint_replacement_len = htons (editor_hint_replacement_len);
  GNUNET_memcpy (((char*) &msg[1]) + key_len, label, label_len);
  GNUNET_memcpy (((char*) &msg[1]) + key_len + label_len, editor_hint,
                 editor_hint_len);
  GNUNET_memcpy (((char*) &msg[1]) + key_len + label_len + editor_hint_len,
                 editor_hint_replacement,
                 editor_hint_replacement_len);
  if (NULL == h->mq)
    qe->env = env;
  else
    GNUNET_MQ_send (h->mq, env);
  return qe;
}

References GNUNET_DATASTORE_QueueEntry::cont, GNUNET_DATASTORE_QueueEntry::cont_cls, EditRecordSetCancelMessage::editor_hint_len, EditRecordSetCancelMessage::editor_hint_replacement_len, env, GNUNET_DATASTORE_QueueEntry::env, finished_cb(), get_op_id(), GNUNET_assert, 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_SET_EDIT_CANCEL, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, h, GNUNET_DATASTORE_QueueEntry::h, EditRecordSetCancelMessage::key_len, EditRecordSetCancelMessage::label_len, GNUNET_ARM_Handle::mq, msg, pkey, and qe.

Here is the call graph for this function: