gnunet-namestore.c File Reference

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

#include "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_dnsparser_lib.h>
#include <gnunet_identity_service.h>
#include <gnunet_gnsrecord_lib.h>
#include <gnunet_gns_service.h>
#include <gnunet_namestore_service.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...

Functions
static void	do_shutdown (void *cls)
	Task run on shutdown. More...
static void	test_finished ()
	Check if we are finished, and if so, perform shutdown. More...
static void	add_continuation (void *cls, int32_t success, const char *emsg)
	Continuation called to notify client about result of the operation. More...
static void	del_continuation (void *cls, int32_t success, const char *emsg)
	Continuation called to notify client about result of the operation. More...
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	display_record (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	display_record_iterator (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *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	display_record_monitor (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *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	display_record_lookup (void *cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *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_CRYPTO_EcdsaPrivateKey *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_CRYPTO_EcdsaPrivateKey *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_CRYPTO_EcdsaPrivateKey *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 int	parse_expiration (const char *expirationstring, int *etime_is_rel, uint64_t *etime)
	Parse expiration time. More...
static void	replace_cont (void *cls, int success, const char *emsg)
	Function called when namestore is done with the replace operation. More...
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 void	identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego)
	Callback invoked from identity service with ego information. More...
static void	default_ego_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	Function called with the default ego to be used for GNS operations. More...
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...
static int	multirecord_process (struct GNUNET_GETOPT_CommandLineProcessorContext *ctx, void *scls, const char *option, const char *value)
	Command-line option parser function that allows the user to specify a complete record as one argument for adding/removing. More...
struct GNUNET_GETOPT_CommandLineOption	multirecord_option (char shortName, const char *name, const char *argumentHelp, const char *description, struct RecordSetEntry **rs)
	Allow user to specify keywords. 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_CRYPTO_EcdsaPrivateKey	zone_pkey
	Private key for the our zone. More...
static struct GNUNET_IDENTITY_EgoLookup *	el
	Handle to identity lookup. More...
static struct GNUNET_IDENTITY_Handle *	idh
	Identity service handle. More...
struct GNUNET_IDENTITY_Operation *	get_default
	Obtain default ego. More...
static char *	ego_name
	Name of the ego controlling the zone. More...
static int	add
	Desired action is to add a record. 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 int	list
	Desired action is to list records. More...
static struct GNUNET_NAMESTORE_ZoneIterator *	list_it
	List iterator for the 'list' operation. 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_RECORD) 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 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...

Detailed Description

command line tool to manipulate the local zone

Author

Christian Grothoff

TODO:

• test

Definition in file gnunet-namestore.c.

Function Documentation

do_shutdown()

static void do_shutdown ( void *  cls )

static

Task run on shutdown.

Cleans up everything.

Parameters

cls

unused

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

References data, GNUNET_free, GNUNET_IDENTITY_cancel(), GNUNET_IDENTITY_disconnect(), GNUNET_IDENTITY_ego_lookup_cancel(), GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NAMESTORE_zone_monitor_stop(), uri, and zone_pkey.

Referenced by run().

{
  (void) cls;
  if (NULL != get_default)
  {
    GNUNET_IDENTITY_cancel (get_default);
    get_default = NULL;
  }
  if (NULL != idh)
  {
    GNUNET_IDENTITY_disconnect (idh);
    idh = NULL;
  }
  if (NULL != el)
  {
    GNUNET_IDENTITY_ego_lookup_cancel (el);
    el = NULL;
  }
  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 != ns)
  {
    GNUNET_NAMESTORE_disconnect (ns);
    ns = NULL;
  }
  memset (&zone_pkey, 0, sizeof(zone_pkey));
  if (NULL != uri)
  {
    GNUNET_free (uri);
    uri = NULL;
  }
  if (NULL != zm)
  {
    GNUNET_NAMESTORE_zone_monitor_stop (zm);
    zm = NULL;
  }
  if (NULL != data)
  {
    GNUNET_free (data);
    data = NULL;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_finished()

static void test_finished ( void  )

static

Check if we are finished, and if so, perform shutdown.

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

References GNUNET_SCHEDULER_shutdown().

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(), zone_iteration_error_cb(), and zone_iteration_finished().

{
  if ((NULL == add_qe) && (NULL == add_qe_uri) && (NULL == get_qe) &&
      (NULL == del_qe) && (NULL == reverse_qe) && (NULL == list_it))
    GNUNET_SCHEDULER_shutdown ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_continuation()

static void add_continuation ( void *  cls, int32_t  success, const char *  emsg  )

static

Continuation called to notify client about result of the operation.

Parameters

cls	closure, location of the QueueEntry pointer to NULL out
success	GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) GNUNET_NO if content was already there GNUNET_YES (or other positive value) on success
emsg	NULL on success, otherwise an error message

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

References _, GNUNET_NO, GNUNET_YES, qe, ret, and test_finished().

Referenced by get_existing_record(), and run_with_zone_pkey().

{
  struct GNUNET_NAMESTORE_QueueEntry **qe = cls;

  *qe = NULL;
  if (GNUNET_YES != success)
  {
    fprintf (stderr,
             _ ("Adding record failed: %s\n"),
             (GNUNET_NO == success) ? "record exists" : emsg);
    if (GNUNET_NO != success)
      ret = 1;
  }
  ret = 0;
  test_finished ();
}

Here is the call graph for this function:

Here is the caller graph for this function:

del_continuation()

static void del_continuation ( void *  cls, int32_t  success, const char *  emsg  )

static

Continuation called to notify client about result of the operation.

Parameters

cls	closure, unused
success	GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) GNUNET_NO if content was already there GNUNET_YES (or other positive value) on success
emsg	NULL on success, otherwise an error message

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

References _, GNUNET_NO, GNUNET_SYSERR, and test_finished().

Referenced by del_monitor().

{
  (void) cls;
  del_qe = NULL;
  if (GNUNET_NO == success)
  {
    fprintf (stderr,
             _ ("Deleting record failed, record does not exist%s%s\n"),
             (NULL != emsg) ? ": " : "",
             (NULL != emsg) ? emsg : "");
  }
  if (GNUNET_SYSERR == success)
  {
    fprintf (stderr,
             _ ("Deleting record failed%s%s\n"),
             (NULL != emsg) ? ": " : "",
             (NULL != emsg) ? emsg : "");
  }
  test_finished ();
}

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

References test_finished().

Referenced by run_with_zone_pkey().

{
  (void) cls;
  list_it = NULL;
  test_finished ();
}

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

References ret, and test_finished().

Referenced by run_with_zone_pkey().

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

Here is the call graph for this function:

Here is the caller graph for this function:

display_record()

static void display_record ( 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 411 of file gnunet-namestore.c.

References _, GNUNET_TIME_Absolute::abs_value_us, data, data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW_RECORD, GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_typename_to_number(), GNUNET_GNSRECORD_value_to_string(), GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_NO, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_YES, name, GNUNET_TIME_Relative::rel_value_us, type, and typestring.

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

{
  const char *typestr;
  char *s;
  const char *ets;
  struct GNUNET_TIME_Absolute at;
  struct GNUNET_TIME_Relative rt;
  int have_record;

  if ((NULL != name) && (0 != strcmp (name, rname)))
  {
    GNUNET_NAMESTORE_zone_iterator_next (list_it, 1);
    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;
  fprintf (stdout, "%s:\n", rname);
  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);
    }
    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_RECORD)) ? "SHADOW"
             : "");
    GNUNET_free (s);
  }
  fprintf (stdout, "%s", "\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

display_record_iterator()

static void display_record_iterator ( void *  cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  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 498 of file gnunet-namestore.c.

References display_record(), and GNUNET_NAMESTORE_zone_iterator_next().

Referenced by run_with_zone_pkey().

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

Here is the call graph for this function:

Here is the caller graph for this function:

display_record_monitor()

static void display_record_monitor ( void *  cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  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 521 of file gnunet-namestore.c.

References display_record(), and GNUNET_NAMESTORE_zone_monitor_next().

Referenced by run_with_zone_pkey().

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

Here is the call graph for this function:

Here is the caller graph for this function:

display_record_lookup()

static void display_record_lookup ( void *  cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  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 544 of file gnunet-namestore.c.

References display_record(), and test_finished().

Referenced by run_with_zone_pkey().

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

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

Referenced by run_with_zone_pkey().

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

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

Referenced by run_with_zone_pkey().

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

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

References test_finished().

Referenced by run_with_zone_pkey().

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

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

References GNUNET_break, ret, and test_finished().

Referenced by run_with_zone_pkey().

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

Here is the call graph for this function:

Here is the caller graph for this function:

get_existing_record()

static void get_existing_record ( void *  cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  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 624 of file gnunet-namestore.c.

References _, add_continuation(), data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, etime, etime_is_rel, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_assert, GNUNET_break, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_DNSPARSER_TYPE_SOA, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW_RECORD, GNUNET_GNSRECORD_TYPE_GNS2DNS, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_log, GNUNET_memcpy, GNUNET_NAMESTORE_records_store(), GNUNET_NO, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_YES, is_public, is_shadow, name, GNUNET_GNSRECORD_Data::record_type, ret, test_finished(), type, and zone_pkey.

Referenced by run_with_zone_pkey().

{
  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;
    test_finished ();
    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_CNAME:
      fprintf (
        stderr,
        _ (
          "A %s record exists already under `%s', no other records can be added.\n"),
        "CNAME",
        rec_name);
      ret = 1;
      test_finished ();
      return;

    case GNUNET_GNSRECORD_TYPE_PKEY:
      fprintf (
        stderr,
        _ (
          "A %s record exists already under `%s', no other records can be added.\n"),
        "PKEY",
        rec_name);
      ret = 1;
      test_finished ();
      return;

    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;
        test_finished ();
        return;
      }
      break;
    }
  }
  switch (type)
  {
  case GNUNET_DNSPARSER_TYPE_CNAME:
    if (0 != rd_count)
    {
      fprintf (stderr,
               _ (
                 "Records already exist under `%s', cannot add `%s' record.\n"),
               rec_name,
               "CNAME");
      ret = 1;
      test_finished ();
      return;
    }
    break;

  case GNUNET_GNSRECORD_TYPE_PKEY:
    if (0 != rd_count)
    {
      fprintf (stderr,
               _ (
                 "Records already exist under `%s', cannot add `%s' record.\n"),
               rec_name,
               "PKEY");
      ret = 1;
      test_finished ();
      return;
    }
    break;

  case GNUNET_GNSRECORD_TYPE_GNS2DNS:
    for (unsigned int i = 0; i < rd_count; i++)
      if (GNUNET_GNSRECORD_TYPE_GNS2DNS != rd[i].record_type)
      {
        fprintf (
          stderr,
          _ (
            "Non-GNS2DNS records already exist under `%s', cannot add GNS2DNS record.\n"),
          rec_name);
        ret = 1;
        test_finished ();
        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_RECORD;
  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);
}

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

References reverse_pkey.

Referenced by run_with_zone_pkey().

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

Here is the caller graph for this function:

handle_reverse_lookup()

static void handle_reverse_lookup ( void *  cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  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 783 of file gnunet-namestore.c.

References ego_name, reverse_pkey, and test_finished().

Referenced by run_with_zone_pkey().

{
  (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);
  test_finished ();
}

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

References GNUNET_break, ret, and test_finished().

Referenced by run_with_zone_pkey().

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

Here is the call graph for this function:

Here is the caller graph for this function:

del_monitor()

static void del_monitor ( void *  cls, const struct GNUNET_CRYPTO_EcdsaPrivateKey *  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 828 of file gnunet-namestore.c.

References _, data, data_size, del_continuation(), GNUNET_free, GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_typename_to_number(), GNUNET_GNSRECORD_value_to_string(), GNUNET_NAMESTORE_records_store(), name, GNUNET_GNSRECORD_Data::record_type, ret, test_finished(), type, typestring, value, and zone_pkey.

Referenced by run_with_zone_pkey().

{
  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;
    test_finished ();
    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);
    test_finished ();
    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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

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
etime_is_rel[out]	set to GNUNET_YES if time is relative
etime[out]	set to expiration time (abs or rel)

Returns

GNUNET_OK on success

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

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_ERROR_TYPE_DEBUG, 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_UNIT_FOREVER_ABS, GNUNET_YES, and GNUNET_TIME_Relative::rel_value_us.

Referenced by multirecord_process(), and run_with_zone_pkey().

{
  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;
    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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

replace_cont()

static void replace_cont ( void *  cls, int  success, const char *  emsg  )

static

Function called when namestore is done with the replace operation.

Parameters

cls	NULL
success	GNUNET_SYSERR on failure (including timeout/queue drop/failure to validate) GNUNET_NO if content was already there or not found GNUNET_YES (or other positive value) on success
emsg	NULL on success, otherwise an error message

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

References _, GNUNET_ERROR_TYPE_MESSAGE, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), and ret.

Referenced by run_with_zone_pkey().

{
  (void) cls;

  set_qe = NULL;
  if (GNUNET_OK != success)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
                _ ("Failed to replace records: %s\n"),
                emsg);
    ret = 1;   /* fail from 'main' */
  }
  GNUNET_SCHEDULER_shutdown ();
}

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

References _, add, add_continuation(), add_error_cb(), data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, del, del_lookup_error_cb(), del_monitor(), display_record_iterator(), display_record_lookup(), display_record_monitor(), e, etime, etime_is_rel, GNUNET_GNSRECORD_Data::expiration_time, expirationstring, GNUNET_GNSRECORD_Data::flags, get_existing_record(), GNUNET_CRYPTO_ecdsa_public_key_from_string(), GNUNET_DNSPARSER_TYPE_OPENPGPKEY, GNUNET_DNSPARSER_TYPE_SRV, GNUNET_DNSPARSER_TYPE_TLSA, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW_RECORD, GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_TYPE_NICK, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_GNSRECORD_typename_to_number(), GNUNET_log, GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_records_lookup(), GNUNET_NAMESTORE_records_store(), GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_to_name(), GNUNET_new_array, GNUNET_OK, GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_STRINGS_utf8_tolower(), GNUNET_YES, handle_reverse_lookup(), is_public, is_shadow, list, lookup_error_cb(), monitor, monitor_error_cb(), name, nickstring, parse_expiration(), pkey, GNUNET_GNSRECORD_Data::record_type, replace_cont(), ret, reverse_error_cb(), reverse_pkey, sh, sync_cb(), type, typestring, uri, value, zone_iteration_error_cb(), zone_iteration_finished(), and zone_pkey.

Referenced by identity_cb(), and run().

{
  struct GNUNET_GNSRECORD_Data rd;

  if (! (add | del | list | (NULL != nickstring) | (NULL != uri)
         | (NULL != reverse_pkey) | (NULL != recordset)))
  {
    /* nothing more to be done */
    fprintf (stderr, _ ("No options given\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  ns = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == ns)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to namestore\n"));
    return;
  }

  if (NULL != recordset)
  {
    /* replace entire record set */
    unsigned int rd_count;
    struct GNUNET_GNSRECORD_Data *rd;

    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-R",
               _ ("replace"));
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      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);
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      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 == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("add"));
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    if (NULL == typestring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-t",
               _ ("add"));
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    type = GNUNET_GNSRECORD_typename_to_number (typestring);
    if (UINT32_MAX == type)
    {
      fprintf (stderr, _ ("Unsupported type `%s'\n"), typestring);
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      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");
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    if (NULL == value)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-V",
               _ ("add"));
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
      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);
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    if (NULL == expirationstring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-e",
               _ ("add"));
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    if (GNUNET_OK != parse_expiration (expirationstring, &etime_is_rel, &etime))
    {
      fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    add_qe = GNUNET_NAMESTORE_records_lookup (ns,
                                              &zone_pkey,
                                              name,
                                              &add_error_cb,
                                              NULL,
                                              &get_existing_record,
                                              NULL);
  }
  if (del)
  {
    if (NULL == name)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-n",
               _ ("del"));
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    del_qe = GNUNET_NAMESTORE_records_lookup (ns,
                                              &zone_pkey,
                                              name,
                                              &del_lookup_error_cb,
                                              NULL,
                                              &del_monitor,
                                              NULL);
  }
  if (list)
  {
    if (NULL != name)
      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_start (ns,
                                                       &zone_pkey,
                                                       &zone_iteration_error_cb,
                                                       NULL,
                                                       &display_record_iterator,
                                                       NULL,
                                                       &zone_iteration_finished,
                                                       NULL);
  }
  if (NULL != reverse_pkey)
  {
    struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;

    if (GNUNET_OK !=
        GNUNET_CRYPTO_ecdsa_public_key_from_string (reverse_pkey,
                                                    strlen (reverse_pkey),
                                                    &pubkey))
    {
      fprintf (stderr,
               _ ("Invalid public key for reverse lookup `%s'\n"),
               reverse_pkey);
      GNUNET_SCHEDULER_shutdown ();
    }
    reverse_qe = GNUNET_NAMESTORE_zone_to_name (ns,
                                                &zone_pkey,
                                                &pubkey,
                                                &reverse_error_cb,
                                                NULL,
                                                &handle_reverse_lookup,
                                                NULL);
  }
  if (NULL != uri)
  {
    char sh[105];
    char sname[64];
    struct GNUNET_CRYPTO_EcdsaPublicKey pkey;

    GNUNET_STRINGS_utf8_tolower (uri, uri);
    if ((2 != (sscanf (uri, "gnunet://gns/%52s/%63s", sh, sname))) ||
        (GNUNET_OK !=
         GNUNET_CRYPTO_ecdsa_public_key_from_string (sh, strlen (sh), &pkey)))
    {
      fprintf (stderr, _ ("Invalid URI `%s'\n"), uri);
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    if (NULL == expirationstring)
    {
      fprintf (stderr,
               _ ("Missing option `%s' for operation `%s'\n"),
               "-e",
               _ ("add"));
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    if (GNUNET_OK != parse_expiration (expirationstring, &etime_is_rel, &etime))
    {
      fprintf (stderr, _ ("Invalid time format `%s'\n"), expirationstring);
      GNUNET_SCHEDULER_shutdown ();
      ret = 1;
      return;
    }
    memset (&rd, 0, sizeof(rd));
    rd.data = &pkey;
    rd.data_size = sizeof(struct GNUNET_CRYPTO_EcdsaPublicKey);
    rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
    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_RECORD;
    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_start (cfg,
                                              &zone_pkey,
                                              GNUNET_YES,
                                              &monitor_error_cb,
                                              NULL,
                                              &display_record_monitor,
                                              NULL,
                                              &sync_cb,
                                              NULL);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

identity_cb()

static void identity_cb ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego  )

static

Callback invoked from identity service with ego information.

An ego of NULL means the ego was not found.

Parameters

cls	closure with the configuration
ego	an ego known to identity service, or NULL

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

References _, cfg, ego_name, GNUNET_free, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_SCHEDULER_shutdown(), name, ret, run_with_zone_pkey(), and zone_pkey.

Referenced by default_ego_cb(), and run().

{
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;

  el = NULL;
  if ((NULL != name) && (0 != strchr (name, '.')))
  {
    fprintf (stderr,
             _ ("Label `%s' contains `.' which is not allowed\n"),
             name);
    GNUNET_SCHEDULER_shutdown ();
    ret = -1;
    return;
  }

  if (NULL == ego)
  {
    if (NULL != ego_name)
    {
      fprintf (stderr,
               _ ("Ego `%s' not known to identity service\n"),
               ego_name);
    }
    GNUNET_SCHEDULER_shutdown ();
    ret = -1;
    return;
  }
  zone_pkey = *GNUNET_IDENTITY_ego_get_private_key (ego);
  GNUNET_free (ego_name);
  ego_name = NULL;
  run_with_zone_pkey (cfg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

default_ego_cb()

static void default_ego_cb ( void *  cls, struct GNUNET_IDENTITY_Ego *  ego, void **  ctx, const char *  name  )

static

Function called with the default ego to be used for GNS operations.

Used if the user did not specify a zone via command-line or environment variables.

Parameters

cls	NULL
ego	default ego, NULL for none
ctx	NULL
name	unused

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

References _, cfg, GNUNET_SCHEDULER_shutdown(), identity_cb(), and ret.

Referenced by id_connect_cb().

{
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;

  (void) ctx;
  (void) name;
  get_default = NULL;
  if (NULL == ego)
  {
    fprintf (stderr,
             _ ("No default identity configured for `namestore' subsystem\n"
                "Run gnunet-identity -s namestore -e $NAME to set the default to $NAME\n"
                "Run gnunet-identity -d to get a list of choices for $NAME\n"));
    GNUNET_SCHEDULER_shutdown ();
    ret = -1;
    return;
  }
  else
  {
    identity_cb ((void *) cfg, ego);
  }
}

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

References cfg, default_ego_cb(), and GNUNET_IDENTITY_get().

Referenced by run().

{
  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;

  (void) ctx;
  (void) name;
  if (NULL != ego)
    return;
  get_default =
    GNUNET_IDENTITY_get (idh, "namestore", &default_ego_cb, (void *) cfg);
}

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

References _, do_shutdown(), ego_name, getenv(), GNUNET_ERROR_TYPE_WARNING, GNUNET_IDENTITY_connect(), GNUNET_IDENTITY_ego_lookup(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_STRINGS_string_to_data(), id_connect_cb(), identity_cb(), ret, run_with_zone_pkey(), uri, and zone_pkey.

Referenced by main().

{
  const char *pkey_str;

  (void) cls;
  (void) args;
  (void) cfgfile;
  if (NULL != args[0])
    GNUNET_log (
      GNUNET_ERROR_TYPE_WARNING,
      _ ("Superfluous command line arguments (starting with `%s') ignored\n"),
      args[0]);
  if ((NULL != args[0]) && (NULL == uri))
    uri = GNUNET_strdup (args[0]);

  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
  pkey_str = getenv ("GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
  if (NULL != pkey_str)
  {
    if (GNUNET_OK != GNUNET_STRINGS_string_to_data (pkey_str,
                                                    strlen (pkey_str),
                                                    &zone_pkey,
                                                    sizeof(zone_pkey)))
    {
      fprintf (stderr,
               "Malformed private key `%s' in $%s\n",
               pkey_str,
               "GNUNET_NAMESTORE_EGO_PRIVATE_KEY");
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    run_with_zone_pkey (cfg);
    return;
  }
  if (NULL == ego_name)
  {
    idh = GNUNET_IDENTITY_connect (cfg, &id_connect_cb, (void *) cfg);
    if (NULL == idh)
      fprintf (stderr, _ ("Cannot connect to identity service\n"));
    ret = -1;
    return;
  }
  el = GNUNET_IDENTITY_ego_lookup (cfg, ego_name, &identity_cb, (void *) cfg);
}

Here is the call graph for this function:

Here is the caller graph for this function:

multirecord_process()

static int multirecord_process ( struct GNUNET_GETOPT_CommandLineProcessorContext *  ctx, void *  scls, const char *  option, const char *  value  )

static

Command-line option parser function that allows the user to specify a complete record as one argument for adding/removing.

A pointer to the head of the list of record sets must be passed as the "scls" argument.

Parameters

ctx	command line processor context
scls	must be of type "struct GNUNET_FS_Uri **"
option	name of the option (typically 'R')
value	command line argument given; format is "TTL TYPE FLAGS VALUE" where TTL is an expiration time (rel or abs), always given in seconds (without the unit), TYPE is a DNS/GNS record type, FLAGS is either "n" for no flags or a combination of 's' (shadow) and 'p' (public) and VALUE is the value (in human-readable format)

Returns

GNUNET_OK on success

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

References _, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, etime_is_rel, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_asprintf(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_GNSRECORD_number_to_typename(), GNUNET_GNSRECORD_RF_NONE, GNUNET_GNSRECORD_RF_PRIVATE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SHADOW_RECORD, GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_typename_to_number(), GNUNET_log, GNUNET_malloc, GNUNET_OK, GNUNET_strdup, GNUNET_SYSERR, head, RecordSetEntry::next, parse_expiration(), RecordSetEntry::record, and GNUNET_GNSRECORD_Data::record_type.

Referenced by multirecord_option().

{
  struct RecordSetEntry **head = scls;
  struct RecordSetEntry *r;
  struct GNUNET_GNSRECORD_Data record;
  char *cp;
  char *tok;
  char *saveptr;
  int etime_is_rel;
  void *raw_data;

  (void) ctx;
  (void) option;
  cp = GNUNET_strdup (value);
  tok = strtok_r (cp, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Empty record line argument is not allowed.\n"));
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  {
    char *etime_in_s;

    GNUNET_asprintf (&etime_in_s, "%s s", tok);
    if (GNUNET_OK !=
        parse_expiration (etime_in_s, &etime_is_rel, &record.expiration_time))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Invalid expiration time `%s' (must be without unit)\n"),
                  tok);
      GNUNET_free (cp);
      GNUNET_free (etime_in_s);
      return GNUNET_SYSERR;
    }
    GNUNET_free (etime_in_s);
  }
  tok = strtok_r (NULL, " ", &saveptr);
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Missing entries in record line `%s'.\n"),
                value);
    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,
                _ ("Missing entries in record line `%s'.\n"),
                value);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  record.flags = GNUNET_GNSRECORD_RF_NONE;
  if (etime_is_rel)
    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_SHADOW_RECORD;
  /* find beginning of record value */
  tok = strchr (&value[tok - cp], (unsigned char) ' ');
  if (NULL == tok)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Missing entries in record line `%s'.\n"),
                value);
    GNUNET_free (cp);
    return GNUNET_SYSERR;
  }
  GNUNET_free (cp);
  tok++; /* skip space */
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

multirecord_option()

struct GNUNET_GETOPT_CommandLineOption multirecord_option	(	char	shortName,
		const char *	name,
		const char *	argumentHelp,
		const char *	description,
		struct RecordSetEntry **	rs
	)

Allow user to specify keywords.

Parameters

	shortName	short name of the option
	name	long name of the option
	argumentHelp	help text for the option argument
	description	long help text for the option
[out]	topKeywords	set to the desired value

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

References GNUNET_GETOPT_CommandLineOption::argumentHelp, GNUNET_GETOPT_CommandLineOption::description, multirecord_process(), name, and GNUNET_GETOPT_CommandLineOption::shortName.

Referenced by main().

{
  struct GNUNET_GETOPT_CommandLineOption clo = { .shortName = shortName,
                                                 .name = name,
                                                 .argumentHelp = argumentHelp,
                                                 .description = description,
                                                 .require_argument = 1,
                                                 .processor =
                                                   &multirecord_process,
                                                 .scls = (void *) rs };

  return clo;
}

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

References _, add, del, ego_name, expirationstring, gettext_noop, GNUNET_CRYPTO_ecdsa_key_clear(), 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(), is_public, is_shadow, list, monitor, multirecord_option(), nickstring, ret, reverse_pkey, run(), typestring, uri, value, and zone_pkey.

{
  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_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_string ('r',
                                 "reverse",
                                 "PKEY",
                                 gettext_noop (
                                   "determine our name for the given PKEY"),
                                 &reverse_pkey),
    multirecord_option (
      'R',
      "replace",
      "RECORDLINE",
      gettext_noop (
        "set record set to values given by (possibly multiple) RECORDLINES; can be specified multiple times"),
      &recordset),
    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 (
      '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 };
  int lret;

  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);
    GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
    return lret;
  }
  GNUNET_free_nz ((void *) argv);
  GNUNET_CRYPTO_ecdsa_key_clear (&zone_pkey);
  return ret;
}

Here is the call graph for this function:

Variable Documentation

ns

struct GNUNET_NAMESTORE_Handle* ns

static

Handle to the namestore.

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

zone_pkey

struct GNUNET_CRYPTO_EcdsaPrivateKey zone_pkey

static

Private key for the our zone.

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

Referenced by del_monitor(), do_shutdown(), get_existing_record(), identity_cb(), main(), run(), and run_with_zone_pkey().

el

struct GNUNET_IDENTITY_EgoLookup* el

static

Handle to identity lookup.

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

idh

struct GNUNET_IDENTITY_Handle* idh

static

Identity service handle.

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

get_default

struct GNUNET_IDENTITY_Operation* get_default

Obtain default ego.

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

ego_name

char* ego_name

static

Name of the ego controlling the zone.

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

Referenced by handle_reverse_lookup(), identity_cb(), main(), and run().

add

int add

static

Desired action is to add a record.

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

Referenced by main(), 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 92 of file gnunet-namestore.c.

add_qe

struct GNUNET_NAMESTORE_QueueEntry* add_qe

static

Queue entry for the 'add' operation.

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

get_qe

struct GNUNET_NAMESTORE_QueueEntry* get_qe

static

Queue entry for the 'lookup' operation.

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

reverse_qe

struct GNUNET_NAMESTORE_QueueEntry* reverse_qe

static

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

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

list

int list

static

Desired action is to list records.

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

Referenced by main(), and run_with_zone_pkey().

list_it

struct GNUNET_NAMESTORE_ZoneIterator* list_it

static

List iterator for the 'list' operation.

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

del

int del

static

Desired action is to remove a record.

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

Referenced by forward_resolution(), GNUNET_ABD_delegate_issue(), handle_delegate_collection_cb(), 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 127 of file gnunet-namestore.c.

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

is_shadow

int is_shadow

static

Is record a shadow record (GNUNET_GNSRECORD_RF_SHADOW_RECORD)

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

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

set_qe

struct GNUNET_NAMESTORE_QueueEntry* set_qe

static

Queue entry for the 'set/replace' operation.

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

name

char* name

static

Name of the records to add/list/remove.

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

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

value

char* value

static

Value of the record to add/remove.

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

Referenced by add_get_request_to_pending(), add_setter_action(), add_to_tc(), age_values(), attr_in_claims_request(), bandwidth_stats_iterator(), barrier_destroy_iterator(), bind_loose_channel(), build_result_set(), cache_clear_iterator(), call_iterator(), cancel_pending_request(), change_peer_respect(), channel_destroy_iterator(), check_connection_quality(), check_known_address(), check_known_challenge(), check_validation_request_pending(), clean_local_client(), clean_request(), cleanup_channel(), cleanup_destination(), cleanup_iterator(), cleanup_validation_entry(), client_release_ports(), close_files_iter(), collector(), consume_cont(), consume_ticket(), cookie_identity_interpretation(), database_setup(), debug_channel(), decrementBit(), del_monitor(), delete_entries(), 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(), disconnect_all_neighbours(), disconnect_and_free_peer_entry(), dns_string_to_value(), dns_value_to_string(), do_flood(), do_restart_typemap_message(), drop_client_entries(), escape_name(), 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_by_unique_id(), find_closest(), find_result_set(), find_sender_by_address(), find_trees(), flush_respect(), forward_reply(), free_ack_cummulator_cb(), free_addr_it(), free_all_it(), free_backtalker_cb(), free_blacklist_entry(), free_connect_info(), free_dv_routes_cb(), free_ego(), free_entry(), free_host_entry(), free_item(), free_matching_requests(), free_neighbour_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(), get_active_address_it(), get_all_peers_iterator(), get_all_tunnels_iterator(), get_cb(), get_iterator(), get_queue_delete_it(), get_receiver_delete_it(), get_result_present(), get_sender_delete_it(), get_session_delete_it(), get_url_parameter_copy(), GNUNET_CONFIGURATION_deserialize(), GNUNET_NETWORK_socket_disable_corking(), GSF_cadet_release_clients(), handle_ack(), handle_set(), 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(), iterate_addresses(), iterate_channels_cb(), iterate_entries(), iterate_reachables(), iterate_zones(), iterator_bf_create(), iterator_bf_reduce(), jwt_parse_attributes(), libgnunet_plugin_rest_openid_connect_done(), locate_by_id(), lookup_queue_it(), lookup_session_it(), main(), mark_match_down(), mark_peer_down(), move_to_pending(), move_to_queue(), neighbour_delete(), neighbours_iterate(), normalize_address(), notify_change(), notify_client_about_session(), notify_client_queues(), notify_tunnel_up_cb(), op_get_element_iterator(), opc_free_iterator(), opc_search_iterator(), open_port_cb(), parse_jwt(), parse_record(), parse_record_data(), peerinfo_it(), prepare_ibf_iterator(), printer(), process(), process_client_result(), process_reply(), process_result_with_request(), process_stat_in(), process_update_node(), put_cb(), rcop_cleanup_iterator(), reachability_iterator(), regex_cancel_dht_get(), regex_result_iterator(), reghost_free_iterator(), reghost_match_iterator(), remove_by_unique_id(), remove_iterator(), reschedule_hellos(), rewatch_it(), 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_utilization_data(), session_cmp_it(), session_disconnect_it(), session_lookup_client_by_address(), session_lookup_it(), session_tag_it(), set_cont(), set_insert_iterator(), signal_result_resume(), socket_set_nodelay(), stat_iterator(), stop_peer_request(), store_and_free_entries(), stun_attr2str(), stun_msg2str(), sum_relative_preferences(), template_plugin_update_session_timeout(), test_blacklisted(), test_exist_cb(), test_result_present(), ticket_collect(), transmit_suggestion(), try_add_peers(), try_combine_recent(), update_abs_sum(), update_flood_times(), update_iterator(), update_rel_sum(), update_sre_result_maps(), validation_entry_match(), watch_notifier_it(), write_item(), and zone_to_name().

uri

char* uri

static

URI to import.

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

Referenced by do_shutdown(), main(), run(), and run_with_zone_pkey().

reverse_pkey

char* reverse_pkey

static

Reverse lookup to perform.

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

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

expirationstring

char* expirationstring

static

Desired expiration time.

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

Referenced by main(), and run_with_zone_pkey().

nickstring

char* nickstring

static

Desired nick name.

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

Referenced by main(), and run_with_zone_pkey().

ret

int ret

static

Global return value.

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

Referenced by add_continuation(), add_error_cb(), default_ego_cb(), del_lookup_error_cb(), del_monitor(), get_existing_record(), identity_cb(), main(), replace_cont(), run(), run_with_zone_pkey(), and zone_iteration_error_cb().

type

uint32_t type

static

Type string converted to DNS type value.

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

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

data_size

size_t data_size

static

Number of bytes in data.

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

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

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

zm

struct GNUNET_NAMESTORE_ZoneMonitor* zm

static

Monitor handle.

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

Referenced by check_result(), client_disconnect_cb(), continue_store_activity(), GNUNET_NAMESTORE_zone_monitor_start(), handle_monitor_next(), handle_monitor_start(), handle_result(), handle_sync(), monitor_iterate_cb(), monitor_iteration_next(), mq_error_handler(), and warn_monitor_slow().

monitor

int monitor

static

Enables monitor mode.

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