gnunet-namestore.c File Reference

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

#include "platform.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 ego list. More...

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

Functions
static int	parse_expiration (const char *expirationstring, int *etime_is_rel, uint64_t *etime)
	Parse expiration time. More...
static int	parse_recordline (const char *line)
static void	reset_handles (void)
static void	do_shutdown (void *cls)
	Task run on shutdown. More...
static void	commit_cb (void *cls, enum GNUNET_ErrorCode ec)
static void	process_command_stdin ()
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. More...
static void	zone_iteration_error_cb (void *cls)
	Function called when we encountered an error in a zone iteration. More...
static void	collect_zone_records_to_purge (const struct GNUNET_IDENTITY_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
static void	collect_orphans (const struct GNUNET_IDENTITY_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
static void	display_record (const struct GNUNET_IDENTITY_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
	Process a record that was stored in the namestore. More...
static void	purge_zone_iterator (void *cls, const struct GNUNET_IDENTITY_PrivateKey *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_IDENTITY_PrivateKey *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_IDENTITY_PrivateKey *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. More...
static void	display_record_monitor (void *cls, const struct GNUNET_IDENTITY_PrivateKey *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. More...
static void	display_record_lookup (void *cls, const struct GNUNET_IDENTITY_PrivateKey *zone_key, const char *rname, unsigned int rd_len, const struct GNUNET_GNSRECORD_Data *rd)
	Process a record that was stored in the namestore. More...
static void	sync_cb (void *cls)
	Function called once we are in sync in monitor mode. More...
static void	monitor_error_cb (void *cls)
	Function called on errors while monitoring. More...
static void	lookup_error_cb (void *cls)
	Function called on errors while monitoring. More...
static void	add_error_cb (void *cls)
	Function called if lookup fails. More...
static void	get_existing_record (void *cls, const struct GNUNET_IDENTITY_PrivateKey *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. More...
static void	reverse_error_cb (void *cls)
	Function called if we encountered an error in zone-to-name. More...
static void	handle_reverse_lookup (void *cls, const struct GNUNET_IDENTITY_PrivateKey *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. More...
static void	del_lookup_error_cb (void *cls)
	Function called if lookup for deletion fails. More...
static void	del_monitor (void *cls, const struct GNUNET_IDENTITY_PrivateKey *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. More...
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. More...
static int	get_identity_for_string (const char *str, struct GNUNET_IDENTITY_PrivateKey *zk)
static void	begin_cb (void *cls, enum GNUNET_ErrorCode ec)
static void	id_connect_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	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. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *_cfg)
	Main function that will be run. More...
int	main (int argc, char *const *argv)
	The main function for gnunet-namestore. More...

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

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 40 of file gnunet-namestore.c.

MAX_LINE_LEN

#define MAX_LINE_LEN   4086

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

MAX_ARGS

#define MAX_ARGS   20

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

Function Documentation

parse_expiration()

static int parse_expiration ( const char *  expirationstring, int *  etime_is_rel, uint64_t *  etime  )

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 351 of file gnunet-namestore.c.

{
  struct GNUNET_TIME_Relative etime_rel;
  struct GNUNET_TIME_Absolute etime_abs;
 
  if (0 == strcmp (expirationstring, "never"))
  {
    *etime = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
    *etime_is_rel = GNUNET_NO;
    return GNUNET_OK;
  }
  if (GNUNET_OK ==
      GNUNET_STRINGS_fancy_time_to_relative (expirationstring, &etime_rel))
  {
    *etime_is_rel = GNUNET_YES;
    *etime = 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 (expirationstring, &etime_abs))
  {
    *etime_is_rel = GNUNET_NO;
    *etime = 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, etime, etime_is_rel, expirationstring, 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 396 of file gnunet-namestore.c.

{
  struct RecordSetEntry **head = &recordset;
  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);
    return GNUNET_SYSERR;
  }
 
  r = GNUNET_malloc (sizeof(struct RecordSetEntry) + record.data_size);
  r->next = *head;
  record.data = &r[1];
  memcpy (&r[1], raw_data, record.data_size);
  GNUNET_free (raw_data);
  r->record = record;
  *head = 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, head, line, RecordSetEntry::next, record(), RecordSetEntry::record, and recordset.

Referenced by process_command_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

reset_handles()

static void reset_handles ( void  )

static

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

{
  struct MarkedRecord *mrec;
  struct MarkedRecord *mrec_tmp;
  struct RecordSetEntry *rs_entry;
 
  rs_entry = recordset;
  while (NULL != (rs_entry = recordset))
  {
    recordset = recordset->next;
    GNUNET_free (rs_entry);
  }
  recordset = NULL;
  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;
  purge_zone = 0;
}

References add_qe, add_qe_uri, 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_public, is_shadow, list, list_it, marked_head, MarkedRecord::name, name, RecordSetEntry::next, MarkedRecord::next, purge_task, purge_zone, recordset, reverse_qe, set_qe, typestring, uri, value, zm, and zone_pkey.

Referenced by do_shutdown(), and finish_command().

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 596 of file gnunet-namestore.c.

{
  struct EgoEntry *ego_entry;
  struct EgoEntry *ego_tmp;
  (void) cls;
 
  reset_handles ();
  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, and reset_handles().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

commit_cb()

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

static

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

{
  ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr, "Failed to commit to namestore: `%s'\n",
             GNUNET_ErrorCode_get_hint (ec));
    ret = 1;
  }
  GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_EC_NONE, GNUNET_ErrorCode_get_hint(), GNUNET_SCHEDULER_shutdown(), ns_qe, and ret.

Referenced by finish_command(), and process_command_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

process_command_stdin()

static void process_command_stdin ( )

static

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

one last time

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

{
  char buf[MAX_LINE_LEN];
  static struct GNUNET_IDENTITY_PrivateKey next_zone_key;
  static char next_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
  static int finished = GNUNET_NO;
  static int have_next_zonekey = GNUNET_NO;
  int zonekey_set = GNUNET_NO;
  char *tmp;
 
 
  if (GNUNET_YES == have_next_zonekey)
  {
    zone_pkey = next_zone_key;
    if (NULL != name)
      GNUNET_free (name);
    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] == ':')
    {
      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);
        ns_qe = GNUNET_NAMESTORE_transaction_commit (ns, &commit_cb, NULL);
        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_zonekey = GNUNET_YES;
      /* Run a command for the previous record set */
      if (NULL != recordset)
      {
        run_with_zone_pkey (cfg);
        return;
      }
      zone_pkey = next_zone_key;
      if (NULL != name)
        GNUNET_free (name);
      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)
      {
        run_with_zone_pkey (cfg); 
        finished = GNUNET_YES;
        return;
      }
      fprintf (stderr, "Warning, encountered recordline without zone\n");
    }
  }
  ns_qe = GNUNET_NAMESTORE_transaction_commit (ns, &commit_cb, NULL);
  return;
}

References buf, cfg, commit_cb(), get_identity_for_string(), GNUNET_DNSPARSER_MAX_NAME_LENGTH, GNUNET_free, GNUNET_NAMESTORE_transaction_commit(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_YES, MAX_LINE_LEN, name, ns, ns_qe, parse_recordline(), recordset, ret, run_with_zone_pkey(), and zone_pkey.

Referenced by begin_cb(), and finish_command().

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 645 of file gnunet-namestore.c.

{
  reset_handles ();
  if (read_from_stdin)
  {
    process_command_stdin ();
    return;
  }
  ns_qe = GNUNET_NAMESTORE_transaction_commit (ns, &commit_cb, NULL);
}

References commit_cb(), GNUNET_NAMESTORE_transaction_commit(), ns, ns_qe, process_command_stdin(), read_from_stdin, and reset_handles().

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(), replace_cont(), run_with_zone_pkey(), 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 658 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;
  }
  ret = 0;
  finish_command ();
}

References _, finish_command(), GNUNET_EC_NAMESTORE_RECORD_EXISTS, GNUNET_EC_NONE, GNUNET_ErrorCode_get_hint(), 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 677 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 708 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_records_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_records_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 694 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 737 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 755 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_IDENTITY_PrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Definition at line 765 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, MarkedRecord::name, and zone_key.

Referenced by purge_zone_iterator().

Here is the caller graph for this function:

collect_orphans()

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

static

Definition at line 783 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, EgoEntry::next, and zone_key.

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_IDENTITY_PrivateKey *  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 821 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_IDENTITY_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\n",
               typestr,
               s,
               ets,
               (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_PRIVATE)) ? "PRIVATE"
             : "PUBLIC",
               (0 != (rd[i].flags & GNUNET_GNSRECORD_RF_SHADOW)) ? "SHADOW"
             : "");
    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_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_CRITICAL, 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_IDENTITY_private_key_to_string(), 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, typestring, and zone_key.

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_IDENTITY_PrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd, struct GNUNET_TIME_Absolute  expiry  )

static

Definition at line 931 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, rd, and zone_key.

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_IDENTITY_PrivateKey *  zone_key, const char *  rname, unsigned int  rd_len, const struct GNUNET_GNSRECORD_Data *  rd, struct GNUNET_TIME_Absolute  expiry  )

static

Definition at line 947 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, rd, and zone_key.

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_IDENTITY_PrivateKey *  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 972 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, rd, and zone_key.

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_IDENTITY_PrivateKey *  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 997 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, zm, and zone_key.

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_IDENTITY_PrivateKey *  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 1022 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, rd, and zone_key.

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 1042 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(), 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 1055 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 1068 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 1081 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_IDENTITY_PrivateKey *  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 1102 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_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_records_store (ns,
                                           &zone_pkey,
                                           name,
                                           rd_count + 1,
                                           rde,
                                           &add_continuation,
                                           &add_qe);
}

References _, add_continuation(), add_qe, GNUNET_GNSRECORD_Data::data, data, GNUNET_GNSRECORD_Data::data_size, 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_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_log, GNUNET_memcpy, GNUNET_NAMESTORE_records_store(), GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, is_public, is_shadow, name, ns, rd, rd_count, GNUNET_GNSRECORD_Data::record_type, ret, type, zone_key, 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 1175 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_IDENTITY_PrivateKey *  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 1194 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, reverse_qe, and zone.

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 1217 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_IDENTITY_PrivateKey *  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 1239 of file gnunet-namestore.c.

{
  struct GNUNET_GNSRECORD_Data rdx[rd_count];
  unsigned int rd_left;
  uint32_t 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_records_store (ns,
                                             &zone_pkey,
                                             name,
                                             0,
                                             NULL,
                                             &del_continuation,
                                             NULL);
    return;
  }
  rd_left = 0;
  if (NULL != typestring)
    type = GNUNET_GNSRECORD_typename_to_number (typestring);
  else
    type = GNUNET_GNSRECORD_TYPE_ANY;
  for (unsigned int i = 0; i < rd_count; i++)
  {
    vs = NULL;
    if (! (((GNUNET_GNSRECORD_TYPE_ANY == type) ||
            (rd[i].record_type == 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_records_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_records_store(), name, ns, rd, rd_count, GNUNET_GNSRECORD_Data::record_type, ret, type, typestring, value, zone, 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:

replace_cont()

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

static

Definition at line 1317 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' */
  }
  finish_command ();
}

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

Referenced by 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 1340 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;
 
    /* 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 = GNUNET_new_array (rd_count, struct GNUNET_GNSRECORD_Data);
    rd_count = 0;
    for (struct RecordSetEntry *e = recordset; NULL != e; e = e->next)
    {
      rd[rd_count] = e->record;
      rd_count++;
    }
    set_qe = GNUNET_NAMESTORE_records_store (ns,
                                             &zone_pkey,
                                             name,
                                             rd_count,
                                             rd,
                                             &replace_cont,
                                             NULL);
    GNUNET_free (rd);
    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_OPENPGPKEY == type))
    {
      fprintf (stderr,
               _ ("For DNS record types `SRV', `TLSA' 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_lookup (ns,
                                              &zone_pkey,
                                              name,
                                              &del_lookup_error_cb,
                                              NULL,
                                              &del_monitor,
                                              NULL);
  }
  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_IDENTITY_PublicKey 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_IDENTITY_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_IDENTITY_PublicKey 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_IDENTITY_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_IDENTITY_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;
    add_qe_uri = GNUNET_NAMESTORE_records_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, cfg, GNUNET_GNSRECORD_Data::data, data, GNUNET_GNSRECORD_Data::data_size, data_size, del, del_lookup_error_cb(), del_monitor(), del_qe, display_record_iterator(), display_record_lookup(), display_record_monitor(), e, ego_name, etime, etime_is_rel, GNUNET_GNSRECORD_Data::expiration_time, expirationstring, finish_command(), GNUNET_GNSRECORD_Data::flags, get_existing_record(), get_qe, GNUNET_DNSPARSER_TYPE_OPENPGPKEY, 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_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW, GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_typename_to_number(), GNUNET_IDENTITY_public_key_from_string(), GNUNET_IDENTITY_public_key_get_length(), GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_records_store(), 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_public, is_shadow, list, list_it, list_orphaned, lookup_error_cb(), monitor, monitor_error_cb(), name, 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 begin_cb(), and process_command_stdin().

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_IDENTITY_PrivateKey *  zk  )

static

FIXME: Check for zTLD?

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

{
  const struct GNUNET_IDENTITY_PrivateKey *privkey;
  struct GNUNET_IDENTITY_PublicKey pubkey;
  struct GNUNET_IDENTITY_PublicKey ego_pubkey;
  struct EgoEntry *ego_entry;
 
  if (GNUNET_OK == GNUNET_IDENTITY_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_IDENTITY_ego_get_private_key(), GNUNET_IDENTITY_ego_get_public_key(), GNUNET_IDENTITY_public_key_from_string(), GNUNET_NO, GNUNET_OK, EgoEntry::identifier, EgoEntry::next, and pubkey.

Referenced by process_command_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

begin_cb()

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

static

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

{
  ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to start transaction: %s\n",
                GNUNET_ErrorCode_get_hint (ec));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (read_from_stdin)
  {
    process_command_stdin ();
    return;
  }
  run_with_zone_pkey (cfg);
}

References cfg, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_SCHEDULER_shutdown(), ns_qe, process_command_stdin(), read_from_stdin, and run_with_zone_pkey().

Referenced by id_connect_cb().

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 *  name  )

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 1896 of file gnunet-namestore.c.

{
  struct GNUNET_IDENTITY_PublicKey pk;
  struct EgoEntry *ego_entry;
 
  (void) ctx;
  (void) name;
  if ((NULL != name) && (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 (name);
    GNUNET_CONTAINER_DLL_insert_tail (ego_head,
                                      ego_tail,
                                      ego_entry);
    if ((NULL != ego_name) &&
        (0 == strcmp (name, ego_name)))
      zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
    return;
  }
  if (NULL != ego)
    return;
  ns_qe = GNUNET_NAMESTORE_transaction_begin (ns, &begin_cb, (void *) cfg);
}

References begin_cb(), 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_NAMESTORE_transaction_begin(), GNUNET_new, GNUNET_strdup, EgoEntry::identifier, name, ns, ns_qe, pk, 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 1938 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 _, consensus-simulation::args, 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 1980 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_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_string ('z',
                                 "zone",
                                 "EGO",
                                 gettext_noop (
                                   "name of the ego controlling the zone"),
                                 &ego_name),
    GNUNET_GETOPT_OPTION_END };
 
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
 
  is_public = -1;
  is_shadow = -1;
  GNUNET_log_setup ("gnunet-namestore", "WARNING", NULL);
  if (GNUNET_OK !=
      (lret = GNUNET_PROGRAM_run (argc,
                                  argv,
                                  "gnunet-namestore",
                                  _ ("GNUnet zone manipulation tool"),
                                  options,
                                  &run,
                                  NULL)))
  {
    GNUNET_free_nz ((void *) argv);
    // FIXME
    // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
    return lret;
  }
  GNUNET_free_nz ((void *) argv);
  // FIXME
  // GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
  return ret;
}

References _, add, del, ego_name, expirationstring, gettext_noop, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_flag(), GNUNET_GETOPT_option_string(), GNUNET_log_setup(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), include_maintenance, is_public, is_shadow, list, list_orphaned, 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 114 of file gnunet-namestore.c.

Referenced by del_monitor(), do_shutdown(), finish_command(), get_existing_record(), id_connect_cb(), process_command_stdin(), purge_next_record(), run(), and run_with_zone_pkey().

zone_pkey

struct GNUNET_IDENTITY_PrivateKey zone_pkey

static

Private key for the our zone.

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

Referenced by 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 124 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 129 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 134 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 139 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 144 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 149 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 154 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 159 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 164 of file gnunet-namestore.c.

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

ego_head

struct EgoEntry* ego_head

static

Ego list.

Definition at line 169 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 174 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 179 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 184 of file gnunet-namestore.c.

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

list

int list

static

Desired action is to list records.

Definition at line 189 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 194 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(), run_with_zone_pkey(), and solver_info_cb().

del

int del

static

Desired action is to remove a record.

Definition at line 199 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 204 of file gnunet-namestore.c.

Referenced by get_existing_record(), 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 209 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 214 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 219 of file gnunet-namestore.c.

Referenced by display_record(), and main().

purge_zone

int purge_zone

static

Purge zone contents.

Definition at line 225 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 230 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 235 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 240 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 245 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 250 of file gnunet-namestore.c.

Referenced by 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 255 of file gnunet-namestore.c.

Referenced by begin_cb(), commit_cb(), do_shutdown(), finish_command(), id_connect_cb(), and process_command_stdin().

name

char* name

static

Name of the records to add/list/remove.

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

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

value

char* value

static

Value of the record to add/remove.

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

Referenced by add_section_contents(), add_sections(), add_setter_action(), add_to_tc(), age_values(), attr_in_claims_request(), auto_conf_iter(), bandwidth_stats_iterator(), barrier_destroy_iterator(), bind_loose_channel(), blacklist_cfg_iter(), build_result_set(), bulk_tx_start(), cache_clear_iterator(), call_iterator(), cancel_pending_request(), cfg_copy_iterator(), 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_iterator(), cleanup_url_map(), cleanup_validation_entry(), client_disconnect_it(), client_release_ports(), close_files_iter(), collector(), compare_entries(), compute_service_response(), compute_square_sum_mpi_elements(), con_val_iter(), consume_cont(), cookie_identity_interpretation(), copy_element_cb(), copy_entry(), create_randomized_element_iterator(), create_response(), database_setup(), debug_channel(), del_monitor(), delete_entries(), delete_value(), destroy_active_client_request(), destroy_ai_cb(), destroy_all_address_it(), destroy_channel_cb(), destroy_elements_iterator(), destroy_it(), destroy_iterator_cb(), destroy_key_to_element_iter(), destroy_paths_now(), destroy_port_cb(), destroy_remaining_channels(), destroy_session_cb(), destroy_session_shutdown_cb(), destroy_tunnels_now(), destroy_watch(), determinate_avg_element_size_iterator(), determinate_done_message_iterator(), disconnect_all_neighbours(), disconnect_and_free_it(), disconnect_and_free_peer_entry(), dns_string_to_value(), dns_value_to_string(), do_notify(), do_restart_typemap_message(), drop_client_entries(), dv_neighbour_selection(), dv_neighbour_transmission(), execute_get(), execute_select(), expire_blocks(), expire_entries(), filter_all(), filtered_map_initialization(), find_address_cb(), find_address_it(), find_advertisable_hello(), find_ai_cb(), find_ai_no_session_cb(), find_best_address_it(), find_by_message_uuid(), find_result_set(), find_sender_by_address(), find_trees(), flush_respect(), free_ack_cummulator_cb(), free_addr_it(), free_all_it(), free_backtalker_cb(), free_barrier_node_cb(), free_barriers_cb(), free_blacklist_entry(), free_dv_routes_cb(), free_ego(), free_element_cb(), free_entry(), free_host_entry(), free_item(), free_iterate(), free_matching_requests(), free_namespaces_cb(), free_neighbour_cb(), free_nodes_cb(), free_peer(), free_pending_ack_cb(), free_preference(), free_reassembly_cb(), free_request(), free_request_it(), free_result(), free_service_record(), free_sug_handle(), free_tmps(), free_tracker(), free_validation_state_cb(), free_value(), free_waiting_entry(), full_sync_plausibility_check(), get_active_address_it(), get_all_peers_iterator(), get_all_tunnels_iterator(), get_iterator(), get_lt_delete_it(), get_queue_delete_it(), get_rand_peer_iterator(), get_receiver_delete_it(), get_result_present(), get_sender_delete_it(), get_session_delete_it(), get_url_parameter_copy(), GNUNET_CONFIGURATION_append_value_filename(), GNUNET_CONFIGURATION_config_tool_run(), 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_FS_GETOPT_KEYWORDS(), GNUNET_FS_GETOPT_METADATA(), GNUNET_NETWORK_socket_disable_corking(), GNUNET_PEERSTORE_store(), GNUNET_STATISTICS_set(), GNUNET_TESTING_get_topo_from_string(), GSF_cadet_release_clients(), handle_ack(), handle_alice_client_message(), handle_bob_client_message(), handle_set(), hash_hosts(), header_iterator(), heap_plugin_get_expiration(), heap_plugin_get_replication(), heap_plugin_get_zero_anonymity(), heap_plugin_put(), incrementBit(), init_key_to_element_iterator(), initialize_map_unfiltered(), inspect_attrs(), iterate_addresses(), iterate_channels_cb(), iterate_close_room(), iterate_copy_history(), iterate_create_ego(), iterate_destroy_contacts(), iterate_destroy_egos(), iterate_destroy_entries(), iterate_destroy_links(), iterate_destroy_members(), iterate_destroy_message(), iterate_destroy_messages(), iterate_destroy_operations(), iterate_destroy_room(), iterate_destroy_rooms(), iterate_destroy_session(), iterate_destroy_tunnels(), iterate_entries(), iterate_find_member(), iterate_find_room(), iterate_free_member_ids(), iterate_load_next_member_sessions(), iterate_load_next_session(), iterate_local_members(), iterate_member_sessions_it(), iterate_reachables(), iterate_reset_room(), iterate_save_entries(), iterate_save_links(), iterate_save_member_session_history_hentries(), iterate_save_members(), iterate_save_messages(), iterate_save_operations(), iterate_save_rooms(), 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(), iterator_bf_create(), iterator_bf_reduce(), iterator_cb(), jwt_parse_attributes(), locate_by_id(), log_namespaces(), log_nodes(), lookup_queue_it(), lookup_session_it(), main(), make_json(), mark_match_down(), mark_peer_down(), migrate_and_drop_keywords(), migrate_and_drop_metadata(), move_to_pending(), move_to_queue(), mpi_to_sexp(), neighbour_delete(), neighbours_iterate(), nibble_to_regex(), node_connections(), normalize_address(), notify_change(), notify_client_about_session(), notify_client_connect_info(), notify_client_queues(), notify_tunnel_up_cb(), num_to_regex(), op_get_element_iterator(), opc_free_iterator(), opc_search_iterator(), open_port_cb(), parse_jwt(), parse_record(), parse_record_data(), peerinfo_it(), peermap_clear_iterator(), PEERSTORE_create_record_mq_envelope(), peerstore_flat_store_record(), peerstore_sqlite_store_record(), pending_reversals_delete_it(), prepare_ibf_iterator(), print_option(), printer(), printer_watch(), process_reply(), process_result_with_request(), process_stat(), process_stat_in(), process_stats(), process_update_node(), rcop_cleanup_iterator(), reachability_iterator(), read_service_conf(), regex_cancel_dht_get(), regex_free_result(), regex_result_iterator(), reghost_free_iterator(), remove_all(), remove_iterator(), reschedule_hellos(), reset_handles(), rewatch_it(), rsa_sign_mpi(), run(), run_with_zone_pkey(), schedule_current_round(), search_iterator(), search_result_free(), search_result_freeze_probes(), search_result_resume_probes(), search_result_stop(), search_result_suspend(), send_full_element_iterator(), send_missing_full_elements_iter(), send_offers_iterator(), send_session_info_iter(), send_simple_cb(), send_utilization_data(), session_cmp_it(), session_disconnect_it(), session_lookup_client_by_address(), session_lookup_it(), session_tag_it(), set_cont(), set_insert_iterator(), set_value(), signal_result_resume(), socket_set_nodelay(), stat_iterator(), statistics_cb(), statistics_result(), stats_iterator(), stop_peer_request(), store_and_free_entries(), store_peer_presistently_iterator(), stun_attr2str(), stun_msg2str(), sum_relative_preferences(), test_blacklisted(), test_exist_cb(), test_result_present(), ticket_collect(), tld_iter(), transmit_client_response(), transmit_suggestion(), try_add_peers(), update_abs_sum(), update_config(), update_flood_times(), update_iterator(), update_rel_sum(), update_sre_result_maps(), url_iterator(), valid_peer_iterator(), validation_entry_match(), watch_notifier_it(), write_item(), and zone_to_name().

uri

char* uri

static

URI to import.

Definition at line 270 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 275 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 280 of file gnunet-namestore.c.

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

expirationstring

char* expirationstring

static

Desired expiration time.

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

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

nickstring

char* nickstring

static

Desired nick name.

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

Referenced by main(), and run_with_zone_pkey().

ret

int ret

static

Global return value.

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

Referenced by add_continuation(), add_error_cb(), commit_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 300 of file gnunet-namestore.c.

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

data

void* data

static

Value in binary format.

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

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

data_size

size_t data_size

static

Number of bytes in data.

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

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

etime

uint64_t etime

static

Expiration string converted to numeric value.

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

Referenced by get_existing_record(), parse_expiration(), 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 320 of file gnunet-namestore.c.

Referenced by get_existing_record(), parse_expiration(), and run_with_zone_pkey().

zm

struct GNUNET_NAMESTORE_ZoneMonitor* zm

static

Monitor handle.

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

Referenced by check_monitor_start(), 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(), handle_monitor_next(), handle_monitor_start(), handle_result(), handle_sync(), 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 330 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 335 of file gnunet-namestore.c.

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

purge_task

struct GNUNET_SCHEDULER_Task* purge_task

static

Purge task.

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

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