gnunet-namestore.c File Reference

command line tool to manipulate the local zone More...

#include "platform.h"
#include "gnunet_common.h"
#include <gnunet_util_lib.h>
#include <gnunet_identity_service.h>
#include <gnunet_gnsrecord_lib.h>
#include <gnunet_gns_service.h>
#include <gnunet_namestore_service.h>
#include <inttypes.h>

Include dependency graph for gnunet-namestore.c:

Go to the source code of this file.

Data Structures
struct	RecordSetEntry
	Entry in record set for bulk processing. More...
struct	MarkedRecord
	The record marked for deletion. More...
struct	EgoEntry
	The default namestore ego. More...

Macros
#define	WARN_RELATIVE_EXPIRATION_LIMIT
	The upper bound for the zone iteration interval (per record).
#define	INITIAL_RI_BUFFER_SIZE   5000
#define	MAX_LINE_LEN   4086
#define	MAX_ARGS   20

Functions
static int	parse_expiration (const char *exp_str, int *is_rel, uint64_t *exptime)
	Parse expiration time.
static int	parse_recordline (const char *line)
static void	clear_recordset ()
static void	reset_handles (void)
static void	do_shutdown (void *cls)
	Task run on shutdown.
static void	process_command_stdin (void)
static void	batch_insert_recordinfo (const struct GNUNET_CONFIGURATION_Handle *cfg)
	We have obtained the zone's private key, so now process the main commands using it.
static void	finish_command (void)
static void	add_continuation (void *cls, enum GNUNET_ErrorCode ec)
static void	del_continuation (void *cls, enum GNUNET_ErrorCode ec)
static void	purge_next_record (void *cls)
static void	marked_deleted (void *cls, enum GNUNET_ErrorCode ec)
static void	zone_iteration_finished (void *cls)
	Function called when we are done with a zone iteration.
static void	zone_iteration_error_cb (void *cls)
	Function called when we encountered an error in a zone iteration.
static void	collect_zone_records_to_purge (const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
static void	collect_orphans (const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
static void	display_record (const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
	Process a record that was stored in the namestore.
static void	purge_zone_iterator (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
static void	purge_orphans_iterator (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
static void	display_record_iterator (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
	Process a record that was stored in the namestore.
static void	display_record_monitor (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd, struct GNUNET_TIME_Absolute expiry)
	Process a record that was stored in the namestore.
static void	display_record_lookup (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
	Process a record that was stored in the namestore.
static void	sync_cb (void *cls)
	Function called once we are in sync in monitor mode.
static void	monitor_error_cb (void *cls)
	Function called on errors while monitoring.
static void	lookup_error_cb (void *cls)
	Function called on errors while monitoring.
static void	add_error_cb (void *cls)
	Function called if lookup fails.
static void	get_existing_record (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key, const char *rec_name, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	We're storing a record; this function is given the existing record so that we can merge the information.
static void	reverse_error_cb (void *cls)
	Function called if we encountered an error in zone-to-name.
static void	handle_reverse_lookup (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Function called with the result of our attempt to obtain a name for a given public key.
static void	del_lookup_error_cb (void *cls)
	Function called if lookup for deletion fails.
static void	del_monitor (void *cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *zone, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	We were asked to delete something; this function is called with the existing records.
static void	schedule_finish (void *cls)
static void	replace_cont (void *cls, enum GNUNET_ErrorCode ec)
static void	run_with_zone_pkey (const struct GNUNET_CONFIGURATION_Handle *cfg_)
	We have obtained the zone's private key, so now process the main commands using it.
static int	get_identity_for_string (const char *str, struct GNUNET_CRYPTO_BlindablePrivateKey *zk)
static void	id_connect_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *ego_name_tmp)
	Function called with ALL of the egos known to the identity service, used on startup if the user did not specify a zone on the command-line.
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *_cfg)
	Main function that will be run.
int	main (int argc, char *const *argv)
	The main function for gnunet-namestore.

Variables
static struct GNUNET_NAMESTORE_Handle *	ns
	Handle to the namestore.
static struct GNUNET_CRYPTO_BlindablePrivateKey	zone_pkey
	Private key for the our zone.
static struct GNUNET_IDENTITY_Handle *	idh
	Identity service handle.
static char *	ego_name
	Name of the ego controlling the zone.
static struct GNUNET_NAMESTORE_QueueEntry *	add_qe_uri
	Queue entry for the 'add-uri' operation.
static struct GNUNET_NAMESTORE_QueueEntry *	add_qe
	Queue entry for the 'add' operation.
static struct GNUNET_NAMESTORE_QueueEntry *	get_qe
	Queue entry for the 'lookup' operation.
static struct GNUNET_NAMESTORE_QueueEntry *	reverse_qe
	Queue entry for the 'reverse lookup' operation (in combination with a name).
static struct MarkedRecord *	marked_head
	Marked record list.
static struct MarkedRecord *	marked_tail
	Marked record list.
const struct GNUNET_CONFIGURATION_Handle *	cfg
	Configuration handle.
static struct EgoEntry *	ego_head
	Ego list.
static struct EgoEntry *	ego_tail
	Ego list.
static struct GNUNET_NAMESTORE_ZoneIterator *	list_it
	List iterator for the 'list' operation.
static int	read_from_stdin
	Run in read from stdin mode.
static int	list
	Desired action is to list records.
static int	add
	Desired action is to add a record.
static int	del
	Desired action is to remove a record.
static int	is_public
	Is record public (opposite of GNUNET_GNSRECORD_RF_PRIVATE)
static int	is_shadow
	Is record a shadow record (GNUNET_GNSRECORD_RF_SHADOW)
static int	is_maintenance
	Is record a maintenance record (GNUNET_GNSRECORD_RF_MAINTENANCE)
static int	omit_private
	Filter private records.
static int	output_recordline
	Output in recordline format.
static int	purge_zone
	Purge zone contents.
static int	include_maintenance
	Do not filter maintenance records.
static int	purge_orphaned
	Purge orphaned records.
static int	list_orphaned
	List records and zone keys of orphaned records.
static struct GNUNET_NAMESTORE_QueueEntry *	del_qe
	Queue entry for the 'del' operation.
static struct GNUNET_NAMESTORE_QueueEntry *	set_qe
	Queue entry for the 'set/replace' operation.
static struct GNUNET_NAMESTORE_QueueEntry *	ns_qe
	Queue entry for begin/commit.
static char *	name
	Name of the records to add/list/remove.
static char *	value
	Value of the record to add/remove.
static char *	uri
	URI to import.
static char *	reverse_pkey
	Reverse lookup to perform.
static char *	typestring
	Type of the record to add/remove, NULL to remove all.
static char *	expirationstring
	Desired expiration time.
static char *	nickstring
	Desired nick name.
static int	ret
	Global return value.
static uint32_t	type
	Type string converted to DNS type value.
static void *	data
	Value in binary format.
static size_t	data_size
	Number of bytes in data.
static uint64_t	etime
	Expiration string converted to numeric value.
static int	etime_is_rel = GNUNET_SYSERR
	Is expiration time relative or absolute time?
static struct GNUNET_NAMESTORE_ZoneMonitor *	zm
	Monitor handle.
static int	monitor
	Enables monitor mode.
static struct RecordSetEntry *	recordset
	Entry in record set for processing records in bulk.
static struct GNUNET_SCHEDULER_Task *	purge_task
	Purge task.
static unsigned int	ri_count = 0
static struct GNUNET_NAMESTORE_RecordInfo *	record_info
static unsigned int	record_info_capacity = 0
	Maximum capacity of record_info array.
static unsigned int	max_batch_size = 1000
static unsigned int	ri_sent = 0

Detailed Description

command line tool to manipulate the local zone

Author

Christian Grothoff

TODO:

• test

Definition in file gnunet-namestore.c.

Macro Definition Documentation

WARN_RELATIVE_EXPIRATION_LIMIT

#define WARN_RELATIVE_EXPIRATION_LIMIT

Value:

          GNUNET_TIME_relative_multiply ( \
          GNUNET_TIME_UNIT_MINUTES, 15)

The upper bound for the zone iteration interval (per record).

Definition at line 41 of file gnunet-namestore.c.

{
  struct RecordSetEntry *next;
 
  struct GNUNET_GNSRECORD_Data record;
};
 
struct MarkedRecord
{
  struct MarkedRecord *next;
 
  struct MarkedRecord *prev;
 
  char *name;
 
  struct GNUNET_CRYPTO_BlindablePrivateKey key;
};
 
struct EgoEntry
{
  struct EgoEntry *next;
 
  struct EgoEntry *prev;
 
  char *identifier;
 
  struct GNUNET_IDENTITY_Ego *ego;
};
 
static struct GNUNET_NAMESTORE_Handle *ns;
 
static struct GNUNET_CRYPTO_BlindablePrivateKey zone_pkey;
 
static struct GNUNET_IDENTITY_Handle *idh;
 
static char *ego_name;
 
static struct GNUNET_NAMESTORE_QueueEntry *add_qe_uri;
 
static struct GNUNET_NAMESTORE_QueueEntry *add_qe;
 
static struct GNUNET_NAMESTORE_QueueEntry *get_qe;
 
static struct GNUNET_NAMESTORE_QueueEntry *reverse_qe;
 
static struct MarkedRecord *marked_head;
 
static struct MarkedRecord *marked_tail;
 
const struct GNUNET_CONFIGURATION_Handle *cfg;
 
static struct EgoEntry *ego_head;
 
static struct EgoEntry *ego_tail;
 
static struct GNUNET_NAMESTORE_ZoneIterator *list_it;
 
static int read_from_stdin;
 
static int list;
 
static int add;
 
static int del;
 
static int is_public;
 
static int is_shadow;
 
static int is_maintenance;
 
static int omit_private;
 
static int output_recordline;
 
 
static int purge_zone;
 
static int include_maintenance;
 
static int purge_orphaned;
 
static int list_orphaned;
 
static struct GNUNET_NAMESTORE_QueueEntry *del_qe;
 
static struct GNUNET_NAMESTORE_QueueEntry *set_qe;
 
static struct GNUNET_NAMESTORE_QueueEntry *ns_qe;
 
static char *name;
 
static char *value;
 
static char *uri;
 
static char *reverse_pkey;
 
static char *typestring;
 
static char *expirationstring;
 
static char *nickstring;
 
static int ret;
 
static uint32_t type;
 
static void *data;
 
static size_t data_size;
 
static uint64_t etime;
 
static int etime_is_rel = GNUNET_SYSERR;
 
static struct GNUNET_NAMESTORE_ZoneMonitor *zm;
 
static int monitor;
 
static struct RecordSetEntry *recordset;
 
static struct GNUNET_SCHEDULER_Task *purge_task;
 
/* FIXME: Make array and grow as needed */
#define INITIAL_RI_BUFFER_SIZE 5000
 
static unsigned int ri_count = 0;
 
static struct GNUNET_NAMESTORE_RecordInfo *record_info;
 
static unsigned int record_info_capacity = 0;
 
/* How many records to put simulatneously */
static unsigned int max_batch_size = 1000;
 
static int
parse_expiration (const char *exp_str,
                  int *is_rel,
                  uint64_t *exptime)
{
  struct GNUNET_TIME_Relative etime_rel;
  struct GNUNET_TIME_Absolute etime_abs;
 
  if (0 == strcmp (exp_str, "never"))
  {
    *exptime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
    *is_rel = GNUNET_NO;
    return GNUNET_OK;
  }
  if (GNUNET_OK ==
      GNUNET_STRINGS_fancy_time_to_relative (exp_str, &etime_rel))
  {
    *is_rel = GNUNET_YES;
    *exptime = etime_rel.rel_value_us;
    if (GNUNET_TIME_relative_cmp (etime_rel, <, WARN_RELATIVE_EXPIRATION_LIMIT))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Relative expiration times of less than %s are not recommended. To improve availability, consider increasing this value.\n",
                  GNUNET_STRINGS_relative_time_to_string (
                    WARN_RELATIVE_EXPIRATION_LIMIT, GNUNET_NO));
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Storing record with relative expiration time of %s\n",
                GNUNET_STRINGS_relative_time_to_string (etime_rel, GNUNET_NO));
    return GNUNET_OK;
  }
  if (GNUNET_OK ==
      GNUNET_STRINGS_fancy_time_to_absolute (exp_str, &etime_abs))
  {
    *is_rel = GNUNET_NO;
    *exptime = etime_abs.abs_value_us;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Storing record with absolute expiration time of %s\n",
                GNUNET_STRINGS_absolute_time_to_string (etime_abs));
    return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}
 
 
static int
parse_recordline (const char *line)
{
  struct RecordSetEntry *r;
  struct GNUNET_GNSRECORD_Data record;
  char *cp;
  char *tok;
  char *saveptr;
  void *raw_data;
 
  cp = GNUNET_strdup (line);
  tok = strtok_r (cp, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Missing entries in record line `%s'.\n"),
                line);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  record.record_type = GNUNET_GNSRECORD_typename_to_number (tok);
  if (UINT32_MAX == record.record_type)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Unknown record type `%s'\n"), tok);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  tok = strtok_r (NULL, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Empty record line argument is not allowed.\n"));
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  if (1 != sscanf (tok, "%" SCNu64, &record.expiration_time))
  {
    fprintf (stderr,
             _ ("Error parsing expiration time %s.\n"), tok);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  tok = strtok_r (NULL, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Empty record line argument is not allowed.\n"));
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  record.flags = GNUNET_GNSRECORD_RF_NONE;
  if (NULL != strchr (tok, (unsigned char) 'r'))
    record.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
  if (NULL == strchr (tok, (unsigned char) 'p')) /* p = public */
    record.flags |= GNUNET_GNSRECORD_RF_PRIVATE;
  if (NULL != strchr (tok, (unsigned char) 'S'))
    record.flags |= GNUNET_GNSRECORD_RF_SUPPLEMENTAL;
  if (NULL != strchr (tok, (unsigned char) 's'))
    record.flags |= GNUNET_GNSRECORD_RF_SHADOW;
  if (NULL != strchr (tok, (unsigned char) 'C'))
    record.flags |= GNUNET_GNSRECORD_RF_CRITICAL;
  tok += strlen (tok) + 1;
  if (GNUNET_OK != GNUNET_GNSRECORD_string_to_value (record.record_type,
                                                     tok,
                                                     &raw_data,
                                                     &record.data_size))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Invalid record data for type %s: `%s'.\n"),
                GNUNET_GNSRECORD_number_to_typename (record.record_type),
                tok);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  GNUNET_free (cp);
 
  r = GNUNET_malloc (sizeof(struct RecordSetEntry) + record.data_size);
  r->next = recordset;
  record.data = &r[1];
  memcpy (&r[1], raw_data, record.data_size);
  GNUNET_free (raw_data);
  r->record = record;
  recordset = r;
  return GNUNET_OK;
}
 
 
static void
clear_recordset ()
{
  struct RecordSetEntry *rs_entry;
 
  while (NULL != (rs_entry = recordset))
  {
    recordset = recordset->next;
    GNUNET_free (rs_entry);
  }
  recordset = NULL;
}
 
 
static void
reset_handles (void)
{
  struct MarkedRecord *mrec;
  struct MarkedRecord *mrec_tmp;
  clear_recordset ();
  if (NULL != ego_name)
  {
    GNUNET_free (ego_name);
    ego_name = NULL;
  }
  if (NULL != name)
  {
    GNUNET_free (name);
    name = NULL;
  }
  if (NULL != value)
  {
    GNUNET_free (value);
    value = NULL;
  }
  if (NULL != uri)
  {
    GNUNET_free (uri);
    uri = NULL;
  }
  if (NULL != expirationstring)
  {
    GNUNET_free (expirationstring);
    expirationstring = NULL;
  }
  if (NULL != purge_task)
  {
    GNUNET_SCHEDULER_cancel (purge_task);
    purge_task = NULL;
  }
  for (mrec = marked_head; NULL != mrec;)
  {
    mrec_tmp = mrec;
    mrec = mrec->next;
    GNUNET_free (mrec_tmp->name);
    GNUNET_free (mrec_tmp);
  }
  if (NULL != list_it)
  {
    GNUNET_NAMESTORE_zone_iteration_stop (list_it);
    list_it = NULL;
  }
  if (NULL != add_qe)
  {
    GNUNET_NAMESTORE_cancel (add_qe);
    add_qe = NULL;
  }
  if (NULL != set_qe)
  {
    GNUNET_NAMESTORE_cancel (set_qe);
    set_qe = NULL;
  }
  if (NULL != add_qe_uri)
  {
    GNUNET_NAMESTORE_cancel (add_qe_uri);
    add_qe_uri = NULL;
  }
  if (NULL != get_qe)
  {
    GNUNET_NAMESTORE_cancel (get_qe);
    get_qe = NULL;
  }
  if (NULL != del_qe)
  {
    GNUNET_NAMESTORE_cancel (del_qe);
    del_qe = NULL;
  }
  if (NULL != reverse_qe)
  {
    GNUNET_NAMESTORE_cancel (reverse_qe);
    reverse_qe = NULL;
  }
  memset (&zone_pkey, 0, sizeof(zone_pkey));
  if (NULL != zm)
  {
    GNUNET_NAMESTORE_zone_monitor_stop (zm);
    zm = NULL;
  }
  if (NULL != data)
  {
    GNUNET_free (data);
    data = NULL;
  }
  if (NULL != typestring)
  {
    GNUNET_free (typestring);
    typestring = NULL;
  }
  list = 0;
  is_public = 0;
  is_shadow = 0;
  is_maintenance = 0;
  purge_zone = 0;
}
 
 
static void
do_shutdown (void *cls)
{
  struct EgoEntry *ego_entry;
  struct EgoEntry *ego_tmp;
  (void) cls;
 
  reset_handles ();
  if (NULL != record_info)
    GNUNET_free (record_info);
  record_info = NULL;
  if (NULL != ns_qe)
  {
    GNUNET_NAMESTORE_cancel (ns_qe);
    ns_qe = NULL;
  }
  if (NULL != ns)
  {
    GNUNET_NAMESTORE_disconnect (ns);
    ns = NULL;
  }
  if (NULL != idh)
  {
    GNUNET_IDENTITY_disconnect (idh);
    idh = NULL;
  }
  for (ego_entry = ego_head; NULL != ego_entry;)
  {
    ego_tmp = ego_entry;
    ego_entry = ego_entry->next;
    GNUNET_free (ego_tmp->identifier);
    GNUNET_free (ego_tmp);
  }
}
 
 
static void
process_command_stdin (void);
 
static unsigned int ri_sent = 0;
 
static void
batch_insert_recordinfo (const struct GNUNET_CONFIGURATION_Handle *cfg);
 
static void
finish_command (void)
{
  // if (ri_sent < ri_count)
  // {
  //  batch_insert_recordinfo (cfg);
  //  return;
  // }
  // reset_handles ();
  if (read_from_stdin)
  {
    process_command_stdin ();
    return;
  }
  GNUNET_SCHEDULER_shutdown ();
}
 
 
static void
add_continuation (void *cls, enum GNUNET_ErrorCode ec)
{
  struct GNUNET_NAMESTORE_QueueEntry **qe = cls;
 
  *qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr,
             _ ("Adding record failed: %s\n"),
             GNUNET_ErrorCode_get_hint (ec));
    if (GNUNET_EC_NAMESTORE_RECORD_EXISTS != ec)
      ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  ret = 0;
  finish_command ();
}
 
 
static void
del_continuation (void *cls, enum GNUNET_ErrorCode ec)
{
  (void) cls;
  del_qe = NULL;
  if (GNUNET_EC_NAMESTORE_RECORD_NOT_FOUND == ec)
  {
    fprintf (stderr,
             _ ("Deleting record failed: %s\n"), GNUNET_ErrorCode_get_hint (
               ec));
  }
  finish_command ();
}
 
 
static void
purge_next_record (void *cls);
 
static void
marked_deleted (void *cls, enum GNUNET_ErrorCode ec)
{
  del_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr,
             _ ("Deleting record failed: %s\n"),
             GNUNET_ErrorCode_get_hint (ec));
  }
  purge_task = GNUNET_SCHEDULER_add_now (&purge_next_record, NULL);
}
 
 
static void
purge_next_record (void *cls)
{
  struct MarkedRecord *mrec;
  purge_task = NULL;
 
  if (NULL == marked_head)
  {
    ret = 0;
    finish_command ();
    return;
  }
  mrec = marked_head;
  GNUNET_CONTAINER_DLL_remove (marked_head,
                               marked_tail,
                               mrec);
  del_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                              &mrec->key,
                                              mrec->name,
                                              0, NULL,
                                              &marked_deleted,
                                              NULL);
  GNUNET_free (mrec->name);
  GNUNET_free (mrec);
}
 
 
static void
zone_iteration_finished (void *cls)
{
  (void) cls;
  list_it = NULL;
  if (purge_orphaned || purge_zone)
  {
    purge_task = GNUNET_SCHEDULER_add_now (&purge_next_record, NULL);
    return;
  }
  ret = 0;
  finish_command ();
}
 
 
static void
zone_iteration_error_cb (void *cls)
{
  (void) cls;
  list_it = NULL;
  fprintf (stderr, "Error iterating over zone\n");
  ret = 1;
  finish_command ();
}
 
 
static void
collect_zone_records_to_purge (const struct
                               GNUNET_CRYPTO_BlindablePrivateKey *zone_key,
                               const char *rname,
                               unsigned int rd_len,
                               const struct GNUNET_GNSRECORD_Data *rd)
{
  struct MarkedRecord *mrec;
 
  mrec = GNUNET_new (struct MarkedRecord);
  mrec->key = *zone_key;
  mrec->name = GNUNET_strdup (rname);
  GNUNET_CONTAINER_DLL_insert (marked_head,
                               marked_tail,
                               mrec);
}
 
 
static void
collect_orphans (const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key,
                 const char *rname,
                 unsigned int rd_len,
                 const struct GNUNET_GNSRECORD_Data *rd)
{
  struct EgoEntry *ego;
  struct MarkedRecord *orphan;
  int is_orphaned = 1;
 
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == memcmp (GNUNET_IDENTITY_ego_get_private_key (ego->ego),
                     zone_key,
                     sizeof (*zone_key)))
    {
      is_orphaned = 0;
      break;
    }
  }
  if (is_orphaned)
  {
    orphan = GNUNET_new (struct MarkedRecord);
    orphan->key = *zone_key;
    orphan->name = GNUNET_strdup (rname);
    GNUNET_CONTAINER_DLL_insert (marked_head,
                                 marked_tail,
                                 orphan);
  }
}
 
 
static void
display_record (const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key,
                const char *rname,
                unsigned int rd_len,
                const struct GNUNET_GNSRECORD_Data *rd)
{
  const char *typestr;
  char *s;
  const char *ets;
  struct GNUNET_TIME_Absolute at;
  struct GNUNET_TIME_Relative rt;
  struct EgoEntry *ego;
  int have_record;
  int is_orphaned = 1;
  char *orphaned_str;
 
  if ((NULL != name) && (0 != strcmp (name, rname)))
    return;
  have_record = GNUNET_NO;
  for (unsigned int i = 0; i < rd_len; i++)
  {
    if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
        (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
      continue;
    if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
      continue;
    have_record = GNUNET_YES;
    break;
  }
  if (GNUNET_NO == have_record)
    return;
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == memcmp (GNUNET_IDENTITY_ego_get_private_key (ego->ego),
                     zone_key,
                     sizeof (*zone_key)))
    {
      is_orphaned = 0;
      break;
    }
  }
  if (list_orphaned && ! is_orphaned)
    return;
  if (! list_orphaned && is_orphaned)
    return;
  orphaned_str = GNUNET_CRYPTO_blindable_private_key_to_string (zone_key);
  fprintf (stdout, "%s.%s:\n", rname, is_orphaned ? orphaned_str :
           ego->identifier);
  GNUNET_free (orphaned_str);
  if (NULL != typestring)
    type = GNUNET_GNSRECORD_typename_to_number (typestring);
  else
    type = GNUNET_GNSRECORD_TYPE_ANY;
  for (unsigned int i = 0; i < rd_len; i++)
  {
    if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
        (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
      continue;
    if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
      continue;
    typestr = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type);
    s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                          rd[i].data,
                                          rd[i].data_size);
    if (NULL == s)
    {
      fprintf (stdout,
               _ ("\tCorrupt or unsupported record of type %u\n"),
               (unsigned int) rd[i].record_type);
      continue;
    }
    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      rt.rel_value_us = rd[i].expiration_time;
      ets = GNUNET_STRINGS_relative_time_to_string (rt, GNUNET_YES);
    }
    else
    {
      at.abs_value_us = rd[i].expiration_time;
      ets = GNUNET_STRINGS_absolute_time_to_string (at);
    }
    {
      char flgstr[16];
      sprintf (flgstr, "[%s%s%s%s%s]",
               (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE) ? "" : "p",
               (rd[i].flags & GNUNET_GNSRECORD_RF_SUPPLEMENTAL) ? "S" : "",
               (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION) ? "r" :
               "",
               (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW) ? "S" : "",
               (rd[i].flags & GNUNET_GNSRECORD_RF_CRITICAL) ? "C" : "");
      if (output_recordline)
        fprintf (stdout,
                 "  %s %" PRIu64 " %s %s\n",
                 typestr,
                 rd[i].expiration_time,
                 flgstr,
                 s);
      else
        fprintf (stdout,
                 "\t%s: %s (%s)\t%s\t%s\t%s\n",
                 typestr,
                 s,
                 ets,
                 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE"
             : "PUBLIC",
                 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW)) ? "SHADOW"
               : "",
                 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_MAINTENANCE)) ?
                 "MAINTENANCE"
             : "");
      GNUNET_free (s);
    }
  }
  // fprintf (stdout, "%s", "\n");
}
 
 
static void
purge_zone_iterator (void *cls,
                     const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key,
                     const char *rname,
                     unsigned int rd_len,
                     const struct GNUNET_GNSRECORD_Data *rd,
                     struct GNUNET_TIME_Absolute expiry)
{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  collect_zone_records_to_purge (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
}
 
 
static void
purge_orphans_iterator (void *cls,
                        const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key
                        ,
                        const char *rname,
                        unsigned int rd_len,
                        const struct GNUNET_GNSRECORD_Data *rd,
                        struct GNUNET_TIME_Absolute expiry)
{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  collect_orphans (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
}
 
 
static void
display_record_iterator (void *cls,
                         const struct GNUNET_CRYPTO_BlindablePrivateKey *
                         zone_key,
                         const char *rname,
                         unsigned int rd_len,
                         const struct GNUNET_GNSRECORD_Data *rd,
                         struct GNUNET_TIME_Absolute expiry)
{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  display_record (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
}
 
 
static void
display_record_monitor (void *cls,
                        const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key
                        ,
                        const char *rname,
                        unsigned int rd_len,
                        const struct GNUNET_GNSRECORD_Data *rd,
                        struct GNUNET_TIME_Absolute expiry)
{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  display_record (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_monitor_next (zm, 1);
}
 
 
static void
display_record_lookup (void *cls,
                       const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key,
                       const char *rname,
                       unsigned int rd_len,
                       const struct GNUNET_GNSRECORD_Data *rd)
{
  (void) cls;
  (void) zone_key;
  get_qe = NULL;
  display_record (zone_key, rname, rd_len, rd);
  finish_command ();
}
 
 
static void
sync_cb (void *cls)
{
  (void) cls;
  fprintf (stdout, "%s", "Monitor is now in sync.\n");
}
 
 
static void
monitor_error_cb (void *cls)
{
  (void) cls;
  fprintf (stderr, "%s", "Monitor disconnected and out of sync.\n");
}
 
 
static void
lookup_error_cb (void *cls)
{
  (void) cls;
  get_qe = NULL;
  fprintf (stderr, "%s", "Failed to lookup record.\n");
  finish_command ();
}
 
 
static void
add_error_cb (void *cls)
{
  (void) cls;
  add_qe = NULL;
  GNUNET_break (0);
  ret = 1;
  finish_command ();
}
 
 
static void
get_existing_record (void *cls,
                     const struct GNUNET_CRYPTO_BlindablePrivateKey *zone_key,
                     const char *rec_name,
                     unsigned int rd_count,
                     const struct GNUNET_GNSRECORD_Data *rd)
{
  struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
  struct GNUNET_GNSRECORD_Data *rde;
 
  (void) cls;
  (void) zone_key;
  add_qe = NULL;
  if (0 != strcmp (rec_name, name))
  {
    GNUNET_break (0);
    ret = 1;
    finish_command ();
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u records for name `%s'\n",
              rd_count,
              rec_name);
  for (unsigned int i = 0; i < rd_count; i++)
  {
    switch (rd[i].record_type)
    {
    case GNUNET_DNSPARSER_TYPE_SOA:
      if (GNUNET_DNSPARSER_TYPE_SOA == type)
      {
        fprintf (
          stderr,
          _ (
            "A SOA record exists already under `%s', cannot add a second SOA to the same zone.\n"),
          rec_name);
        ret = 1;
        finish_command ();
        return;
      }
      break;
    }
  }
  memset (rdn, 0, sizeof(struct GNUNET_GNSRECORD_Data));
  GNUNET_memcpy (&rdn[1], rd, rd_count * sizeof(struct GNUNET_GNSRECORD_Data));
  rde = &rdn[0];
  rde->data = data;
  rde->data_size = data_size;
  rde->record_type = type;
  if (1 == is_shadow)
    rde->flags |= GNUNET_GNSRECORD_RF_SHADOW;
  if (1 == is_maintenance)
    rde->flags |= GNUNET_GNSRECORD_RF_MAINTENANCE;
  if (1 != is_public)
    rde->flags |= GNUNET_GNSRECORD_RF_PRIVATE;
  rde->expiration_time = etime;
  if (GNUNET_YES == etime_is_rel)
    rde->flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
  else if (GNUNET_NO != etime_is_rel)
    rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
  GNUNET_assert (NULL != name);
  add_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                              &zone_pkey,
                                              name,
                                              rd_count + 1,
                                              rde,
                                              &add_continuation,
                                              &add_qe);
}
 
 
static void
reverse_error_cb (void *cls)
{
  (void) cls;
  reverse_qe = NULL;
  fprintf (stdout, "%s.zkey\n", reverse_pkey);
}
 
 
static void
handle_reverse_lookup (void *cls,
                       const struct GNUNET_CRYPTO_BlindablePrivateKey *zone,
                       const char *label,
                       unsigned int rd_count,
                       const struct GNUNET_GNSRECORD_Data *rd)
{
  (void) cls;
  (void) zone;
  (void) rd_count;
  (void) rd;
  reverse_qe = NULL;
  if (NULL == label)
    fprintf (stdout, "%s\n", reverse_pkey);
  else
    fprintf (stdout, "%s.%s\n", label, ego_name);
  finish_command ();
}
 
 
static void
del_lookup_error_cb (void *cls)
{
  (void) cls;
  del_qe = NULL;
  GNUNET_break (0);
  ret = 1;
  finish_command ();
}
 
 
static void
del_monitor (void *cls,
             const struct GNUNET_CRYPTO_BlindablePrivateKey *zone,
             const char *label,
             unsigned int rd_count,
             const struct GNUNET_GNSRECORD_Data *rd)
{
  struct GNUNET_GNSRECORD_Data rdx[rd_count];
  unsigned int rd_left;
  uint32_t del_type;
  char *vs;
 
  (void) cls;
  (void) zone;
  del_qe = NULL;
  if (0 == rd_count)
  {
    fprintf (stderr,
             _ (
               "There are no records under label `%s' that could be deleted.\n")
             ,
             label);
    ret = 1;
    finish_command ();
    return;
  }
  if ((NULL == value) && (NULL == typestring))
  {
    /* delete everything */
    del_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                                &zone_pkey,
                                                name,
                                                0,
                                                NULL,
                                                &del_continuation,
                                                NULL);
    return;
  }
  rd_left = 0;
  if (NULL != typestring)
    del_type = GNUNET_GNSRECORD_typename_to_number (typestring);
  else
    del_type = GNUNET_GNSRECORD_TYPE_ANY;
  for (unsigned int i = 0; i < rd_count; i++)
  {
    vs = NULL;
    if (! (((GNUNET_GNSRECORD_TYPE_ANY == del_type) ||
            (rd[i].record_type == del_type)) &&
           ((NULL == value) ||
            (NULL ==
             (vs = (GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                                      rd[i].data,
                                                      rd[i].data_size)))) ||
            (0 == strcmp (vs, value)))))
      rdx[rd_left++] = rd[i];
    GNUNET_free (vs);
  }
  if (rd_count == rd_left)
  {
    /* nothing got deleted */
    fprintf (
      stderr,
      _ (
        "There are no records under label `%s' that match the request for deletion.\n"),
      label);
    finish_command ();
    return;
  }
  /* delete everything but what we copied to 'rdx' */
  del_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                              &zone_pkey,
                                              name,
                                              rd_left,
                                              rdx,
                                              &del_continuation,
                                              NULL);
}
 
 
static void
schedule_finish (void*cls)
{
  finish_command ();
}
 
 
static void
replace_cont (void *cls, enum GNUNET_ErrorCode ec)
{
  (void) cls;
 
  set_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                _ ("%s\n"),
                GNUNET_ErrorCode_get_hint (ec));
    ret = 1;   /* fail from 'main' */
  }
  GNUNET_SCHEDULER_add_now (&schedule_finish, NULL);
}
 
 
static void
batch_insert_recordinfo (const struct GNUNET_CONFIGURATION_Handle *batch_cfg)
{
  unsigned int sent_here;
 
  GNUNET_assert (0 != ri_count);
  set_qe = GNUNET_NAMESTORE_records_store (ns,
                                           &zone_pkey,
                                           ri_count - ri_sent,
                                           record_info + ri_sent,
                                           &sent_here,
                                           &replace_cont,
                                           NULL);
  ri_sent += sent_here;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent %d/%d record infos\n", ri_sent,
              ri_count);
  if (ri_sent == ri_count)
  {
    for (int i = 0; i < ri_count; i++)
    {
      GNUNET_free (record_info[i].a_rd);
      record_info[i].a_rd = NULL;
    }
    ri_count = 0;
    ri_sent = 0;
  }
  return;
}
 
 
static void
run_with_zone_pkey (const struct GNUNET_CONFIGURATION_Handle *cfg_)
{
  struct GNUNET_GNSRECORD_Data rd;
  enum GNUNET_GNSRECORD_Filter filter_flags = GNUNET_GNSRECORD_FILTER_NONE;
 
  if (omit_private)
    filter_flags |= GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE;
  if (include_maintenance)
    filter_flags |= GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE;
  if (! (add | del | list | (NULL != nickstring) | (NULL != uri)
         | (NULL != reverse_pkey) | (NULL != recordset) | (monitor)
         | (purge_orphaned) | (list_orphaned) | (purge_zone)) )
  {
    /* nothing more to be done */
    fprintf (stderr, _ ("No options given\n"));
    finish_command ();
    return;
  }
 
  if (NULL != recordset)
  {
    /* replace entire record set */
    unsigned int rd_count;
    struct GNUNET_GNSRECORD_Data *rd_tmp;
 
    /* FIXME: We could easily support append and delete with this as well */
    if (! add)
    {
      fprintf (stderr, _ ("Recordlines only work with option `%s'\n"),
               "-a");
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("name"));
      ret = 1;
      finish_command ();
      return;
    }
    rd_count = 0;
    for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
      rd_count++;
    rd_tmp = GNUNET_new_array (rd_count, struct GNUNET_GNSRECORD_Data);
    rd_count = 0;
    for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
    {
      rd_tmp[rd_count] = e->record;
      rd_count++;
    }
    set_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                                &zone_pkey,
                                                name,
                                                rd_count,
                                                rd_tmp,
                                                &replace_cont,
                                                NULL);
    GNUNET_free (rd_tmp);
    return;
  }
  if (NULL != nickstring)
  {
    if (0 == strlen (nickstring))
    {
      fprintf (stderr, _ ("Invalid nick `%s'\n"), nickstring);
      ret = 1;
      finish_command ();
      return;
    }
    add = 1;
    typestring = GNUNET_strdup (GNUNET_GNSRECORD_number_to_typename (
                                  GNUNET_GNSRECORD_TYPE_NICK));
    name = GNUNET_strdup (GNUNET_GNS_EMPTY_LABEL_AT);
    value = GNUNET_strdup (nickstring);
    is_public = 0;
    expirationstring = GNUNET_strdup ("never");
    GNUNET_free (nickstring);
    nickstring = NULL;
  }
 
  if (add)
  {
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == typestring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-t",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    type = GNUNET_GNSRECORD_typename_to_number (typestring);
    if (UINT32_MAX == type)
    {
      fprintf (stderr, _ ("Unsupported type `%s'\n"), typestring);
      ret = 1;
      finish_command ();
      return;
    }
    if ((GNUNET_DNSPARSER_TYPE_SRV == type) ||
        (GNUNET_DNSPARSER_TYPE_TLSA == type) ||
        (GNUNET_DNSPARSER_TYPE_SMIMEA == type) ||
        (GNUNET_DNSPARSER_TYPE_OPENPGPKEY == type))
    {
      fprintf (stderr,
               _ (
                 "For DNS record types `SRV', `TLSA', `SMIMEA' and `OPENPGPKEY'"));
      fprintf (stderr, ", please use a `BOX' record instead\n");
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == value)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-V",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_string_to_value (type, value, &data, &data_size))
    {
      fprintf (stderr,
               _ ("Value `%s' invalid for record type `%s'\n"),
               value,
               typestring);
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == expirationstring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-e",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK != parse_expiration (expirationstring, &etime_is_rel, &etime))
    {
      fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
      ret = 1;
      finish_command ();
      return;
    }
    add_qe = GNUNET_NAMESTORE_records_lookup (ns,
                                              &zone_pkey,
                                              name,
                                              &add_error_cb,
                                              NULL,
                                              &get_existing_record,
                                              NULL);
  }
  if (del)
  {
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("del"));
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("del"));
      ret = 1;
      finish_command ();
      return;
    }
    del_qe = GNUNET_NAMESTORE_records_lookup2 (ns,
                                               &zone_pkey,
                                               name,
                                               &del_lookup_error_cb,
                                               NULL,
                                               &del_monitor,
                                               NULL,
                                               filter_flags);
  }
  if (purge_orphaned)
  {
    list_it = GNUNET_NAMESTORE_zone_iteration_start2 (ns,
                                                      NULL,
                                                      &zone_iteration_error_cb,
                                                      NULL,
                                                      &purge_orphans_iterator,
                                                      NULL,
                                                      &zone_iteration_finished,
                                                      NULL,
                                                      filter_flags);
 
  }
  else if (purge_zone)
  {
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("purge-zone"));
      ret = 1;
      finish_command ();
      return;
    }
    list_it = GNUNET_NAMESTORE_zone_iteration_start2 (ns,
                                                      &zone_pkey,
                                                      &zone_iteration_error_cb,
                                                      NULL,
                                                      &purge_zone_iterator,
                                                      NULL,
                                                      &zone_iteration_finished,
                                                      NULL,
                                                      filter_flags);
 
  }
  else if (list || list_orphaned)
  {
    if (NULL != name)
    {
      if (NULL == ego_name)
      {
        fprintf (stderr,
                 _ ("Missing option `%s' for operation `%s'\n"),
                 "-z",
                 _ ("list"));
        ret = 1;
        finish_command ();
        return;
      }
      get_qe = GNUNET_NAMESTORE_records_lookup (ns,
                                                &zone_pkey,
                                                name,
                                                &lookup_error_cb,
                                                NULL,
                                                &display_record_lookup,
                                                NULL);
    }
    else
      list_it = GNUNET_NAMESTORE_zone_iteration_start2 (ns,
                                                        (NULL == ego_name) ?
                                                        NULL : &zone_pkey,
                                                        &zone_iteration_error_cb
                                                        ,
                                                        NULL,
                                                        &display_record_iterator
                                                        ,
                                                        NULL,
                                                        &zone_iteration_finished
                                                        ,
                                                        NULL,
                                                        filter_flags);
  }
  if (NULL != reverse_pkey)
  {
    struct GNUNET_CRYPTO_BlindablePublicKey pubkey;
 
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("reverse-pkey"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK !=
        GNUNET_CRYPTO_blindable_public_key_from_string (reverse_pkey,
                                                        &pubkey))
    {
      fprintf (stderr,
               _ ("Invalid public key for reverse lookup `%s'\n"),
               reverse_pkey);
      ret = 1;
      finish_command ();
      return;
    }
    reverse_qe = GNUNET_NAMESTORE_zone_to_name (ns,
                                                &zone_pkey,
                                                &pubkey,
                                                &reverse_error_cb,
                                                NULL,
                                                &handle_reverse_lookup,
                                                NULL);
  }
  if (NULL != uri)
  {
    char sh[105];
    char sname[64];
    struct GNUNET_CRYPTO_BlindablePublicKey pkey;
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("uri"));
      ret = 1;
      finish_command ();
      return;
    }
 
    memset (sh, 0, 105);
    memset (sname, 0, 64);
 
    if ((2 != (sscanf (uri, "gnunet://gns/%58s/%63s", sh, sname))) ||
        (GNUNET_OK !=
         GNUNET_CRYPTO_blindable_public_key_from_string (sh, &pkey)))
    {
      fprintf (stderr, _ ("Invalid URI `%s'\n"), uri);
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == expirationstring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-e",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK != parse_expiration (expirationstring, &etime_is_rel, &etime))
    {
      fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
      ret = 1;
      finish_command ();
      return;
    }
    memset (&rd, 0, sizeof(rd));
    rd.data = &pkey;
    rd.data_size = GNUNET_CRYPTO_public_key_get_length (&pkey);
    rd.record_type = ntohl (pkey.type);
    rd.expiration_time = etime;
    if (GNUNET_YES == etime_is_rel)
      rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
    if (1 == is_shadow)
      rd.flags |= GNUNET_GNSRECORD_RF_SHADOW;
    if (1 == is_maintenance)
      rd.flags |= GNUNET_GNSRECORD_RF_MAINTENANCE;
    add_qe_uri = GNUNET_NAMESTORE_record_set_store (ns,
                                                    &zone_pkey,
                                                    sname,
                                                    1,
                                                    &rd,
                                                    &add_continuation,
                                                    &add_qe_uri);
  }
  if (monitor)
  {
    zm = GNUNET_NAMESTORE_zone_monitor_start2 (cfg_,
                                               (NULL != ego_name) ?
                                               &zone_pkey : NULL,
                                               GNUNET_YES,
                                               &monitor_error_cb,
                                               NULL,
                                               &display_record_monitor,
                                               NULL,
                                               &sync_cb,
                                               NULL,
                                               filter_flags);
  }
}
 
 
#define MAX_LINE_LEN 4086
 
#define MAX_ARGS 20
 
static int
get_identity_for_string (const char *str,
                         struct GNUNET_CRYPTO_BlindablePrivateKey *zk)
{
  const struct GNUNET_CRYPTO_BlindablePrivateKey *privkey;
  struct GNUNET_CRYPTO_BlindablePublicKey pubkey;
  struct GNUNET_CRYPTO_BlindablePublicKey ego_pubkey;
  struct EgoEntry *ego_entry;
 
  if (GNUNET_OK == GNUNET_CRYPTO_blindable_public_key_from_string (str,
                                                                   &pubkey))
  {
    for (ego_entry = ego_head;
         NULL != ego_entry; ego_entry = ego_entry->next)
    {
      privkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
      GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &ego_pubkey);
      if (0 == memcmp (&ego_pubkey, &pubkey, sizeof (pubkey)))
      {
        *zk = *privkey;
        return GNUNET_OK;
      }
    }
  }
  else
  {
    for (ego_entry = ego_head; NULL != ego_entry; ego_entry = ego_entry->next)
    {
      if (0 != strcmp (str, ego_entry->identifier))
        continue;
      *zk = *GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
      return GNUNET_OK;
    }
  }
  return GNUNET_NO;
}
 
 
static void
process_command_stdin (void)
{
  char buf[MAX_LINE_LEN];
  static struct GNUNET_CRYPTO_BlindablePrivateKey next_zone_key;
  static char next_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
  static int finished = GNUNET_NO;
  static int have_next_recordline = GNUNET_NO;
  int zonekey_set = GNUNET_NO;
  char *tmp;
  char *current_name = NULL;
 
 
  if (GNUNET_YES == have_next_recordline)
  {
    zone_pkey = next_zone_key;
    if (NULL != current_name)
      GNUNET_free (current_name);
    current_name = GNUNET_strdup (next_name);
    zonekey_set = GNUNET_YES;
  }
  while (NULL != fgets (buf, sizeof (buf), stdin))
  {
    if (1 >= strlen (buf))
      continue;
    if (buf[strlen (buf) - 1] == '\n')
      buf[strlen (buf) - 1] = '\0';
    if (buf[strlen (buf) - 1] == ':')
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Switching to %s\n", buf);
      memset (next_name, 0, sizeof (next_name));
      strncpy (next_name, buf, strlen (buf) - 1);
      tmp = strchr (next_name, '.');
      if (NULL == tmp)
      {
        fprintf (stderr, "Error parsing name `%s'\n", next_name);
        GNUNET_SCHEDULER_shutdown ();
        ret = 1;
        return;
      }
      if (GNUNET_OK != get_identity_for_string (tmp + 1, &next_zone_key))
      {
        fprintf (stderr, "Error parsing zone name `%s'\n", tmp + 1);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      *tmp = '\0';
      have_next_recordline = GNUNET_YES;
      /* Run a command for the previous record set */
      if (NULL != recordset)
      {
        if (ri_count >= record_info_capacity)
        {
          GNUNET_array_grow (record_info,
                             record_info_capacity,
                             record_info_capacity + max_batch_size);
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Recordinfo array grown to %u bytes!\n",
                      record_info_capacity);
        }
        record_info[ri_count].a_label = GNUNET_strdup (current_name);
        {
          int rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
            rd_count++;
          record_info[ri_count].a_rd = GNUNET_new_array (rd_count,
                                                         struct
                                                         GNUNET_GNSRECORD_Data);
          rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
          {
            record_info[ri_count].a_rd[rd_count] = e->record;
            record_info[ri_count].a_rd[rd_count].data = GNUNET_malloc (e->
                                                                       record.
                                                                       data_size);
            record_info[ri_count].a_rd[rd_count].data_size = e->record.
                                                             data_size;
            memcpy ((void*) record_info[ri_count].a_rd[rd_count].data,
                    e->record.data, e->record.data_size);
            rd_count++;
          }
          record_info[ri_count].a_rd_count = rd_count;
          ri_count++;
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Added %d records to record info\n", rd_count);
          clear_recordset ();
        }
        /* If the zone has changed, insert */
        /* If we have reached batch size, insert */
        if (0 != GNUNET_memcmp (&next_zone_key, &zone_pkey) ||
            (ri_count >= max_batch_size))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Batch inserting %d RI\n",
                      ri_count);
          batch_insert_recordinfo (cfg);
          return;
        }
      }
      zone_pkey = next_zone_key;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Switching from %s to %s\n",
                  current_name, next_name);
      if (NULL != current_name)
        GNUNET_free (current_name);
      current_name = GNUNET_strdup (next_name);
      zonekey_set = GNUNET_YES;
      continue;
    }
    if (GNUNET_NO == zonekey_set)
    {
      fprintf (stderr, "Warning, encountered recordline without zone\n");
      continue;
    }
    parse_recordline (buf);
  }
  if (GNUNET_NO == finished)
  {
    if (NULL != recordset)
    {
      if (GNUNET_YES == zonekey_set)
      {
        record_info[ri_count].a_label = GNUNET_strdup (current_name);
        {
          int rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
            rd_count++;
          record_info[ri_count].a_rd = GNUNET_new_array (rd_count,
                                                         struct
                                                         GNUNET_GNSRECORD_Data);
          rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
          {
            record_info[ri_count].a_rd[rd_count] = e->record;
            record_info[ri_count].a_rd[rd_count].data = GNUNET_malloc (e->record
                                                                       .
                                                                       data_size);
            record_info[ri_count].a_rd[rd_count].data_size = e->record.data_size
            ;
            memcpy ((void*) record_info[ri_count].a_rd[rd_count].data,
                    e->record.data, e->record.data_size);
            rd_count++;
          }
          record_info[ri_count].a_rd_count = rd_count;
        }
        ri_count++;
        batch_insert_recordinfo (cfg);   
        finished = GNUNET_YES;
        return;
      }
      fprintf (stderr, "Warning, encountered recordline without zone\n");
    }
  }
  if (ri_sent < ri_count)
  {
    batch_insert_recordinfo (cfg);
    return;
  }
  GNUNET_SCHEDULER_shutdown ();
  return;
}
 
 
static void
id_connect_cb (void *cls,
               struct GNUNET_IDENTITY_Ego *ego,
               void **ctx,
               const char *ego_name_tmp)
{
  struct GNUNET_CRYPTO_BlindablePublicKey pk;
  struct EgoEntry *ego_entry;
 
  (void) ctx;
  (void) ego_name_tmp;
  if ((NULL != ego_name_tmp) && (NULL != ego))
  {
    ego_entry = GNUNET_new (struct EgoEntry);
    GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
    ego_entry->ego = ego;
    ego_entry->identifier = GNUNET_strdup (ego_name_tmp);
    GNUNET_CONTAINER_DLL_insert_tail (ego_head,
                                      ego_tail,
                                      ego_entry);
    if ((NULL != ego_name) && (NULL != ego_name_tmp) &&
        (0 == strcmp (ego_name, ego_name_tmp)))
      zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
    return;
  }
  if (NULL != ego)
    return;
  if (read_from_stdin)
  {
    process_command_stdin ();
    return;
  }
  run_with_zone_pkey (cfg);
}
 
 
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *_cfg)
{
  (void) cls;
  (void) args;
  (void) cfgfile;
  cfg = _cfg;
  if (NULL != args[0])
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ ("Superfluous command line arguments (starting with `%s') ignored\n"),
      args[0]);
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
  ns = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == ns)
  {
    fprintf (stderr, _ ("Failed to connect to namestore\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  idh = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, (void *) cfg);
  if (NULL == idh)
  {
    ret = -1;
    fprintf (stderr, _ ("Cannot connect to identity service\n"));
    GNUNET_SCHEDULER_shutdown ();
  }
}
 
 
int
main (int argc, char *const *argv)
{
  int lret;
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag ('a', "add", gettext_noop ("add record"), &add),
    GNUNET_GETOPT_option_flag ('d',
                               "delete",
                               gettext_noop ("delete record"),
                               &del),
    GNUNET_GETOPT_option_flag ('D',
                               "display",
                               gettext_noop ("display records"),
                               &list),
    GNUNET_GETOPT_option_flag ('S',
                               "from-stdin",
                               gettext_noop ("read commands from stdin"),
                               &read_from_stdin),
    GNUNET_GETOPT_option_string (
      'e',
      "expiration",
      "TIME",
      gettext_noop (
        "expiration time for record to use (for adding only), \"never\" is possible"),
      &expirationstring),
    GNUNET_GETOPT_option_string ('i',
                                 "nick",
                                 "NICKNAME",
                                 gettext_noop (
                                   "set the desired nick name for the zone"),
                                 &nickstring),
    GNUNET_GETOPT_option_flag ('m',
                               "monitor",
                               gettext_noop (
                                 "monitor changes in the namestore"),
                               &monitor),
    GNUNET_GETOPT_option_string ('n',
                                 "name",
                                 "NAME",
                                 gettext_noop (
                                   "name of the record to add/delete/display"),
                                 &name),
    GNUNET_GETOPT_option_flag ('r',
                               "recordline",
                               gettext_noop ("Output in recordline format"),
                               &output_recordline),
    GNUNET_GETOPT_option_string ('Z',
                                 "zone-to-name",
                                 "KEY",
                                 gettext_noop (
                                   "determine our name for the given KEY"),
                                 &reverse_pkey),
    GNUNET_GETOPT_option_string ('t',
                                 "type",
                                 "TYPE",
                                 gettext_noop (
                                   "type of the record to add/delete/display"),
                                 &typestring),
    GNUNET_GETOPT_option_string ('u',
                                 "uri",
                                 "URI",
                                 gettext_noop ("URI to import into our zone"),
                                 &uri),
    GNUNET_GETOPT_option_string ('V',
                                 "value",
                                 "VALUE",
                                 gettext_noop (
                                   "value of the record to add/delete"),
                                 &value),
    GNUNET_GETOPT_option_flag ('p',
                               "public",
                               gettext_noop ("create or list public record"),
                               &is_public),
    GNUNET_GETOPT_option_flag ('o',
                               "omit-private",
                               gettext_noop ("omit private records"),
                               &omit_private),
    GNUNET_GETOPT_option_flag ('T',
                               "include-maintenance",
                               gettext_noop (
                                 "do not filter maintenance records"),
                               &include_maintenance),
    GNUNET_GETOPT_option_flag ('P',
                               "purge-orphans",
                               gettext_noop (
                                 "purge namestore of all orphans"),
                               &purge_orphaned),
    GNUNET_GETOPT_option_flag ('O',
                               "list-orphans",
                               gettext_noop (
                                 "show private key for orphaned records for recovery using `gnunet-identity -C -P <key>'. Use in combination with --display"),
                               &list_orphaned),
    GNUNET_GETOPT_option_flag ('X',
                               "purge-zone-records",
                               gettext_noop (
                                 "delete all records in specified zone"),
                               &purge_zone),
    GNUNET_GETOPT_option_uint ('B',
                               "batch-size",
                               "NUMBER",
                               gettext_noop (
                                 "number of records to buffer and send as batch (for use with --from-stdin)"),
                               &max_batch_size),
    GNUNET_GETOPT_option_flag (
      's',
      "shadow",
      gettext_noop (
        "create shadow record (only valid if all other records of the same type have expired)"),
      &is_shadow),
    GNUNET_GETOPT_option_flag (
      'M',
      "maintenance",
      gettext_noop (
        "create maintenance record (e.g TOMBSTONEs)"),
      &is_maintenance),
    GNUNET_GETOPT_option_string ('z',
                                 "zone",
                                 "EGO",
                                 gettext_noop (
                                   "name of the ego controlling the zone"),
                                 &ego_name),
    GNUNET_GETOPT_OPTION_END };
 
 
  is_public = -1;
  is_shadow = -1;
  is_maintenance = -1;
  GNUNET_log_setup ("gnunet-namestore", "WARNING", NULL);
  if (GNUNET_OK !=
      (lret = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                                  argc,
                                  argv,
                                  "gnunet-namestore",
                                  _ ("GNUnet zone manipulation tool"),
                                  options,
                                  &run,
                                  NULL)))
  {
    // FIXME
    // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
    return lret;
  }
  // FIXME
  // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
  return ret;
}
 
 
/* end of gnunet-namestore.c */

INITIAL_RI_BUFFER_SIZE

#define INITIAL_RI_BUFFER_SIZE   5000

Definition at line 349 of file gnunet-namestore.c.

MAX_LINE_LEN

#define MAX_LINE_LEN   4086

Definition at line 1836 of file gnunet-namestore.c.

MAX_ARGS

#define MAX_ARGS   20

Definition at line 1838 of file gnunet-namestore.c.

Function Documentation

parse_expiration()

static int parse_expiration ( const char *  exp_str, int *  is_rel, uint64_t *  exptime  )

static

Parse expiration time.

Parameters

	expirationstring	text to parse
[out]	etime_is_rel	set to GNUNET_YES if time is relative
[out]	etime	set to expiration time (abs or rel)

Returns

GNUNET_OK on success

Definition at line 370 of file gnunet-namestore.c.

{
  struct GNUNET_TIME_Relative etime_rel;
  struct GNUNET_TIME_Absolute etime_abs;
 
  if (0 == strcmp (exp_str, "never"))
  {
    *exptime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
    *is_rel = GNUNET_NO;
    return GNUNET_OK;
  }
  if (GNUNET_OK ==
      GNUNET_STRINGS_fancy_time_to_relative (exp_str, &etime_rel))
  {
    *is_rel = GNUNET_YES;
    *exptime = etime_rel.rel_value_us;
    if (GNUNET_TIME_relative_cmp (etime_rel, <, WARN_RELATIVE_EXPIRATION_LIMIT))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Relative expiration times of less than %s are not recommended. To improve availability, consider increasing this value.\n",
                  GNUNET_STRINGS_relative_time_to_string (
                    WARN_RELATIVE_EXPIRATION_LIMIT, GNUNET_NO));
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Storing record with relative expiration time of %s\n",
                GNUNET_STRINGS_relative_time_to_string (etime_rel, GNUNET_NO));
    return GNUNET_OK;
  }
  if (GNUNET_OK ==
      GNUNET_STRINGS_fancy_time_to_absolute (exp_str, &etime_abs))
  {
    *is_rel = GNUNET_NO;
    *exptime = etime_abs.abs_value_us;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Storing record with absolute expiration time of %s\n",
                GNUNET_STRINGS_absolute_time_to_string (etime_abs));
    return GNUNET_OK;
  }
  return GNUNET_SYSERR;
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_fancy_time_to_absolute(), GNUNET_STRINGS_fancy_time_to_relative(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_relative_cmp, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, GNUNET_TIME_Relative::rel_value_us, and WARN_RELATIVE_EXPIRATION_LIMIT.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_recordline()

static int parse_recordline ( const char *  line )

static

Definition at line 415 of file gnunet-namestore.c.

{
  struct RecordSetEntry *r;
  struct GNUNET_GNSRECORD_Data record;
  char *cp;
  char *tok;
  char *saveptr;
  void *raw_data;
 
  cp = GNUNET_strdup (line);
  tok = strtok_r (cp, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Missing entries in record line `%s'.\n"),
                line);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  record.record_type = GNUNET_GNSRECORD_typename_to_number (tok);
  if (UINT32_MAX == record.record_type)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _ ("Unknown record type `%s'\n"), tok);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  tok = strtok_r (NULL, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Empty record line argument is not allowed.\n"));
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  if (1 != sscanf (tok, "%" SCNu64, &record.expiration_time))
  {
    fprintf (stderr,
             _ ("Error parsing expiration time %s.\n"), tok);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  tok = strtok_r (NULL, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Empty record line argument is not allowed.\n"));
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  record.flags = GNUNET_GNSRECORD_RF_NONE;
  if (NULL != strchr (tok, (unsigned char) 'r'))
    record.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
  if (NULL == strchr (tok, (unsigned char) 'p')) /* p = public */
    record.flags |= GNUNET_GNSRECORD_RF_PRIVATE;
  if (NULL != strchr (tok, (unsigned char) 'S'))
    record.flags |= GNUNET_GNSRECORD_RF_SUPPLEMENTAL;
  if (NULL != strchr (tok, (unsigned char) 's'))
    record.flags |= GNUNET_GNSRECORD_RF_SHADOW;
  if (NULL != strchr (tok, (unsigned char) 'C'))
    record.flags |= GNUNET_GNSRECORD_RF_CRITICAL;
  tok += strlen (tok) + 1;
  if (GNUNET_OK != GNUNET_GNSRECORD_string_to_value (record.record_type,
                                                     tok,
                                                     &raw_data,
                                                     &record.data_size))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Invalid record data for type %s: `%s'.\n"),
                GNUNET_GNSRECORD_number_to_typename (record.record_type),
                tok);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  GNUNET_free (cp);
 
  r = GNUNET_malloc (sizeof(struct RecordSetEntry) + record.data_size);
  r->next = recordset;
  record.data = &r[1];
  memcpy (&r[1], raw_data, record.data_size);
  GNUNET_free (raw_data);
  r->record = record;
  recordset = r;
  return GNUNET_OK;
}

References _, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_CRITICAL, GNUNET_GNSRECORD_RF_NONE, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_GNSRECORD_RF_SUPPLEMENTAL, GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_typename_to_number(), GNUNET_log, GNUNET_malloc, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, line, RecordSetEntry::next, RecordSetEntry::record, record(), and recordset.

Referenced by process_command_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

clear_recordset()

static void clear_recordset ( )

static

Definition at line 502 of file gnunet-namestore.c.

{
  struct RecordSetEntry *rs_entry;
 
  while (NULL != (rs_entry = recordset))
  {
    recordset = recordset->next;
    GNUNET_free (rs_entry);
  }
  recordset = NULL;
}

References GNUNET_free, RecordSetEntry::next, and recordset.

Referenced by process_command_stdin(), and reset_handles().

Here is the caller graph for this function:

reset_handles()

static void reset_handles ( void  )

static

Definition at line 516 of file gnunet-namestore.c.

{
  struct MarkedRecord *mrec;
  struct MarkedRecord *mrec_tmp;
  clear_recordset ();
  if (NULL != ego_name)
  {
    GNUNET_free (ego_name);
    ego_name = NULL;
  }
  if (NULL != name)
  {
    GNUNET_free (name);
    name = NULL;
  }
  if (NULL != value)
  {
    GNUNET_free (value);
    value = NULL;
  }
  if (NULL != uri)
  {
    GNUNET_free (uri);
    uri = NULL;
  }
  if (NULL != expirationstring)
  {
    GNUNET_free (expirationstring);
    expirationstring = NULL;
  }
  if (NULL != purge_task)
  {
    GNUNET_SCHEDULER_cancel (purge_task);
    purge_task = NULL;
  }
  for (mrec = marked_head; NULL != mrec;)
  {
    mrec_tmp = mrec;
    mrec = mrec->next;
    GNUNET_free (mrec_tmp->name);
    GNUNET_free (mrec_tmp);
  }
  if (NULL != list_it)
  {
    GNUNET_NAMESTORE_zone_iteration_stop (list_it);
    list_it = NULL;
  }
  if (NULL != add_qe)
  {
    GNUNET_NAMESTORE_cancel (add_qe);
    add_qe = NULL;
  }
  if (NULL != set_qe)
  {
    GNUNET_NAMESTORE_cancel (set_qe);
    set_qe = NULL;
  }
  if (NULL != add_qe_uri)
  {
    GNUNET_NAMESTORE_cancel (add_qe_uri);
    add_qe_uri = NULL;
  }
  if (NULL != get_qe)
  {
    GNUNET_NAMESTORE_cancel (get_qe);
    get_qe = NULL;
  }
  if (NULL != del_qe)
  {
    GNUNET_NAMESTORE_cancel (del_qe);
    del_qe = NULL;
  }
  if (NULL != reverse_qe)
  {
    GNUNET_NAMESTORE_cancel (reverse_qe);
    reverse_qe = NULL;
  }
  memset (&zone_pkey, 0, sizeof(zone_pkey));
  if (NULL != zm)
  {
    GNUNET_NAMESTORE_zone_monitor_stop (zm);
    zm = NULL;
  }
  if (NULL != data)
  {
    GNUNET_free (data);
    data = NULL;
  }
  if (NULL != typestring)
  {
    GNUNET_free (typestring);
    typestring = NULL;
  }
  list = 0;
  is_public = 0;
  is_shadow = 0;
  is_maintenance = 0;
  purge_zone = 0;
}

References add_qe, add_qe_uri, clear_recordset(), data, del_qe, ego_name, expirationstring, get_qe, GNUNET_free, GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_monitor_stop(), GNUNET_SCHEDULER_cancel(), is_maintenance, is_public, is_shadow, list, list_it, marked_head, MarkedRecord::name, name, MarkedRecord::next, purge_task, purge_zone, reverse_qe, set_qe, typestring, uri, value, zm, and zone_pkey.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Task run on shutdown.

Cleans up everything.

Parameters

cls

unused

Definition at line 623 of file gnunet-namestore.c.

{
  struct EgoEntry *ego_entry;
  struct EgoEntry *ego_tmp;
  (void) cls;
 
  reset_handles ();
  if (NULL != record_info)
    GNUNET_free (record_info);
  record_info = NULL;
  if (NULL != ns_qe)
  {
    GNUNET_NAMESTORE_cancel (ns_qe);
    ns_qe = NULL;
  }
  if (NULL != ns)
  {
    GNUNET_NAMESTORE_disconnect (ns);
    ns = NULL;
  }
  if (NULL != idh)
  {
    GNUNET_IDENTITY_disconnect (idh);
    idh = NULL;
  }
  for (ego_entry = ego_head; NULL != ego_entry;)
  {
    ego_tmp = ego_entry;
    ego_entry = ego_entry->next;
    GNUNET_free (ego_tmp->identifier);
    GNUNET_free (ego_tmp);
  }
}

References ego_head, GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_disconnect(), EgoEntry::identifier, idh, EgoEntry::next, ns, ns_qe, record_info, and reset_handles().

Here is the call graph for this function:

process_command_stdin()

static void process_command_stdin ( void  )

static

Check if this is a new name. If yes, and we have records, store them.

One last time

Definition at line 1880 of file gnunet-namestore.c.

{
  char buf[MAX_LINE_LEN];
  static struct GNUNET_CRYPTO_BlindablePrivateKey next_zone_key;
  static char next_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
  static int finished = GNUNET_NO;
  static int have_next_recordline = GNUNET_NO;
  int zonekey_set = GNUNET_NO;
  char *tmp;
  char *current_name = NULL;
 
 
  if (GNUNET_YES == have_next_recordline)
  {
    zone_pkey = next_zone_key;
    if (NULL != current_name)
      GNUNET_free (current_name);
    current_name = GNUNET_strdup (next_name);
    zonekey_set = GNUNET_YES;
  }
  while (NULL != fgets (buf, sizeof (buf), stdin))
  {
    if (1 >= strlen (buf))
      continue;
    if (buf[strlen (buf) - 1] == '\n')
      buf[strlen (buf) - 1] = '\0';
    if (buf[strlen (buf) - 1] == ':')
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Switching to %s\n", buf);
      memset (next_name, 0, sizeof (next_name));
      strncpy (next_name, buf, strlen (buf) - 1);
      tmp = strchr (next_name, '.');
      if (NULL == tmp)
      {
        fprintf (stderr, "Error parsing name `%s'\n", next_name);
        GNUNET_SCHEDULER_shutdown ();
        ret = 1;
        return;
      }
      if (GNUNET_OK != get_identity_for_string (tmp + 1, &next_zone_key))
      {
        fprintf (stderr, "Error parsing zone name `%s'\n", tmp + 1);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      *tmp = '\0';
      have_next_recordline = GNUNET_YES;
      /* Run a command for the previous record set */
      if (NULL != recordset)
      {
        if (ri_count >= record_info_capacity)
        {
          GNUNET_array_grow (record_info,
                             record_info_capacity,
                             record_info_capacity + max_batch_size);
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Recordinfo array grown to %u bytes!\n",
                      record_info_capacity);
        }
        record_info[ri_count].a_label = GNUNET_strdup (current_name);
        {
          int rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
            rd_count++;
          record_info[ri_count].a_rd = GNUNET_new_array (rd_count,
                                                         struct
                                                         GNUNET_GNSRECORD_Data);
          rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
          {
            record_info[ri_count].a_rd[rd_count] = e->record;
            record_info[ri_count].a_rd[rd_count].data = GNUNET_malloc (e->
                                                                       record.
                                                                       data_size);
            record_info[ri_count].a_rd[rd_count].data_size = e->record.
                                                             data_size;
            memcpy ((void*) record_info[ri_count].a_rd[rd_count].data,
                    e->record.data, e->record.data_size);
            rd_count++;
          }
          record_info[ri_count].a_rd_count = rd_count;
          ri_count++;
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Added %d records to record info\n", rd_count);
          clear_recordset ();
        }
        /* If the zone has changed, insert */
        /* If we have reached batch size, insert */
        if (0 != GNUNET_memcmp (&next_zone_key, &zone_pkey) ||
            (ri_count >= max_batch_size))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Batch inserting %d RI\n",
                      ri_count);
          batch_insert_recordinfo (cfg);
          return;
        }
      }
      zone_pkey = next_zone_key;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Switching from %s to %s\n",
                  current_name, next_name);
      if (NULL != current_name)
        GNUNET_free (current_name);
      current_name = GNUNET_strdup (next_name);
      zonekey_set = GNUNET_YES;
      continue;
    }
    if (GNUNET_NO == zonekey_set)
    {
      fprintf (stderr, "Warning, encountered recordline without zone\n");
      continue;
    }
    parse_recordline (buf);
  }
  if (GNUNET_NO == finished)
  {
    if (NULL != recordset)
    {
      if (GNUNET_YES == zonekey_set)
      {
        record_info[ri_count].a_label = GNUNET_strdup (current_name);
        {
          int rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
            rd_count++;
          record_info[ri_count].a_rd = GNUNET_new_array (rd_count,
                                                         struct
                                                         GNUNET_GNSRECORD_Data);
          rd_count = 0;
          for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
          {
            record_info[ri_count].a_rd[rd_count] = e->record;
            record_info[ri_count].a_rd[rd_count].data = GNUNET_malloc (e->record
                                                                       .
                                                                       data_size);
            record_info[ri_count].a_rd[rd_count].data_size = e->record.data_size
            ;
            memcpy ((void*) record_info[ri_count].a_rd[rd_count].data,
                    e->record.data, e->record.data_size);
            rd_count++;
          }
          record_info[ri_count].a_rd_count = rd_count;
        }
        ri_count++;
        batch_insert_recordinfo (cfg);   
        finished = GNUNET_YES;
        return;
      }
      fprintf (stderr, "Warning, encountered recordline without zone\n");
    }
  }
  if (ri_sent < ri_count)
  {
    batch_insert_recordinfo (cfg);
    return;
  }
  GNUNET_SCHEDULER_shutdown ();
  return;
}

References GNUNET_NAMESTORE_RecordInfo::a_label, GNUNET_NAMESTORE_RecordInfo::a_rd, GNUNET_NAMESTORE_RecordInfo::a_rd_count, batch_insert_recordinfo(), cfg, clear_recordset(), data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, finished, get_identity_for_string(), GNUNET_array_grow, GNUNET_DNSPARSER_MAX_NAME_LENGTH, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memcmp, GNUNET_new_array, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_YES, max_batch_size, MAX_LINE_LEN, RecordSetEntry::next, parse_recordline(), rd_count, record(), record_info, record_info_capacity, recordset, ret, ri_count, ri_sent, and zone_pkey.

Referenced by finish_command(), and id_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

batch_insert_recordinfo()

static void batch_insert_recordinfo ( const struct GNUNET_CONFIGURATION_Handle *  batch_cfg )

static

We have obtained the zone's private key, so now process the main commands using it.

Parameters

cfg	configuration to use

Definition at line 1399 of file gnunet-namestore.c.

{
  unsigned int sent_here;
 
  GNUNET_assert (0 != ri_count);
  set_qe = GNUNET_NAMESTORE_records_store (ns,
                                           &zone_pkey,
                                           ri_count - ri_sent,
                                           record_info + ri_sent,
                                           &sent_here,
                                           &replace_cont,
                                           NULL);
  ri_sent += sent_here;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sent %d/%d record infos\n", ri_sent,
              ri_count);
  if (ri_sent == ri_count)
  {
    for (int i = 0; i < ri_count; i++)
    {
      GNUNET_free (record_info[i].a_rd);
      record_info[i].a_rd = NULL;
    }
    ri_count = 0;
    ri_sent = 0;
  }
  return;
}

References GNUNET_NAMESTORE_RecordInfo::a_rd, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAMESTORE_records_store(), ns, record_info, replace_cont(), ri_count, ri_sent, set_qe, and zone_pkey.

Referenced by process_command_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_command()

static void finish_command ( void  )

static

Definition at line 673 of file gnunet-namestore.c.

{
  // if (ri_sent < ri_count)
  // {
  //  batch_insert_recordinfo (cfg);
  //  return;
  // }
  // reset_handles ();
  if (read_from_stdin)
  {
    process_command_stdin ();
    return;
  }
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_SCHEDULER_shutdown(), process_command_stdin(), and read_from_stdin.

Referenced by add_continuation(), add_error_cb(), del_continuation(), del_lookup_error_cb(), del_monitor(), display_record_lookup(), get_existing_record(), handle_reverse_lookup(), lookup_error_cb(), purge_next_record(), run_with_zone_pkey(), schedule_finish(), zone_iteration_error_cb(), and zone_iteration_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

add_continuation()

static void add_continuation ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Definition at line 691 of file gnunet-namestore.c.

{
  struct GNUNET_NAMESTORE_QueueEntry **qe = cls;
 
  *qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr,
             _ ("Adding record failed: %s\n"),
             GNUNET_ErrorCode_get_hint (ec));
    if (GNUNET_EC_NAMESTORE_RECORD_EXISTS != ec)
      ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  ret = 0;
  finish_command ();
}

References _, finish_command(), GNUNET_EC_NAMESTORE_RECORD_EXISTS, GNUNET_EC_NONE, GNUNET_ErrorCode_get_hint(), GNUNET_SCHEDULER_shutdown(), qe, and ret.

Referenced by get_existing_record(), and run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

del_continuation()

static void del_continuation ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Definition at line 712 of file gnunet-namestore.c.

{
  (void) cls;
  del_qe = NULL;
  if (GNUNET_EC_NAMESTORE_RECORD_NOT_FOUND == ec)
  {
    fprintf (stderr,
             _ ("Deleting record failed: %s\n"), GNUNET_ErrorCode_get_hint (
               ec));
  }
  finish_command ();
}

References _, del_qe, finish_command(), GNUNET_EC_NAMESTORE_RECORD_NOT_FOUND, and GNUNET_ErrorCode_get_hint().

Referenced by del_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

purge_next_record()

static void purge_next_record ( void *  cls )

static

Definition at line 744 of file gnunet-namestore.c.

{
  struct MarkedRecord *mrec;
  purge_task = NULL;
 
  if (NULL == marked_head)
  {
    ret = 0;
    finish_command ();
    return;
  }
  mrec = marked_head;
  GNUNET_CONTAINER_DLL_remove (marked_head,
                               marked_tail,
                               mrec);
  del_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                              &mrec->key,
                                              mrec->name,
                                              0, NULL,
                                              &marked_deleted,
                                              NULL);
  GNUNET_free (mrec->name);
  GNUNET_free (mrec);
}

References del_qe, finish_command(), GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NAMESTORE_record_set_store(), MarkedRecord::key, marked_deleted(), marked_head, marked_tail, MarkedRecord::name, ns, purge_task, and ret.

Referenced by marked_deleted(), and zone_iteration_finished().

Here is the call graph for this function:

Here is the caller graph for this function:

marked_deleted()

static void marked_deleted ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Definition at line 730 of file gnunet-namestore.c.

{
  del_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr,
             _ ("Deleting record failed: %s\n"),
             GNUNET_ErrorCode_get_hint (ec));
  }
  purge_task = GNUNET_SCHEDULER_add_now (&purge_next_record, NULL);
}

References _, del_qe, GNUNET_EC_NONE, GNUNET_ErrorCode_get_hint(), GNUNET_SCHEDULER_add_now(), purge_next_record(), and purge_task.

Referenced by purge_next_record().

Here is the call graph for this function:

Here is the caller graph for this function:

zone_iteration_finished()

static void zone_iteration_finished ( void *  cls )

static

Function called when we are done with a zone iteration.

Definition at line 774 of file gnunet-namestore.c.

{
  (void) cls;
  list_it = NULL;
  if (purge_orphaned || purge_zone)
  {
    purge_task = GNUNET_SCHEDULER_add_now (&purge_next_record, NULL);
    return;
  }
  ret = 0;
  finish_command ();
}

References finish_command(), GNUNET_SCHEDULER_add_now(), list_it, purge_next_record(), purge_orphaned, purge_task, purge_zone, and ret.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

zone_iteration_error_cb()

static void zone_iteration_error_cb ( void *  cls )

static

Function called when we encountered an error in a zone iteration.

Definition at line 792 of file gnunet-namestore.c.

{
  (void) cls;
  list_it = NULL;
  fprintf (stderr, "Error iterating over zone\n");
  ret = 1;
  finish_command ();
}

References finish_command(), list_it, and ret.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

collect_zone_records_to_purge()

static void collect_zone_records_to_purge ( const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Definition at line 803 of file gnunet-namestore.c.

{
  struct MarkedRecord *mrec;
 
  mrec = GNUNET_new (struct MarkedRecord);
  mrec->key = *zone_key;
  mrec->name = GNUNET_strdup (rname);
  GNUNET_CONTAINER_DLL_insert (marked_head,
                               marked_tail,
                               mrec);
}

References GNUNET_CONTAINER_DLL_insert, GNUNET_new, GNUNET_strdup, MarkedRecord::key, marked_head, marked_tail, and MarkedRecord::name.

Referenced by purge_zone_iterator().

Here is the caller graph for this function:

collect_orphans()

static void collect_orphans ( const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Definition at line 821 of file gnunet-namestore.c.

{
  struct EgoEntry *ego;
  struct MarkedRecord *orphan;
  int is_orphaned = 1;
 
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == memcmp (GNUNET_IDENTITY_ego_get_private_key (ego->ego),
                     zone_key,
                     sizeof (*zone_key)))
    {
      is_orphaned = 0;
      break;
    }
  }
  if (is_orphaned)
  {
    orphan = GNUNET_new (struct MarkedRecord);
    orphan->key = *zone_key;
    orphan->name = GNUNET_strdup (rname);
    GNUNET_CONTAINER_DLL_insert (marked_head,
                                 marked_tail,
                                 orphan);
  }
}

References EgoEntry::ego, ego_head, GNUNET_CONTAINER_DLL_insert, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_new, GNUNET_strdup, MarkedRecord::key, marked_head, marked_tail, MarkedRecord::name, and EgoEntry::next.

Referenced by purge_orphans_iterator().

Here is the call graph for this function:

Here is the caller graph for this function:

display_record()

static void display_record ( const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Process a record that was stored in the namestore.

Parameters

rname	name that is being mapped (at most 255 characters long)
rd_len	number of entries in rd array
rd	array of records with data to store

Definition at line 860 of file gnunet-namestore.c.

{
  const char *typestr;
  char *s;
  const char *ets;
  struct GNUNET_TIME_Absolute at;
  struct GNUNET_TIME_Relative rt;
  struct EgoEntry *ego;
  int have_record;
  int is_orphaned = 1;
  char *orphaned_str;
 
  if ((NULL != name) && (0 != strcmp (name, rname)))
    return;
  have_record = GNUNET_NO;
  for (unsigned int i = 0; i < rd_len; i++)
  {
    if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
        (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
      continue;
    if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
      continue;
    have_record = GNUNET_YES;
    break;
  }
  if (GNUNET_NO == have_record)
    return;
  for (ego = ego_head; NULL != ego; ego = ego->next)
  {
    if (0 == memcmp (GNUNET_IDENTITY_ego_get_private_key (ego->ego),
                     zone_key,
                     sizeof (*zone_key)))
    {
      is_orphaned = 0;
      break;
    }
  }
  if (list_orphaned && ! is_orphaned)
    return;
  if (! list_orphaned && is_orphaned)
    return;
  orphaned_str = GNUNET_CRYPTO_blindable_private_key_to_string (zone_key);
  fprintf (stdout, "%s.%s:\n", rname, is_orphaned ? orphaned_str :
           ego->identifier);
  GNUNET_free (orphaned_str);
  if (NULL != typestring)
    type = GNUNET_GNSRECORD_typename_to_number (typestring);
  else
    type = GNUNET_GNSRECORD_TYPE_ANY;
  for (unsigned int i = 0; i < rd_len; i++)
  {
    if ((GNUNET_GNSRECORD_TYPE_NICK == rd[i].record_type) &&
        (0 != strcmp (rname, GNUNET_GNS_EMPTY_LABEL_AT)))
      continue;
    if ((type != rd[i].record_type) && (GNUNET_GNSRECORD_TYPE_ANY != type))
      continue;
    typestr = GNUNET_GNSRECORD_number_to_typename (rd[i].record_type);
    s = GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                          rd[i].data,
                                          rd[i].data_size);
    if (NULL == s)
    {
      fprintf (stdout,
               _ ("\tCorrupt or unsupported record of type %u\n"),
               (unsigned int) rd[i].record_type);
      continue;
    }
    if (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      rt.rel_value_us = rd[i].expiration_time;
      ets = GNUNET_STRINGS_relative_time_to_string (rt, GNUNET_YES);
    }
    else
    {
      at.abs_value_us = rd[i].expiration_time;
      ets = GNUNET_STRINGS_absolute_time_to_string (at);
    }
    {
      char flgstr[16];
      sprintf (flgstr, "[%s%s%s%s%s]",
               (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE) ? "" : "p",
               (rd[i].flags & GNUNET_GNSRECORD_RF_SUPPLEMENTAL) ? "S" : "",
               (rd[i].flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION) ? "r" :
               "",
               (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW) ? "S" : "",
               (rd[i].flags & GNUNET_GNSRECORD_RF_CRITICAL) ? "C" : "");
      if (output_recordline)
        fprintf (stdout,
                 "  %s %" PRIu64 " %s %s\n",
                 typestr,
                 rd[i].expiration_time,
                 flgstr,
                 s);
      else
        fprintf (stdout,
                 "\t%s: %s (%s)\t%s\t%s\t%s\n",
                 typestr,
                 s,
                 ets,
                 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE"
             : "PUBLIC",
                 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW)) ? "SHADOW"
               : "",
                 (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_MAINTENANCE)) ?
                 "MAINTENANCE"
             : "");
      GNUNET_free (s);
    }
  }
  // fprintf (stdout, "%s", "\n");
}

References _, GNUNET_TIME_Absolute::abs_value_us, data, data_size, EgoEntry::ego, ego_head, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_CRYPTO_blindable_private_key_to_string(), GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_CRITICAL, GNUNET_GNSRECORD_RF_MAINTENANCE, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_GNSRECORD_RF_SUPPLEMENTAL, GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_typename_to_number(), GNUNET_GNSRECORD_value_to_string(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_NO, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, list_orphaned, name, output_recordline, rd, GNUNET_TIME_Relative::rel_value_us, type, and typestring.

Referenced by display_record_iterator(), display_record_lookup(), and display_record_monitor().

Here is the call graph for this function:

Here is the caller graph for this function:

purge_zone_iterator()

static void purge_zone_iterator ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd, struct GNUNET_TIME_Absolute  expiry  )

static

Definition at line 977 of file gnunet-namestore.c.

{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  collect_zone_records_to_purge (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
}

References collect_zone_records_to_purge(), GNUNET_NAMESTORE_zone_iterator_next(), list_it, and rd.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

purge_orphans_iterator()

static void purge_orphans_iterator ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd, struct GNUNET_TIME_Absolute  expiry  )

static

Definition at line 993 of file gnunet-namestore.c.

{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  collect_orphans (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
}

References collect_orphans(), GNUNET_NAMESTORE_zone_iterator_next(), list_it, and rd.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

display_record_iterator()

static void display_record_iterator ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd, struct GNUNET_TIME_Absolute  expiry  )

static

Process a record that was stored in the namestore.

Parameters

cls	closure
zone_key	private key of the zone
rname	name that is being mapped (at most 255 characters long)
rd_len	number of entries in rd array
rd	array of records with data to store

Definition at line 1019 of file gnunet-namestore.c.

{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  display_record (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
}

References display_record(), GNUNET_NAMESTORE_zone_iterator_next(), list_it, and rd.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

display_record_monitor()

static void display_record_monitor ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd, struct GNUNET_TIME_Absolute  expiry  )

static

Process a record that was stored in the namestore.

Parameters

cls	closure
zone_key	private key of the zone
rname	name that is being mapped (at most 255 characters long)
rd_len	number of entries in rd array
rd	array of records with data to store

Definition at line 1045 of file gnunet-namestore.c.

{
  (void) cls;
  (void) zone_key;
  (void) expiry;
  display_record (zone_key, rname, rd_len, rd);
  GNUNET_NAMESTORE_zone_monitor_next (zm, 1);
}

References display_record(), GNUNET_NAMESTORE_zone_monitor_next(), rd, and zm.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

display_record_lookup()

static void display_record_lookup ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Process a record that was stored in the namestore.

Parameters

cls	closure
zone_key	private key of the zone
rname	name that is being mapped (at most 255 characters long)
rd_len	number of entries in rd array
rd	array of records with data to store

Definition at line 1071 of file gnunet-namestore.c.

{
  (void) cls;
  (void) zone_key;
  get_qe = NULL;
  display_record (zone_key, rname, rd_len, rd);
  finish_command ();
}

References display_record(), finish_command(), get_qe, and rd.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

sync_cb()

static void sync_cb ( void *  cls )

static

Function called once we are in sync in monitor mode.

Parameters

cls

NULL

Definition at line 1091 of file gnunet-namestore.c.

{
  (void) cls;
  fprintf (stdout, "%s", "Monitor is now in sync.\n");
}

Referenced by GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_PEERSTORE_monitor_start(), and run_with_zone_pkey().

Here is the caller graph for this function:

monitor_error_cb()

static void monitor_error_cb ( void *  cls )

static

Function called on errors while monitoring.

Parameters

cls

NULL

Definition at line 1104 of file gnunet-namestore.c.

{
  (void) cls;
  fprintf (stderr, "%s", "Monitor disconnected and out of sync.\n");
}

Referenced by run_with_zone_pkey().

Here is the caller graph for this function:

lookup_error_cb()

static void lookup_error_cb ( void *  cls )

static

Function called on errors while monitoring.

Parameters

cls

NULL

Definition at line 1117 of file gnunet-namestore.c.

{
  (void) cls;
  get_qe = NULL;
  fprintf (stderr, "%s", "Failed to lookup record.\n");
  finish_command ();
}

References finish_command(), and get_qe.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

add_error_cb()

static void add_error_cb ( void *  cls )

static

Function called if lookup fails.

Definition at line 1130 of file gnunet-namestore.c.

{
  (void) cls;
  add_qe = NULL;
  GNUNET_break (0);
  ret = 1;
  finish_command ();
}

References add_qe, finish_command(), GNUNET_break, and ret.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

get_existing_record()

static void get_existing_record ( void *  cls, const struct GNUNET_CRYPTO_BlindablePrivateKey *  zone_key, const char *  rec_name, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

We're storing a record; this function is given the existing record so that we can merge the information.

Parameters

cls	closure, unused
zone_key	private key of the zone
rec_name	name that is being mapped (at most 255 characters long)
rd_count	number of entries in rd array
rd	array of records with data to store

Definition at line 1151 of file gnunet-namestore.c.

{
  struct GNUNET_GNSRECORD_Data rdn[rd_count + 1];
  struct GNUNET_GNSRECORD_Data *rde;
 
  (void) cls;
  (void) zone_key;
  add_qe = NULL;
  if (0 != strcmp (rec_name, name))
  {
    GNUNET_break (0);
    ret = 1;
    finish_command ();
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u records for name `%s'\n",
              rd_count,
              rec_name);
  for (unsigned int i = 0; i < rd_count; i++)
  {
    switch (rd[i].record_type)
    {
    case GNUNET_DNSPARSER_TYPE_SOA:
      if (GNUNET_DNSPARSER_TYPE_SOA == type)
      {
        fprintf (
          stderr,
          _ (
            "A SOA record exists already under `%s', cannot add a second SOA to the same zone.\n"),
          rec_name);
        ret = 1;
        finish_command ();
        return;
      }
      break;
    }
  }
  memset (rdn, 0, sizeof(struct GNUNET_GNSRECORD_Data));
  GNUNET_memcpy (&rdn[1], rd, rd_count * sizeof(struct GNUNET_GNSRECORD_Data));
  rde = &rdn[0];
  rde->data = data;
  rde->data_size = data_size;
  rde->record_type = type;
  if (1 == is_shadow)
    rde->flags |= GNUNET_GNSRECORD_RF_SHADOW;
  if (1 == is_maintenance)
    rde->flags |= GNUNET_GNSRECORD_RF_MAINTENANCE;
  if (1 != is_public)
    rde->flags |= GNUNET_GNSRECORD_RF_PRIVATE;
  rde->expiration_time = etime;
  if (GNUNET_YES == etime_is_rel)
    rde->flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
  else if (GNUNET_NO != etime_is_rel)
    rde->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
  GNUNET_assert (NULL != name);
  add_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                              &zone_pkey,
                                              name,
                                              rd_count + 1,
                                              rde,
                                              &add_continuation,
                                              &add_qe);
}

References _, add_continuation(), add_qe, data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, etime, etime_is_rel, GNUNET_GNSRECORD_Data::expiration_time, finish_command(), GNUNET_GNSRECORD_Data::flags, GNUNET_assert, GNUNET_break, GNUNET_DNSPARSER_TYPE_SOA, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_RF_MAINTENANCE, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_log, GNUNET_memcpy, GNUNET_NAMESTORE_record_set_store(), GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, is_maintenance, is_public, is_shadow, name, ns, rd, rd_count, GNUNET_GNSRECORD_Data::record_type, ret, type, and zone_pkey.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

reverse_error_cb()

static void reverse_error_cb ( void *  cls )

static

Function called if we encountered an error in zone-to-name.

Definition at line 1226 of file gnunet-namestore.c.

{
  (void) cls;
  reverse_qe = NULL;
  fprintf (stdout, "%s.zkey\n", reverse_pkey);
}

References reverse_pkey, and reverse_qe.

Referenced by run_with_zone_pkey().

Here is the caller graph for this function:

handle_reverse_lookup()

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

static

Function called with the result of our attempt to obtain a name for a given public key.

Parameters

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

Definition at line 1245 of file gnunet-namestore.c.

{
  (void) cls;
  (void) zone;
  (void) rd_count;
  (void) rd;
  reverse_qe = NULL;
  if (NULL == label)
    fprintf (stdout, "%s\n", reverse_pkey);
  else
    fprintf (stdout, "%s.%s\n", label, ego_name);
  finish_command ();
}

References ego_name, finish_command(), rd, rd_count, reverse_pkey, and reverse_qe.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

del_lookup_error_cb()

static void del_lookup_error_cb ( void *  cls )

static

Function called if lookup for deletion fails.

Definition at line 1268 of file gnunet-namestore.c.

{
  (void) cls;
  del_qe = NULL;
  GNUNET_break (0);
  ret = 1;
  finish_command ();
}

References del_qe, finish_command(), GNUNET_break, and ret.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

del_monitor()

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

static

We were asked to delete something; this function is called with the existing records.

Now we should determine what should be deleted and then issue the deletion operation.

Parameters

cls	NULL
zone	private key of the zone we are deleting from
label	name of the records we are editing
rd_count	size of the rd array
rd	existing records

Definition at line 1290 of file gnunet-namestore.c.

{
  struct GNUNET_GNSRECORD_Data rdx[rd_count];
  unsigned int rd_left;
  uint32_t del_type;
  char *vs;
 
  (void) cls;
  (void) zone;
  del_qe = NULL;
  if (0 == rd_count)
  {
    fprintf (stderr,
             _ (
               "There are no records under label `%s' that could be deleted.\n")
             ,
             label);
    ret = 1;
    finish_command ();
    return;
  }
  if ((NULL == value) && (NULL == typestring))
  {
    /* delete everything */
    del_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                                &zone_pkey,
                                                name,
                                                0,
                                                NULL,
                                                &del_continuation,
                                                NULL);
    return;
  }
  rd_left = 0;
  if (NULL != typestring)
    del_type = GNUNET_GNSRECORD_typename_to_number (typestring);
  else
    del_type = GNUNET_GNSRECORD_TYPE_ANY;
  for (unsigned int i = 0; i < rd_count; i++)
  {
    vs = NULL;
    if (! (((GNUNET_GNSRECORD_TYPE_ANY == del_type) ||
            (rd[i].record_type == del_type)) &&
           ((NULL == value) ||
            (NULL ==
             (vs = (GNUNET_GNSRECORD_value_to_string (rd[i].record_type,
                                                      rd[i].data,
                                                      rd[i].data_size)))) ||
            (0 == strcmp (vs, value)))))
      rdx[rd_left++] = rd[i];
    GNUNET_free (vs);
  }
  if (rd_count == rd_left)
  {
    /* nothing got deleted */
    fprintf (
      stderr,
      _ (
        "There are no records under label `%s' that match the request for deletion.\n"),
      label);
    finish_command ();
    return;
  }
  /* delete everything but what we copied to 'rdx' */
  del_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                              &zone_pkey,
                                              name,
                                              rd_left,
                                              rdx,
                                              &del_continuation,
                                              NULL);
}

References _, data, data_size, del_continuation(), del_qe, finish_command(), GNUNET_free, GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_typename_to_number(), GNUNET_GNSRECORD_value_to_string(), GNUNET_NAMESTORE_record_set_store(), name, ns, rd, rd_count, GNUNET_GNSRECORD_Data::record_type, ret, typestring, value, and zone_pkey.

Referenced by run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_finish()

static void schedule_finish ( void *  cls )

static

Definition at line 1369 of file gnunet-namestore.c.

{
  finish_command ();
}

References finish_command().

Referenced by replace_cont().

Here is the call graph for this function:

Here is the caller graph for this function:

replace_cont()

static void replace_cont ( void *  cls, enum GNUNET_ErrorCode  ec  )

static

Definition at line 1376 of file gnunet-namestore.c.

{
  (void) cls;
 
  set_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                _ ("%s\n"),
                GNUNET_ErrorCode_get_hint (ec));
    ret = 1;   /* fail from 'main' */
  }
  GNUNET_SCHEDULER_add_now (&schedule_finish, NULL);
}

References _, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_SCHEDULER_add_now(), ret, schedule_finish(), and set_qe.

Referenced by batch_insert_recordinfo(), and run_with_zone_pkey().

Here is the call graph for this function:

Here is the caller graph for this function:

run_with_zone_pkey()

static void run_with_zone_pkey ( const struct GNUNET_CONFIGURATION_Handle *  cfg_ )

static

We have obtained the zone's private key, so now process the main commands using it.

Parameters

cfg	configuration to use

Definition at line 1435 of file gnunet-namestore.c.

{
  struct GNUNET_GNSRECORD_Data rd;
  enum GNUNET_GNSRECORD_Filter filter_flags = GNUNET_GNSRECORD_FILTER_NONE;
 
  if (omit_private)
    filter_flags |= GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE;
  if (include_maintenance)
    filter_flags |= GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE;
  if (! (add | del | list | (NULL != nickstring) | (NULL != uri)
         | (NULL != reverse_pkey) | (NULL != recordset) | (monitor)
         | (purge_orphaned) | (list_orphaned) | (purge_zone)) )
  {
    /* nothing more to be done */
    fprintf (stderr, _ ("No options given\n"));
    finish_command ();
    return;
  }
 
  if (NULL != recordset)
  {
    /* replace entire record set */
    unsigned int rd_count;
    struct GNUNET_GNSRECORD_Data *rd_tmp;
 
    /* FIXME: We could easily support append and delete with this as well */
    if (! add)
    {
      fprintf (stderr, _ ("Recordlines only work with option `%s'\n"),
               "-a");
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("name"));
      ret = 1;
      finish_command ();
      return;
    }
    rd_count = 0;
    for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
      rd_count++;
    rd_tmp = GNUNET_new_array (rd_count, struct GNUNET_GNSRECORD_Data);
    rd_count = 0;
    for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
    {
      rd_tmp[rd_count] = e->record;
      rd_count++;
    }
    set_qe = GNUNET_NAMESTORE_record_set_store (ns,
                                                &zone_pkey,
                                                name,
                                                rd_count,
                                                rd_tmp,
                                                &replace_cont,
                                                NULL);
    GNUNET_free (rd_tmp);
    return;
  }
  if (NULL != nickstring)
  {
    if (0 == strlen (nickstring))
    {
      fprintf (stderr, _ ("Invalid nick `%s'\n"), nickstring);
      ret = 1;
      finish_command ();
      return;
    }
    add = 1;
    typestring = GNUNET_strdup (GNUNET_GNSRECORD_number_to_typename (
                                  GNUNET_GNSRECORD_TYPE_NICK));
    name = GNUNET_strdup (GNUNET_GNS_EMPTY_LABEL_AT);
    value = GNUNET_strdup (nickstring);
    is_public = 0;
    expirationstring = GNUNET_strdup ("never");
    GNUNET_free (nickstring);
    nickstring = NULL;
  }
 
  if (add)
  {
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == typestring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-t",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    type = GNUNET_GNSRECORD_typename_to_number (typestring);
    if (UINT32_MAX == type)
    {
      fprintf (stderr, _ ("Unsupported type `%s'\n"), typestring);
      ret = 1;
      finish_command ();
      return;
    }
    if ((GNUNET_DNSPARSER_TYPE_SRV == type) ||
        (GNUNET_DNSPARSER_TYPE_TLSA == type) ||
        (GNUNET_DNSPARSER_TYPE_SMIMEA == type) ||
        (GNUNET_DNSPARSER_TYPE_OPENPGPKEY == type))
    {
      fprintf (stderr,
               _ (
                 "For DNS record types `SRV', `TLSA', `SMIMEA' and `OPENPGPKEY'"));
      fprintf (stderr, ", please use a `BOX' record instead\n");
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == value)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-V",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_string_to_value (type, value, &data, &data_size))
    {
      fprintf (stderr,
               _ ("Value `%s' invalid for record type `%s'\n"),
               value,
               typestring);
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == expirationstring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-e",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK != parse_expiration (expirationstring, &etime_is_rel, &etime))
    {
      fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
      ret = 1;
      finish_command ();
      return;
    }
    add_qe = GNUNET_NAMESTORE_records_lookup (ns,
                                              &zone_pkey,
                                              name,
                                              &add_error_cb,
                                              NULL,
                                              &get_existing_record,
                                              NULL);
  }
  if (del)
  {
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("del"));
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("del"));
      ret = 1;
      finish_command ();
      return;
    }
    del_qe = GNUNET_NAMESTORE_records_lookup2 (ns,
                                               &zone_pkey,
                                               name,
                                               &del_lookup_error_cb,
                                               NULL,
                                               &del_monitor,
                                               NULL,
                                               filter_flags);
  }
  if (purge_orphaned)
  {
    list_it = GNUNET_NAMESTORE_zone_iteration_start2 (ns,
                                                      NULL,
                                                      &zone_iteration_error_cb,
                                                      NULL,
                                                      &purge_orphans_iterator,
                                                      NULL,
                                                      &zone_iteration_finished,
                                                      NULL,
                                                      filter_flags);
 
  }
  else if (purge_zone)
  {
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("purge-zone"));
      ret = 1;
      finish_command ();
      return;
    }
    list_it = GNUNET_NAMESTORE_zone_iteration_start2 (ns,
                                                      &zone_pkey,
                                                      &zone_iteration_error_cb,
                                                      NULL,
                                                      &purge_zone_iterator,
                                                      NULL,
                                                      &zone_iteration_finished,
                                                      NULL,
                                                      filter_flags);
 
  }
  else if (list || list_orphaned)
  {
    if (NULL != name)
    {
      if (NULL == ego_name)
      {
        fprintf (stderr,
                 _ ("Missing option `%s' for operation `%s'\n"),
                 "-z",
                 _ ("list"));
        ret = 1;
        finish_command ();
        return;
      }
      get_qe = GNUNET_NAMESTORE_records_lookup (ns,
                                                &zone_pkey,
                                                name,
                                                &lookup_error_cb,
                                                NULL,
                                                &display_record_lookup,
                                                NULL);
    }
    else
      list_it = GNUNET_NAMESTORE_zone_iteration_start2 (ns,
                                                        (NULL == ego_name) ?
                                                        NULL : &zone_pkey,
                                                        &zone_iteration_error_cb
                                                        ,
                                                        NULL,
                                                        &display_record_iterator
                                                        ,
                                                        NULL,
                                                        &zone_iteration_finished
                                                        ,
                                                        NULL,
                                                        filter_flags);
  }
  if (NULL != reverse_pkey)
  {
    struct GNUNET_CRYPTO_BlindablePublicKey pubkey;
 
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("reverse-pkey"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK !=
        GNUNET_CRYPTO_blindable_public_key_from_string (reverse_pkey,
                                                        &pubkey))
    {
      fprintf (stderr,
               _ ("Invalid public key for reverse lookup `%s'\n"),
               reverse_pkey);
      ret = 1;
      finish_command ();
      return;
    }
    reverse_qe = GNUNET_NAMESTORE_zone_to_name (ns,
                                                &zone_pkey,
                                                &pubkey,
                                                &reverse_error_cb,
                                                NULL,
                                                &handle_reverse_lookup,
                                                NULL);
  }
  if (NULL != uri)
  {
    char sh[105];
    char sname[64];
    struct GNUNET_CRYPTO_BlindablePublicKey pkey;
    if (NULL == ego_name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-z",
               _ ("uri"));
      ret = 1;
      finish_command ();
      return;
    }
 
    memset (sh, 0, 105);
    memset (sname, 0, 64);
 
    if ((2 != (sscanf (uri, "gnunet://gns/%58s/%63s", sh, sname))) ||
        (GNUNET_OK !=
         GNUNET_CRYPTO_blindable_public_key_from_string (sh, &pkey)))
    {
      fprintf (stderr, _ ("Invalid URI `%s'\n"), uri);
      ret = 1;
      finish_command ();
      return;
    }
    if (NULL == expirationstring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-e",
               _ ("add"));
      ret = 1;
      finish_command ();
      return;
    }
    if (GNUNET_OK != parse_expiration (expirationstring, &etime_is_rel, &etime))
    {
      fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
      ret = 1;
      finish_command ();
      return;
    }
    memset (&rd, 0, sizeof(rd));
    rd.data = &pkey;
    rd.data_size = GNUNET_CRYPTO_public_key_get_length (&pkey);
    rd.record_type = ntohl (pkey.type);
    rd.expiration_time = etime;
    if (GNUNET_YES == etime_is_rel)
      rd.flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
    if (1 == is_shadow)
      rd.flags |= GNUNET_GNSRECORD_RF_SHADOW;
    if (1 == is_maintenance)
      rd.flags |= GNUNET_GNSRECORD_RF_MAINTENANCE;
    add_qe_uri = GNUNET_NAMESTORE_record_set_store (ns,
                                                    &zone_pkey,
                                                    sname,
                                                    1,
                                                    &rd,
                                                    &add_continuation,
                                                    &add_qe_uri);
  }
  if (monitor)
  {
    zm = GNUNET_NAMESTORE_zone_monitor_start2 (cfg_,
                                               (NULL != ego_name) ?
                                               &zone_pkey : NULL,
                                               GNUNET_YES,
                                               &monitor_error_cb,
                                               NULL,
                                               &display_record_monitor,
                                               NULL,
                                               &sync_cb,
                                               NULL,
                                               filter_flags);
  }
}

References _, add, add_continuation(), add_error_cb(), add_qe, add_qe_uri, data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, del, del_lookup_error_cb(), del_monitor(), del_qe, display_record_iterator(), display_record_lookup(), display_record_monitor(), ego_name, etime, etime_is_rel, GNUNET_GNSRECORD_Data::expiration_time, expirationstring, finish_command(), GNUNET_GNSRECORD_Data::flags, get_existing_record(), get_qe, GNUNET_CRYPTO_blindable_public_key_from_string(), GNUNET_CRYPTO_public_key_get_length(), GNUNET_DNSPARSER_TYPE_OPENPGPKEY, GNUNET_DNSPARSER_TYPE_SMIMEA, GNUNET_DNSPARSER_TYPE_SRV, GNUNET_DNSPARSER_TYPE_TLSA, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_FILTER_INCLUDE_MAINTENANCE, GNUNET_GNSRECORD_FILTER_NONE, GNUNET_GNSRECORD_FILTER_OMIT_PRIVATE, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_MAINTENANCE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_typename_to_number(), GNUNET_NAMESTORE_record_set_store(), GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_records_lookup2(), GNUNET_NAMESTORE_zone_iteration_start2(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_new_array, GNUNET_OK, GNUNET_strdup, GNUNET_YES, handle_reverse_lookup(), include_maintenance, is_maintenance, is_public, is_shadow, list, list_it, list_orphaned, lookup_error_cb(), monitor, monitor_error_cb(), name, RecordSetEntry::next, nickstring, ns, omit_private, parse_expiration(), pkey, pubkey, purge_orphaned, purge_orphans_iterator(), purge_zone, purge_zone_iterator(), rd, rd_count, GNUNET_GNSRECORD_Data::record_type, recordset, replace_cont(), ret, reverse_error_cb(), reverse_pkey, reverse_qe, set_qe, sh, sync_cb(), type, typestring, uri, value, zm, zone_iteration_error_cb(), zone_iteration_finished(), and zone_pkey.

Referenced by id_connect_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

get_identity_for_string()

static int get_identity_for_string ( const char *  str, struct GNUNET_CRYPTO_BlindablePrivateKey *  zk  )

static

FIXME: Check for zTLD?

Definition at line 1841 of file gnunet-namestore.c.

{
  const struct GNUNET_CRYPTO_BlindablePrivateKey *privkey;
  struct GNUNET_CRYPTO_BlindablePublicKey pubkey;
  struct GNUNET_CRYPTO_BlindablePublicKey ego_pubkey;
  struct EgoEntry *ego_entry;
 
  if (GNUNET_OK == GNUNET_CRYPTO_blindable_public_key_from_string (str,
                                                                   &pubkey))
  {
    for (ego_entry = ego_head;
         NULL != ego_entry; ego_entry = ego_entry->next)
    {
      privkey = GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
      GNUNET_IDENTITY_ego_get_public_key (ego_entry->ego, &ego_pubkey);
      if (0 == memcmp (&ego_pubkey, &pubkey, sizeof (pubkey)))
      {
        *zk = *privkey;
        return GNUNET_OK;
      }
    }
  }
  else
  {
    for (ego_entry = ego_head; NULL != ego_entry; ego_entry = ego_entry->next)
    {
      if (0 != strcmp (str, ego_entry->identifier))
        continue;
      *zk = *GNUNET_IDENTITY_ego_get_private_key (ego_entry->ego);
      return GNUNET_OK;
    }
  }
  return GNUNET_NO;
}

References EgoEntry::ego, ego_head, GNUNET_CRYPTO_blindable_public_key_from_string(), GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_NO, GNUNET_OK, EgoEntry::identifier, EgoEntry::next, pubkey, and str.

Referenced by process_command_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

id_connect_cb()

static void id_connect_cb ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  ego_name_tmp  )

static

Function called with ALL of the egos known to the identity service, used on startup if the user did not specify a zone on the command-line.

Once the iteration is done (ego is NULL), we ask for the default ego for "namestore".

Parameters

cls	a struct GNUNET_CONFIGURATION_Handle
ego	an ego, NULL for end of iteration
ctx	NULL
name	name associated with ego

Definition at line 2057 of file gnunet-namestore.c.

{
  struct GNUNET_CRYPTO_BlindablePublicKey pk;
  struct EgoEntry *ego_entry;
 
  (void) ctx;
  (void) ego_name_tmp;
  if ((NULL != ego_name_tmp) && (NULL != ego))
  {
    ego_entry = GNUNET_new (struct EgoEntry);
    GNUNET_IDENTITY_ego_get_public_key (ego, &pk);
    ego_entry->ego = ego;
    ego_entry->identifier = GNUNET_strdup (ego_name_tmp);
    GNUNET_CONTAINER_DLL_insert_tail (ego_head,
                                      ego_tail,
                                      ego_entry);
    if ((NULL != ego_name) && (NULL != ego_name_tmp) &&
        (0 == strcmp (ego_name, ego_name_tmp)))
      zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
    return;
  }
  if (NULL != ego)
    return;
  if (read_from_stdin)
  {
    process_command_stdin ();
    return;
  }
  run_with_zone_pkey (cfg);
}

References cfg, ctx, EgoEntry::ego, ego_head, ego_name, ego_tail, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_new, GNUNET_strdup, EgoEntry::identifier, pk, process_command_stdin(), read_from_stdin, run_with_zone_pkey(), and zone_pkey.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  _cfg  )

static

Main function that will be run.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg	configuration

Definition at line 2101 of file gnunet-namestore.c.

{
  (void) cls;
  (void) args;
  (void) cfgfile;
  cfg = _cfg;
  if (NULL != args[0])
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ ("Superfluous command line arguments (starting with `%s') ignored\n"),
      args[0]);
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
  ns = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == ns)
  {
    fprintf (stderr, _ ("Failed to connect to namestore\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  idh = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, (void *) cfg);
  if (NULL == idh)
  {
    ret = -1;
    fprintf (stderr, _ ("Cannot connect to identity service\n"));
    GNUNET_SCHEDULER_shutdown ();
  }
}

References _, cfg, do_shutdown, GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_connect(), GNUNET_log, GNUNET_NAMESTORE_connect(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), id_connect_cb(), idh, ns, and ret.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function for gnunet-namestore.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 2142 of file gnunet-namestore.c.

{
  int lret;
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_flag ('a', "add", gettext_noop ("add record"), &add),
    GNUNET_GETOPT_option_flag ('d',
                               "delete",
                               gettext_noop ("delete record"),
                               &del),
    GNUNET_GETOPT_option_flag ('D',
                               "display",
                               gettext_noop ("display records"),
                               &list),
    GNUNET_GETOPT_option_flag ('S',
                               "from-stdin",
                               gettext_noop ("read commands from stdin"),
                               &read_from_stdin),
    GNUNET_GETOPT_option_string (
      'e',
      "expiration",
      "TIME",
      gettext_noop (
        "expiration time for record to use (for adding only), \"never\" is possible"),
      &expirationstring),
    GNUNET_GETOPT_option_string ('i',
                                 "nick",
                                 "NICKNAME",
                                 gettext_noop (
                                   "set the desired nick name for the zone"),
                                 &nickstring),
    GNUNET_GETOPT_option_flag ('m',
                               "monitor",
                               gettext_noop (
                                 "monitor changes in the namestore"),
                               &monitor),
    GNUNET_GETOPT_option_string ('n',
                                 "name",
                                 "NAME",
                                 gettext_noop (
                                   "name of the record to add/delete/display"),
                                 &name),
    GNUNET_GETOPT_option_flag ('r',
                               "recordline",
                               gettext_noop ("Output in recordline format"),
                               &output_recordline),
    GNUNET_GETOPT_option_string ('Z',
                                 "zone-to-name",
                                 "KEY",
                                 gettext_noop (
                                   "determine our name for the given KEY"),
                                 &reverse_pkey),
    GNUNET_GETOPT_option_string ('t',
                                 "type",
                                 "TYPE",
                                 gettext_noop (
                                   "type of the record to add/delete/display"),
                                 &typestring),
    GNUNET_GETOPT_option_string ('u',
                                 "uri",
                                 "URI",
                                 gettext_noop ("URI to import into our zone"),
                                 &uri),
    GNUNET_GETOPT_option_string ('V',
                                 "value",
                                 "VALUE",
                                 gettext_noop (
                                   "value of the record to add/delete"),
                                 &value),
    GNUNET_GETOPT_option_flag ('p',
                               "public",
                               gettext_noop ("create or list public record"),
                               &is_public),
    GNUNET_GETOPT_option_flag ('o',
                               "omit-private",
                               gettext_noop ("omit private records"),
                               &omit_private),
    GNUNET_GETOPT_option_flag ('T',
                               "include-maintenance",
                               gettext_noop (
                                 "do not filter maintenance records"),
                               &include_maintenance),
    GNUNET_GETOPT_option_flag ('P',
                               "purge-orphans",
                               gettext_noop (
                                 "purge namestore of all orphans"),
                               &purge_orphaned),
    GNUNET_GETOPT_option_flag ('O',
                               "list-orphans",
                               gettext_noop (
                                 "show private key for orphaned records for recovery using `gnunet-identity -C -P <key>'. Use in combination with --display"),
                               &list_orphaned),
    GNUNET_GETOPT_option_flag ('X',
                               "purge-zone-records",
                               gettext_noop (
                                 "delete all records in specified zone"),
                               &purge_zone),
    GNUNET_GETOPT_option_uint ('B',
                               "batch-size",
                               "NUMBER",
                               gettext_noop (
                                 "number of records to buffer and send as batch (for use with --from-stdin)"),
                               &max_batch_size),
    GNUNET_GETOPT_option_flag (
      's',
      "shadow",
      gettext_noop (
        "create shadow record (only valid if all other records of the same type have expired)"),
      &is_shadow),
    GNUNET_GETOPT_option_flag (
      'M',
      "maintenance",
      gettext_noop (
        "create maintenance record (e.g TOMBSTONEs)"),
      &is_maintenance),
    GNUNET_GETOPT_option_string ('z',
                                 "zone",
                                 "EGO",
                                 gettext_noop (
                                   "name of the ego controlling the zone"),
                                 &ego_name),
    GNUNET_GETOPT_OPTION_END };
 
 
  is_public = -1;
  is_shadow = -1;
  is_maintenance = -1;
  GNUNET_log_setup ("gnunet-namestore", "WARNING", NULL);
  if (GNUNET_OK !=
      (lret = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                                  argc,
                                  argv,
                                  "gnunet-namestore",
                                  _ ("GNUnet zone manipulation tool"),
                                  options,
                                  &run,
                                  NULL)))
  {
    // FIXME
    // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
    return lret;
  }
  // FIXME
  // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
  return ret;
}

References _, add, del, ego_name, expirationstring, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_GETOPT_option_uint(), GNUNET_log_setup(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), include_maintenance, is_maintenance, is_public, is_shadow, list, list_orphaned, max_batch_size, monitor, name, nickstring, omit_private, options, output_recordline, purge_orphaned, purge_zone, read_from_stdin, ret, reverse_pkey, run(), typestring, uri, and value.

Here is the call graph for this function:

Variable Documentation

ns

struct GNUNET_NAMESTORE_Handle* ns

static

Handle to the namestore.

Definition at line 115 of file gnunet-namestore.c.

Referenced by batch_insert_recordinfo(), del_monitor(), do_shutdown(), get_existing_record(), purge_next_record(), run(), and run_with_zone_pkey().

zone_pkey

struct GNUNET_CRYPTO_BlindablePrivateKey zone_pkey

static

Private key for the our zone.

Definition at line 120 of file gnunet-namestore.c.

Referenced by batch_insert_recordinfo(), del_monitor(), get_existing_record(), id_connect_cb(), process_command_stdin(), reset_handles(), and run_with_zone_pkey().

idh

struct GNUNET_IDENTITY_Handle* idh

static

Identity service handle.

Definition at line 125 of file gnunet-namestore.c.

Referenced by do_shutdown(), and run().

ego_name

char* ego_name

static

Name of the ego controlling the zone.

Definition at line 130 of file gnunet-namestore.c.

Referenced by handle_reverse_lookup(), id_connect_cb(), main(), reset_handles(), and run_with_zone_pkey().

add_qe_uri

struct GNUNET_NAMESTORE_QueueEntry* add_qe_uri

static

Queue entry for the 'add-uri' operation.

Definition at line 135 of file gnunet-namestore.c.

Referenced by reset_handles(), and run_with_zone_pkey().

add_qe

struct GNUNET_NAMESTORE_QueueEntry* add_qe

static

Queue entry for the 'add' operation.

Definition at line 140 of file gnunet-namestore.c.

Referenced by add_error_cb(), get_existing_record(), reset_handles(), and run_with_zone_pkey().

get_qe

struct GNUNET_NAMESTORE_QueueEntry* get_qe

static

Queue entry for the 'lookup' operation.

Definition at line 145 of file gnunet-namestore.c.

Referenced by display_record_lookup(), lookup_error_cb(), reset_handles(), and run_with_zone_pkey().

reverse_qe

struct GNUNET_NAMESTORE_QueueEntry* reverse_qe

static

Queue entry for the 'reverse lookup' operation (in combination with a name).

Definition at line 150 of file gnunet-namestore.c.

Referenced by handle_reverse_lookup(), reset_handles(), reverse_error_cb(), and run_with_zone_pkey().

marked_head

struct MarkedRecord* marked_head

static

Marked record list.

Definition at line 155 of file gnunet-namestore.c.

Referenced by collect_orphans(), collect_zone_records_to_purge(), purge_next_record(), and reset_handles().

marked_tail

struct MarkedRecord* marked_tail

static

Marked record list.

Definition at line 160 of file gnunet-namestore.c.

Referenced by collect_orphans(), collect_zone_records_to_purge(), and purge_next_record().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

Configuration handle.

Handle to our configuration.

Definition at line 165 of file gnunet-namestore.c.

Referenced by id_connect_cb(), process_command_stdin(), and run().

ego_head

struct EgoEntry* ego_head

static

Ego list.

Definition at line 170 of file gnunet-namestore.c.

Referenced by collect_orphans(), display_record(), do_shutdown(), get_identity_for_string(), and id_connect_cb().

ego_tail

struct EgoEntry* ego_tail

static

Ego list.

Definition at line 175 of file gnunet-namestore.c.

Referenced by id_connect_cb().

list_it

struct GNUNET_NAMESTORE_ZoneIterator* list_it

static

List iterator for the 'list' operation.

Definition at line 180 of file gnunet-namestore.c.

Referenced by display_record_iterator(), purge_orphans_iterator(), purge_zone_iterator(), reset_handles(), run_with_zone_pkey(), zone_iteration_error_cb(), and zone_iteration_finished().

read_from_stdin

int read_from_stdin

static

Run in read from stdin mode.

Definition at line 185 of file gnunet-namestore.c.

Referenced by finish_command(), id_connect_cb(), and main().

list

int list

static

Desired action is to list records.

Definition at line 190 of file gnunet-namestore.c.

Referenced by main(), reset_handles(), and run_with_zone_pkey().

add

int add

static

Desired action is to add a record.

Definition at line 195 of file gnunet-namestore.c.

Referenced by check_ipv4_listed(), check_notify_client(), main(), notify_client(), notify_client_external_ipv4_change(), notify_clients(), notify_clients_stun_change(), notify_monitors_external_ipv4_change(), and run_with_zone_pkey().

del

int del

static

Desired action is to remove a record.

Definition at line 200 of file gnunet-namestore.c.

Referenced by forward_resolution(), GNUNET_ABD_delegate_issue(), main(), run_with_zone_pkey(), and send_lookup_response().

is_public

int is_public

static

Is record public (opposite of GNUNET_GNSRECORD_RF_PRIVATE)

Definition at line 205 of file gnunet-namestore.c.

Referenced by get_existing_record(), GNUNET_MESSENGER_create_room_key(), main(), reset_handles(), and run_with_zone_pkey().

is_shadow

int is_shadow

static

Is record a shadow record (GNUNET_GNSRECORD_RF_SHADOW)

Definition at line 210 of file gnunet-namestore.c.

Referenced by get_existing_record(), main(), reset_handles(), and run_with_zone_pkey().

is_maintenance

int is_maintenance

static

Is record a maintenance record (GNUNET_GNSRECORD_RF_MAINTENANCE)

Definition at line 215 of file gnunet-namestore.c.

Referenced by get_existing_record(), main(), reset_handles(), and run_with_zone_pkey().

omit_private

int omit_private

static

Filter private records.

Definition at line 220 of file gnunet-namestore.c.

Referenced by main(), and run_with_zone_pkey().

output_recordline

int output_recordline

static

Output in recordline format.

Definition at line 225 of file gnunet-namestore.c.

Referenced by display_record(), and main().

purge_zone

int purge_zone

static

Purge zone contents.

Definition at line 231 of file gnunet-namestore.c.

Referenced by main(), reset_handles(), run_with_zone_pkey(), and zone_iteration_finished().

include_maintenance

int include_maintenance

static

Do not filter maintenance records.

Definition at line 236 of file gnunet-namestore.c.

Referenced by main(), and run_with_zone_pkey().

purge_orphaned

int purge_orphaned

static

Purge orphaned records.

Definition at line 241 of file gnunet-namestore.c.

Referenced by main(), run_with_zone_pkey(), and zone_iteration_finished().

list_orphaned

int list_orphaned

static

List records and zone keys of orphaned records.

Definition at line 246 of file gnunet-namestore.c.

Referenced by display_record(), main(), and run_with_zone_pkey().

del_qe

struct GNUNET_NAMESTORE_QueueEntry* del_qe

static

Queue entry for the 'del' operation.

Definition at line 251 of file gnunet-namestore.c.

Referenced by del_continuation(), del_lookup_error_cb(), del_monitor(), marked_deleted(), purge_next_record(), reset_handles(), and run_with_zone_pkey().

set_qe

struct GNUNET_NAMESTORE_QueueEntry* set_qe

static

Queue entry for the 'set/replace' operation.

Definition at line 256 of file gnunet-namestore.c.

Referenced by batch_insert_recordinfo(), replace_cont(), reset_handles(), and run_with_zone_pkey().

ns_qe

struct GNUNET_NAMESTORE_QueueEntry* ns_qe

static

Queue entry for begin/commit.

Definition at line 261 of file gnunet-namestore.c.

Referenced by do_shutdown().

name

char* name

static

Name of the records to add/list/remove.

Definition at line 266 of file gnunet-namestore.c.

Referenced by del_monitor(), display_record(), get_existing_record(), main(), reset_handles(), and run_with_zone_pkey().

value

char* value

static

Value of the record to add/remove.

Definition at line 271 of file gnunet-namestore.c.

Referenced by add_get_request_to_pending(), add_global_addresses(), add_known_to_bloom(), add_section_contents(), add_sections(), add_setter_action(), attr_in_claims_request(), auto_conf_iter(), bandwidth_stats_iterator(), bind_loose_channel(), build_result_set(), bulk_tx_start(), call_iterator(), cancel_pending_request(), change_peer_respect(), channel_destroy_iterator(), check_connection_quality(), check_known_address(), check_known_challenge(), check_validation_request_pending(), check_vectors(), clean_local_client(), clean_request(), cleanup_channel(), cleanup_destination(), cleanup_hashmap(), cleanup_url_map(), clear_linked_hash(), client_release_ports(), close_files_iter(), collector(), compare_entries(), compute_service_response(), compute_square_sum_mpi_elements(), con_val_iter(), consume_cont(), contains_address(), cookie_identity_interpretation(), copy_element_cb(), copy_element_cb(), copy_element_cb(), copy_element_cb(), copy_entry(), create_randomized_element_iterator(), create_response(), debug_channel(), decrementBit(), del_monitor(), delete_linked_hash(), delete_value(), destroy_active_client_request(), destroy_channel_cb(), destroy_elements_iterator(), destroy_elements_iterator(), destroy_elements_iterator(), destroy_it(), destroy_iterator_cb(), destroy_key_to_element_iter(), destroy_key_to_element_iter(), destroy_paths_now(), destroy_port_cb(), destroy_remaining_channels(), destroy_tunnels_now(), determinate_avg_element_size_iterator(), determinate_done_message_iterator(), disconnect_and_free_peer_entry(), dns_string_to_value(), dns_value_to_string(), do_flood(), do_notify(), dv_neighbour_selection(), dv_neighbour_transmission(), escape_name(), execute_get(), expire_blocks(), filter_all(), filter_all(), filtered_map_initialization(), filtered_map_initialization(), find_advertisable_hello(), find_by_message_uuid(), find_by_unique_id(), find_closest(), find_linked_hash(), find_result_set(), find_store_peer(), find_trees(), flush_respect(), format_help(), forward_reply(), free_ack_cummulator_cb(), free_backtalker_cb(), free_carriers_cb(), free_dv_routes_cb(), free_ego(), free_element_cb(), free_element_cb(), free_element_cb(), free_element_cb(), free_entry(), free_item(), free_iterate(), free_neighbour_cb(), free_peer(), free_pending_ack_cb(), free_reassembly_cb(), free_request_it(), free_result(), free_service_record(), free_subnets_cb(), free_sug_handle(), free_validation_state_cb(), free_value(), free_value_cb(), free_values_iter(), free_waiting_entry(), full_sync_plausibility_check(), get_all_peers_iterator(), get_all_tunnels_iterator(), get_cb(), get_connection_delete_it(), get_iterator(), get_lt_delete_it(), get_lt_delete_it(), get_peer_delete_it(), get_queue_delete_it(), get_queue_delete_it(), get_queue_delete_it(), get_rand_peer_iterator(), get_receiver_delete_it(), get_result_present(), get_sender_delete_it(), get_stream_delete_it(), get_url_parameter_copy(), getopt_set_keywords(), getopt_set_metadata(), GNUNET_CONFIGURATION_append_value_filename(), GNUNET_CONFIGURATION_config_tool_run(), GNUNET_CONFIGURATION_deserialize(), GNUNET_CONFIGURATION_get_value_choice(), GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_remove_value_filename(), GNUNET_CONFIGURATION_set_value_string(), GNUNET_CONTAINER_multihashmap32_contains_value(), GNUNET_CONTAINER_multihashmap32_iterator_next(), GNUNET_CONTAINER_multihashmap32_put(), GNUNET_CONTAINER_multihashmap32_remove(), GNUNET_CONTAINER_multihashmap_contains_value(), GNUNET_CONTAINER_multihashmap_iterator_next(), GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CONTAINER_multipeermap_contains_value(), GNUNET_CONTAINER_multipeermap_iterator_next(), GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multishortmap_contains_value(), GNUNET_CONTAINER_multishortmap_iterator_next(), GNUNET_CONTAINER_multishortmap_put(), GNUNET_CONTAINER_multishortmap_remove(), GNUNET_CONTAINER_multiuuidmap_contains_value(), GNUNET_CONTAINER_multiuuidmap_iterator_next(), GNUNET_CONTAINER_multiuuidmap_put(), GNUNET_CONTAINER_multiuuidmap_remove(), GNUNET_NETWORK_socket_disable_corking(), GNUNET_PEERSTORE_store(), GNUNET_STATISTICS_set(), GNUNET_TESTING_set_label(), GSF_cadet_release_clients(), handle_ack(), handle_ack_by_sender(), handle_alice_client_message(), handle_alice_client_message(), handle_bob_client_message(), handle_bob_client_message(), handle_set(), header_iterator(), header_iterator(), heap_plugin_get_expiration(), heap_plugin_get_replication(), heap_plugin_get_zero_anonymity(), heap_plugin_put(), host_processor(), http_recv_header_cb(), increment_value(), incrementBit(), init_key_to_element_iterator(), init_key_to_element_iterator(), initialize_map_unfiltered(), initialize_map_unfiltered(), inspect_attrs(), it_announcement_store_key(), it_epoch_store_keys(), it_find_announcement_with_most_members(), it_find_group_with_most_members(), it_find_valid_announcement_with_most_members(), it_find_valid_group_with_most_members(), it_group_store_key(), it_iterate_epoch_member(), it_move_epoch_groups_from_previous_epoch(), it_room_store_keys(), it_search_epoch_member(), it_update_epoch_member(), iterate_cancel_action_by(), iterate_channels_cb(), iterate_close_room(), iterate_copy_history(), iterate_destroy_action(), iterate_destroy_announcement(), iterate_destroy_contacts(), iterate_destroy_entries(), iterate_destroy_epoch(), iterate_destroy_group(), iterate_destroy_hashs(), iterate_destroy_link(), iterate_destroy_members(), iterate_destroy_message(), iterate_destroy_messages(), iterate_destroy_operations(), iterate_destroy_peers(), iterate_destroy_room(), iterate_destroy_rooms(), iterate_destroy_session(), iterate_destroy_subscription(), iterate_destroy_subscription(), iterate_destroy_tunnels(), iterate_epoch_announcement_invalidation(), iterate_epoch_group_invalidation(), iterate_find_member(), iterate_find_room(), iterate_flag_for_cleanup_discourse_message(), iterate_free_values(), iterate_load_next_member_sessions(), iterate_load_next_session(), iterate_local_members(), iterate_member_sessions_it(), iterate_message_control(), iterate_next_member_ids(), iterate_reachables(), iterate_reset_room(), iterate_room_epoch_member_invalidation(), iterate_save_entries(), iterate_save_epochs(), iterate_save_links(), iterate_save_member_session_history_hentries(), iterate_save_members(), iterate_save_messages(), iterate_save_operations(), iterate_save_peers(), iterate_save_session(), iterate_search_session(), iterate_send_room_message(), iterate_store_members_it(), iterate_sync_member_contacts(), iterate_sync_session_contact(), iterate_zones(), iterator_bf_create(), iterator_bf_create(), iterator_bf_reduce(), iterator_bf_reduce(), jwt_parse_attributes(), link_room_message(), log_namespaces(), log_nodes(), lookup_queue_it(), main(), make_nv(), migrate_and_drop_keywords(), migrate_and_drop_metadata(), move_to_pending(), move_to_queue(), mpi_to_sexp(), neighbour_delete(), nibble_to_regex(), notify_client_about_session(), notify_client_connect_info(), notify_client_queues(), notify_tunnel_up_cb(), num_to_regex(), op_get_element_iterator(), op_get_element_iterator(), open_port_cb(), parse_record(), parse_record_data(), peermap_clear_iterator(), PEERSTORE_create_record_mq_envelope(), peerstore_sqlite_store_record(), pending_reversals_delete_it(), pending_reversals_delete_it(), prepare_ibf_iterator(), prepare_ibf_iterator(), print_option(), print_version(), printer(), printer_watch(), process(), process_client_result(), process_reply(), process_reply(), process_result_with_request(), process_stat(), process_stat_in(), process_stats(), process_update_node(), put_cb(), reachability_iterator(), read_service_conf(), regex_cancel_dht_get(), regex_free_result(), regex_result_iterator(), register_notify(), remove_all(), remove_by_unique_id(), remove_global_addresses(), remove_iterator(), remove_iterator(), remove_iterator(), reschedule_hellos(), reset_handles(), resume_communicators(), rsa_sign_mpi(), run_with_zone_pkey(), schedule_current_round(), search_result_free(), search_result_freeze_probes(), search_result_resume_probes(), search_result_stop(), search_result_suspend(), send_full_element_iterator(), send_full_element_iterator(), send_missing_full_elements_iter(), send_missing_full_elements_iter(), send_offers_iterator(), send_offers_iterator(), send_simple_cb(), send_simple_cb(), send_simple_cb(), set_absolute_time(), set_attributes_from_idtoken(), set_base32(), set_cont(), set_filename(), set_json(), set_one(), set_relative_time(), set_string(), set_timestamp(), set_timetravel_time(), set_uint(), set_uint16(), set_ulong(), set_value(), signal_result_resume(), socket_set_nodelay(), start_carriers(), start_subnets(), stats_iterator(), stop_peer_request(), store_and_free_entries(), store_and_free_entries(), store_peer_presistently_iterator(), stun_attr2str(), stun_msg2str(), test_exist_cb(), test_result_present(), tld_iter(), transmit_client_response(), transmit_client_response(), transmit_suggestion(), try_add_peers(), try_combine_recent(), update_config(), update_flood_times(), update_iterator(), update_sre_result_maps(), url_iterator(), valid_peer_iterator(), verify_store_peer(), write_item(), and zone_to_name().

uri

char* uri

static

URI to import.

Definition at line 276 of file gnunet-namestore.c.

Referenced by main(), reset_handles(), and run_with_zone_pkey().

reverse_pkey

char* reverse_pkey

static

Reverse lookup to perform.

Definition at line 281 of file gnunet-namestore.c.

Referenced by handle_reverse_lookup(), main(), reverse_error_cb(), and run_with_zone_pkey().

typestring

char* typestring

static

Type of the record to add/remove, NULL to remove all.

Definition at line 286 of file gnunet-namestore.c.

Referenced by del_monitor(), display_record(), display_records_from_block(), main(), reset_handles(), and run_with_zone_pkey().

expirationstring

char* expirationstring

static

Desired expiration time.

Definition at line 291 of file gnunet-namestore.c.

Referenced by main(), reset_handles(), and run_with_zone_pkey().

nickstring

char* nickstring

static

Desired nick name.

Definition at line 296 of file gnunet-namestore.c.

Referenced by main(), and run_with_zone_pkey().

ret

int ret

static

Global return value.

Definition at line 301 of file gnunet-namestore.c.

Referenced by add_continuation(), add_error_cb(), del_lookup_error_cb(), del_monitor(), get_existing_record(), main(), process_command_stdin(), purge_next_record(), replace_cont(), run(), run_with_zone_pkey(), zone_iteration_error_cb(), and zone_iteration_finished().

type

uint32_t type

static

Type string converted to DNS type value.

Definition at line 306 of file gnunet-namestore.c.

Referenced by abd_number_to_typename(), abd_string_to_value(), abd_value_to_string(), add_record(), add_setter_action(), add_to_meta_counter(), attr_collect(), auto_config_cb(), basic_number_to_typename(), basic_string_to_value(), basic_value_to_string(), block_plugin_dht_check_block(), block_plugin_dht_check_query(), block_plugin_dht_check_reply(), block_plugin_dht_create_group(), block_plugin_dht_get_key(), block_plugin_dns_check_block(), block_plugin_dns_check_query(), block_plugin_dns_check_reply(), block_plugin_dns_create_group(), block_plugin_dns_get_key(), block_plugin_fs_check_block(), block_plugin_fs_check_query(), block_plugin_fs_check_reply(), block_plugin_fs_create_group(), block_plugin_fs_get_key(), block_plugin_gns_check_block(), block_plugin_gns_check_query(), block_plugin_gns_check_reply(), block_plugin_gns_create_group(), block_plugin_gns_get_key(), block_plugin_regex_check_block(), block_plugin_regex_check_query(), block_plugin_regex_check_reply(), block_plugin_regex_create_group(), block_plugin_regex_get_key(), block_plugin_revocation_check_block(), block_plugin_revocation_check_query(), block_plugin_revocation_check_reply(), block_plugin_revocation_get_key(), block_plugin_seti_test_check_block(), block_plugin_seti_test_check_query(), block_plugin_seti_test_check_reply(), block_plugin_seti_test_get_key(), block_plugin_setu_test_check_block(), block_plugin_setu_test_check_query(), block_plugin_setu_test_check_reply(), block_plugin_setu_test_get_key(), block_plugin_template_create_group(), block_plugin_test_check_block(), block_plugin_test_check_query(), block_plugin_test_check_reply(), block_plugin_test_create_group(), block_plugin_test_get_key(), block_proc(), cadet_reply_proc(), callback_operation(), change_service(), check_key_type(), check_p2p_put(), child_completed_callback(), child_completed_callback(), client_response_handler(), conversation_number_to_typename(), conversation_string_to_value(), conversation_value_to_string(), cred_collect(), display_record(), dns_number_to_typename(), dns_string_to_value(), dns_value_to_string(), ego_create(), execute_get(), expired_processor(), find_full_data(), find_plugin(), for_matching_monitors(), gather_uri_data(), GDS_CLIENTS_process_get(), GDS_DATACACHE_get_closest(), GDS_DATACACHE_handle_get(), GDS_NEIGHBOURS_handle_get(), GDS_ROUTING_add(), get_app(), get_audiobin(), get_callback(), get_cb(), get_coder(), get_existing_record(), get_resp_callback(), get_result_iterator(), get_type(), get_typed(), getopt_set_metadata(), gns_is_critical(), gns_number_to_typename(), gns_string_to_value(), gns_value_to_string(), GNUNET_BLOCK_check_block(), GNUNET_BLOCK_check_query(), GNUNET_BLOCK_check_reply(), GNUNET_BLOCK_get_key(), GNUNET_BLOCK_GROUP_bf_create(), GNUNET_BLOCK_group_create(), GNUNET_CADET_drop_message(), GNUNET_CRYPTO_blinded_key_signature_get_length_by_type(), GNUNET_DATACACHE_get(), GNUNET_DATACACHE_get_closest(), GNUNET_DATASTORE_get_key(), GNUNET_DATASTORE_get_zero_anonymity(), GNUNET_DATASTORE_put(), GNUNET_DHT_get_start(), GNUNET_DHT_monitor_start(), GNUNET_DHT_put(), GNUNET_FS_meta_data_delete(), GNUNET_FS_meta_data_get_by_type(), GNUNET_FS_meta_data_get_first_by_types(), GNUNET_FS_meta_data_insert(), GNUNET_GNS_lookup(), GNUNET_GNS_lookup_limited(), GNUNET_GNS_lookup_with_tld(), GNUNET_GNSRECORD_data_from_identity(), GNUNET_GNSRECORD_identity_from_data(), GNUNET_GNSRECORD_is_critical(), GNUNET_GNSRECORD_is_zonekey_type(), GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_value_to_string(), GNUNET_MQ_msg_(), GNUNET_MQ_msg_nested_mh_(), GNUNET_MQ_preference_to_string(), GNUNET_NETWORK_socket_create(), GNUNET_NT_scanner_get_type(), GNUNET_OS_process_status(), GNUNET_OS_process_wait_status(), GNUNET_PQ_exec_sql(), GNUNET_RECLAIM_attribute_list_add(), GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_attribute_number_to_typename(), GNUNET_RECLAIM_attribute_string_to_value(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_credential_new(), GNUNET_RECLAIM_credential_number_to_typename(), GNUNET_RECLAIM_credential_string_to_value(), GNUNET_RECLAIM_credential_value_to_string(), GNUNET_RECLAIM_presentation_new(), GNUNET_RECLAIM_presentation_number_to_typename(), GNUNET_RECLAIM_presentation_string_to_value(), GNUNET_RECLAIM_presentation_value_to_string(), GSF_cadet_query(), GSF_pending_request_create_(), handle_auto_result(), handle_client_accept(), handle_client_start_search(), handle_datastore_reply(), handle_dht_p2p_get(), handle_dht_reply(), handle_dht_response(), handle_get_zero_anonymity(), handle_local_data(), handle_p2p_put(), handle_p2p_reply(), handle_reply(), handle_result(), heap_plugin_get(), heap_plugin_get_closest(), heap_plugin_get_key(), heap_plugin_get_zero_anonymity(), heap_plugin_put(), initialize_network_handle(), insert_pending_message(), item_printer(), item_printer(), iter_finished(), jwt_number_to_typename(), jwt_string_to_value(), jwt_value_to_string(), main(), maint_child_death(), maint_child_death(), maint_child_death(), match_full_data(), merge_helper(), messenger_number_to_typename(), messenger_string_to_value(), messenger_value_to_string(), meta_printer(), number_to_typename(), pabc_number_to_typename(), pabc_string_to_value(), pabc_value_to_string(), pack(), parse(), parse_attr(), parse_credential(), postgres_plugin_get(), postgres_plugin_get_closest(), postgres_plugin_get_key(), postgres_plugin_get_zero_anonymity(), postgres_plugin_put(), process_client_result(), process_dht_put_content(), process_kblock_for_unindex(), process_local_reply(), process_migration_content(), process_status(), put_callback(), queue_send_msg(), quota_processor(), refresh_bloomfilter(), repl_proc(), repl_proc(), resolve_and_cache(), run_with_zone_pkey(), send_message(), sqlite_plugin_get(), sqlite_plugin_get_closest(), sqlite_plugin_get_key(), sqlite_plugin_get_zero_anonymity(), sqlite_plugin_put(), start_operation(), string_to_value(), stun_get_mapped(), submit_request(), transmit_item(), try_handle_plaintext(), try_handle_plaintext(), try_handle_plaintext(), try_transmission(), type_match(), unindex_process(), union_accept(), use_store_operation(), value_to_string(), and work_test().

data

void* data

static

Value in binary format.

Definition at line 311 of file gnunet-namestore.c.

Referenced by del_monitor(), display_record(), get_existing_record(), process_command_stdin(), reset_handles(), and run_with_zone_pkey().

data_size

size_t data_size

static

Number of bytes in data.

Definition at line 316 of file gnunet-namestore.c.

Referenced by abd_string_to_value(), abd_value_to_string(), add_dns_result(), add_host(), basic_string_to_value(), basic_value_to_string(), buffer_append(), buffer_init(), cadet_reply_proc(), check_pkey(), consistency_iter(), consume_ticket(), conversation_string_to_value(), conversation_value_to_string(), count_and_separate_strings(), create_string_array(), del_monitor(), display_record(), display_records_from_block(), dns_string_to_value(), dns_value_to_string(), dv_hmac(), filter_tickets_cb(), forward_resolution(), GDS_CLIENTS_handle_reply(), GDS_helper_sign_path(), GDS_NEIGHBOURS_handle_reply(), get_existing_record(), get_records_and_call_iterator(), gns_string_to_value(), gns_value_to_string(), GNUNET_ABD_delegate_deserialize(), GNUNET_CONFIGURATION_get_data(), GNUNET_DHT_verify_path(), GNUNET_DNSPARSER_bin_to_hex(), GNUNET_DNSPARSER_hex_to_bin(), GNUNET_FS_meta_data_delete(), GNUNET_FS_meta_data_insert(), GNUNET_GNSRECORD_data_from_identity(), GNUNET_GNSRECORD_identity_from_data(), GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_value_to_string(), GNUNET_NAT_stun_handle_packet(), GNUNET_RECLAIM_attribute_deserialize(), GNUNET_RECLAIM_attribute_list_add(), GNUNET_RECLAIM_attribute_list_deserialize(), GNUNET_RECLAIM_attribute_new(), GNUNET_RECLAIM_attribute_serialize(), GNUNET_RECLAIM_attribute_serialize_get_size(), GNUNET_RECLAIM_attribute_string_to_value(), GNUNET_RECLAIM_attribute_value_to_string(), GNUNET_RECLAIM_credential_deserialize(), GNUNET_RECLAIM_credential_list_deserialize(), GNUNET_RECLAIM_credential_new(), GNUNET_RECLAIM_credential_serialize(), GNUNET_RECLAIM_credential_serialize_get_size(), GNUNET_RECLAIM_credential_string_to_value(), GNUNET_RECLAIM_credential_value_to_string(), GNUNET_RECLAIM_presentation_deserialize(), GNUNET_RECLAIM_presentation_list_deserialize(), GNUNET_RECLAIM_presentation_new(), GNUNET_RECLAIM_presentation_serialize(), GNUNET_RECLAIM_presentation_serialize_get_size(), GNUNET_RECLAIM_presentation_string_to_value(), GNUNET_RECLAIM_presentation_value_to_string(), handle_delegate_collection_cb(), handle_gns2dns_result(), handle_gns_resolution_result(), handle_gns_response(), issue_ticket(), item_printer(), item_printer(), iter_finished(), jwt_get_expiration(), jwt_get_issuer(), jwt_parse_attributes(), jwt_string_to_value(), jwt_value_to_string(), lookup_authz_cb(), lookup_nick_it(), lookup_redirect_uri_result(), merge_helper(), merge_with_nick_records(), messenger_string_to_value(), messenger_value_to_string(), missing_zone_creation_cont(), namestore_flat_store_records(), namestore_postgres_store_records(), namestore_sqlite_store_records(), pabc_string_to_value(), pabc_value_to_string(), parse(), parse_attr(), parse_credential(), parse_result_call_iterator(), play(), process_command_stdin(), process_lookup_result(), process_parallel_lookup_result(), read_stdio(), record(), recursive_gns2dns_resolution(), reply_to_dns(), result_processor(), run_with_zone_pkey(), rvk_move_attr_cb(), sqlite_plugin_del(), store_and_free_entries(), string_to_value(), transmit_call_audio(), transmit_phone_audio(), update_tickets(), and value_to_string().

etime

uint64_t etime

static

Expiration string converted to numeric value.

Definition at line 321 of file gnunet-namestore.c.

Referenced by generate_gns_certificate(), get_existing_record(), run(), and run_with_zone_pkey().

etime_is_rel

int etime_is_rel = GNUNET_SYSERR

static

Is expiration time relative or absolute time?

Definition at line 326 of file gnunet-namestore.c.

Referenced by get_existing_record(), and run_with_zone_pkey().

zm

struct GNUNET_NAMESTORE_ZoneMonitor* zm

static

Monitor handle.

Definition at line 331 of file gnunet-namestore.c.

Referenced by check_result(), client_disconnect_cb(), continue_store_activity(), display_record_monitor(), GNUNET_NAMESTORE_zone_monitor_next(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NAMESTORE_zone_monitor_stop(), GNUNET_PEERSTORE_monitor_next(), GNUNET_PEERSTORE_monitor_stop(), handle_monitor_next(), handle_monitor_start(), handle_result(), handle_sync(), monitor_iterate_cb(), monitor_iteration_next(), monitor_sync(), monitor_unblock(), mq_error_handler(), reconnect(), reset_handles(), run_with_zone_pkey(), and warn_monitor_slow().

monitor

int monitor

static

Enables monitor mode.

Definition at line 336 of file gnunet-namestore.c.

Referenced by main(), and run_with_zone_pkey().

recordset

struct RecordSetEntry* recordset

static

Entry in record set for processing records in bulk.

Definition at line 341 of file gnunet-namestore.c.

Referenced by clear_recordset(), parse_recordline(), process_command_stdin(), and run_with_zone_pkey().

purge_task

struct GNUNET_SCHEDULER_Task* purge_task

static

Purge task.

Definition at line 346 of file gnunet-namestore.c.

Referenced by marked_deleted(), purge_next_record(), reset_handles(), and zone_iteration_finished().

ri_count

unsigned int ri_count = 0

static

Definition at line 351 of file gnunet-namestore.c.

Referenced by batch_insert_recordinfo(), and process_command_stdin().

record_info

struct GNUNET_NAMESTORE_RecordInfo* record_info

static

Definition at line 353 of file gnunet-namestore.c.

Referenced by batch_insert_recordinfo(), do_shutdown(), GNUNET_NAMESTORE_records_store(), and process_command_stdin().

record_info_capacity

unsigned int record_info_capacity = 0

static

Maximum capacity of record_info array.

Definition at line 356 of file gnunet-namestore.c.

Referenced by process_command_stdin().

max_batch_size

unsigned int max_batch_size = 1000

static

Definition at line 359 of file gnunet-namestore.c.

Referenced by main(), and process_command_stdin().

ri_sent

unsigned int ri_sent = 0

static

Definition at line 661 of file gnunet-namestore.c.

Referenced by batch_insert_recordinfo(), and process_command_stdin().