gnunet-namestore-zonefile.c File Reference

#include "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_namestore_plugin.h>

Include dependency graph for gnunet-namestore-zonefile.c:

Go to the source code of this file.

Data Structures
struct	Zone
	Egos / Zones. More...
struct	MissingZoneCreationCtx
	Missing identity creation context. More...
struct	Job
	Request we should make. More...

Macros
#define	MAX_RECORDS_PER_NAME   50
#define	MAX_ZONEFILE_LINE_LEN   4096
	Maximum length of a zonefile line.
#define	MAX_ZONEFILE_RECORD_DATA_LEN   2048
	FIXME: Soft limit this?
#define	THRESH   100
	Maximum number of queries pending at the same time.
#define	TIME_THRESH   10
	TIME_THRESH is in usecs.
#define	SERIES_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10)
	How long do we wait at least between series of requests?

Enumerations
enum	ZonefileImportState { ZS_READY , ZS_ORIGIN_SET , ZS_ORIGIN_CHANGED , ZS_NAME_CHANGED }

Functions
static void	do_shutdown (void *cls)
	Task run on shutdown.
static void	parse (void *cls)
	Main function that will be run.
static char *	trim (char *line)
static char *	next_token (char *token)
static int	parse_ttl (char *token, struct GNUNET_TIME_Relative *pttl)
static int	parse_origin (char *token, char *porigin)
static void	origin_create_cb (void *cls, const struct GNUNET_CRYPTO_PrivateKey *pk, enum GNUNET_ErrorCode ec)
static void	ensure_ego_and_continue (const char *ego_name)
static void	add_continuation (void *cls, enum GNUNET_ErrorCode ec)
static void	process_queue (void *cls)
	Process as many requests as possible from the queue.
static void	insert_sorted (struct Job *job)
	Insert req into DLL sorted by next fetch time.
static void	queue (const char *label, uint32_t rd_count, struct GNUNET_GNSRECORD_Data *rd, const struct Zone *zone)
	Add hostname to the list of requests to be made.
static void	identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *_cfg)
int	main (int argc, char *const *argv)
	The main function for gnunet-namestore-dbtool.

Variables
static struct GNUNET_CONTAINER_Heap *	req_heap
	Heap of all requests to perform, sorted by the time we should next do the request (i.e.
static struct Job *	req_head
	Active requests are kept in a DLL.
static struct Job *	req_tail
	Active requests are kept in a DLL.
static struct Zone *	zone_head
	Head of list of zones we are managing.
static struct Zone *	zone_tail
	Tail of list of zones we are managing.
static struct GNUNET_GNSRECORD_Data	rd [50]
	The record data under a single label.
static struct GNUNET_TIME_Relative	ttl
	Current record $TTL to use.
static char	origin [GNUNET_DNSPARSER_MAX_NAME_LENGTH]
	Current origin.
static unsigned int	rd_count = 0
	Number of records for currently parsed set.
static int	ret = 0
	Return code.
static char *	ego_name = NULL
	Name of the ego.
static char *	res
	Currently read line or NULL on EOF.
static unsigned int	published_sets = 0
	Statistics, how many published record sets.
static unsigned int	published_records = 0
	Statistics, how many records published in aggregate.
static struct Zone *	current_zone
	Private key for the our zone.
static struct GNUNET_NAMESTORE_QueueEntry *	ns_qe
	Queue entry for the 'add' operation.
static struct GNUNET_NAMESTORE_Handle *	ns
	Handle to the namestore.
static struct GNUNET_IDENTITY_Operation *	id_op
	Origin create operations.
static struct GNUNET_IDENTITY_Handle *	id
	Handle to IDENTITY.
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Current configurataion.
static struct GNUNET_SCHEDULER_Task *	t
	Main task.
static unsigned int	pending
	The number of DNS queries that are outstanding.
static unsigned int	pending_rs
	The number of NAMESTORE record store operations that are outstanding.
static int	state
	The current state of the parser.
static struct GNUNET_TIME_Absolute	sleep_time_reg_proc
	Last time we worked before going idle.

Macro Definition Documentation

MAX_RECORDS_PER_NAME

#define MAX_RECORDS_PER_NAME   50

Definition at line 44 of file gnunet-namestore-zonefile.c.

MAX_ZONEFILE_LINE_LEN

#define MAX_ZONEFILE_LINE_LEN   4096

Maximum length of a zonefile line.

Definition at line 49 of file gnunet-namestore-zonefile.c.

MAX_ZONEFILE_RECORD_DATA_LEN

#define MAX_ZONEFILE_RECORD_DATA_LEN   2048

FIXME: Soft limit this?

Definition at line 54 of file gnunet-namestore-zonefile.c.

THRESH

#define THRESH   100

Maximum number of queries pending at the same time.

Definition at line 59 of file gnunet-namestore-zonefile.c.

TIME_THRESH

#define TIME_THRESH   10

TIME_THRESH is in usecs.

How quickly do we submit fresh queries. Used as an additional throttle.

Definition at line 65 of file gnunet-namestore-zonefile.c.

SERIES_DELAY

#define SERIES_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10)

How long do we wait at least between series of requests?

Definition at line 70 of file gnunet-namestore-zonefile.c.

{
  struct Zone *next;
 
  struct Zone *prev;
 
  char *domain;
 
  struct GNUNET_CRYPTO_PrivateKey key;
};
 
struct MissingZoneCreationCtx
{
  // DLL
  struct MissingZoneCreationCtx *next;
 
  // DLL
  struct MissingZoneCreationCtx *prev;
 
  // Operation
  struct GNUNET_IDENTITY_Operation *id_op;
 
  // NS Operation
  struct GNUNET_NAMESTORE_QueueEntry *ns_qe;
 
  // Request
  struct Job *job;
 
  // Name
  char *name;
};
 
struct Job
{
  struct GNUNET_CONTAINER_HeapNode *hn;
 
  struct Job *next;
 
  struct Job *prev;
 
  struct Record *rec_head;
 
  struct Record *rec_tail;
 
  char label[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
 
  struct GNUNET_NAMESTORE_QueueEntry *qe;
 
  const struct Zone *zone;
 
  struct GNUNET_TIME_Absolute expires;
 
  struct GNUNET_TIME_Absolute op_start_time;
 
  // Records to store in job
  struct GNUNET_GNSRECORD_Data *rd;
 
  // Number of records to store in job
  uint32_t rd_count;
};
 
static struct GNUNET_CONTAINER_Heap *req_heap;
 
static struct Job *req_head;
 
static struct Job *req_tail;
 
 
static struct Zone *zone_head;
 
static struct Zone *zone_tail;
 
 
static struct GNUNET_GNSRECORD_Data rd[MAX_RECORDS_PER_NAME];
 
static struct GNUNET_TIME_Relative ttl;
 
static char origin[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
 
static unsigned int rd_count = 0;
 
static int ret = 0;
 
static char *ego_name = NULL;
 
static char *res;
 
static unsigned int published_sets = 0;
 
static unsigned int published_records = 0;
 
 
static struct Zone *current_zone;
 
static struct GNUNET_NAMESTORE_QueueEntry *ns_qe;
 
static struct GNUNET_NAMESTORE_Handle *ns;
 
static struct GNUNET_IDENTITY_Operation *id_op;
 
static struct GNUNET_IDENTITY_Handle *id;
 
static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
static struct GNUNET_SCHEDULER_Task *t;
 
static unsigned int pending;
 
static unsigned int pending_rs;
 
 
static int state;
 
static struct GNUNET_TIME_Absolute sleep_time_reg_proc;
 
enum ZonefileImportState
{
 
  /* Uninitialized */
  ZS_READY,
 
  /* The initial state */
  ZS_ORIGIN_SET,
 
  /* The $ORIGIN has changed */
  ZS_ORIGIN_CHANGED,
 
  /* The record name/label has changed */
  ZS_NAME_CHANGED
 
};
 
 
static void
do_shutdown (void *cls)
{
  (void) cls;
  if (NULL != ego_name)
    GNUNET_free (ego_name);
  if (NULL != ns_qe)
    GNUNET_NAMESTORE_cancel (ns_qe);
  if (NULL != id_op)
    GNUNET_IDENTITY_cancel (id_op);
  if (NULL != ns)
    GNUNET_NAMESTORE_disconnect (ns);
  if (NULL != id)
    GNUNET_IDENTITY_disconnect (id);
  for (int i = 0; i < rd_count; i++)
  {
    void *rd_ptr = (void*) rd[i].data;
    GNUNET_free (rd_ptr);
  }
  if (NULL != t)
    GNUNET_SCHEDULER_cancel (t);
}
 
 
static void
parse (void *cls);
 
static char*
trim (char *line)
{
  char *ltrimmed = line;
  int ltrimmed_len;
  int quoted = 0;
 
  // Trim all whitespace to the left
  while (*ltrimmed == ' ')
    ltrimmed++;
  ltrimmed_len = strlen (ltrimmed);
  // Find the first occurrence of an unqoted ';', which is our comment
  for (int i = 0; i < ltrimmed_len; i++)
  {
    if (ltrimmed[i] == '"')
      quoted = ! quoted;
    if ((ltrimmed[i] != ';') || quoted)
      continue;
    ltrimmed[i] = '\0';
  }
  ltrimmed_len = strlen (ltrimmed);
  // Remove trailing whitespace
  for (int i = ltrimmed_len; i > 0; i--)
  {
    if (ltrimmed[i - 1] != ' ')
      break;
    ltrimmed[i - 1] = '\0';
  }
  ltrimmed_len = strlen (ltrimmed);
  if (ltrimmed[ltrimmed_len - 1] == '\n')
    ltrimmed[ltrimmed_len - 1] = ' ';
  return ltrimmed;
}
 
 
static char*
next_token (char *token)
{
  char *next = token;
  while (*next == ' ')
    next++;
  return next;
}
 
 
static int
parse_ttl (char *token, struct GNUNET_TIME_Relative *pttl)
{
  char *next;
  unsigned int ttl_tmp;
 
  next = strchr (token, ';');
  if (NULL != next)
    next[0] = '\0';
  next = strchr (token, ' ');
  if (NULL != next)
    next[0] = '\0';
  if (1 != sscanf (token, "%u", &ttl_tmp))
  {
    fprintf (stderr, "Unable to parse TTL `%s'\n", token);
    return GNUNET_SYSERR;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TTL is: %u\n", ttl_tmp);
  pttl->rel_value_us = ttl_tmp * 1000 * 1000;
  return GNUNET_OK;
}
 
 
static int
parse_origin (char *token, char *porigin)
{
  char *next;
  next = strchr (token, ';');
  if (NULL != next)
    next[0] = '\0';
  next = strchr (token, ' ');
  if (NULL != next)
    next[0] = '\0';
  strcpy (porigin, token);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Origin is: %s\n", porigin);
  return GNUNET_OK;
}
 
 
static void
origin_create_cb (void *cls,
                  const struct GNUNET_CRYPTO_PrivateKey *pk,
                  enum GNUNET_ErrorCode ec)
{
  struct Zone *zone;
  id_op = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr, "Error: %s\n", GNUNET_ErrorCode_get_hint (ec));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Created missing ego `%s'\n",
              ego_name);
  zone = GNUNET_new (struct Zone);
  zone->key = *pk;
  zone->domain = GNUNET_strdup (ego_name);
  GNUNET_CONTAINER_DLL_insert (zone_head, zone_tail, zone);
  // FIXME add delegation to parent zone
  state = ZS_ORIGIN_SET;
  current_zone = zone;
  t = GNUNET_SCHEDULER_add_now (&parse, NULL);
}
 
 
static void
ensure_ego_and_continue (const char*ego_name)
{
  struct Zone *zone;
  for (zone = zone_head; NULL != zone; zone = zone->next)
    if (0 == strcmp (zone->domain, ego_name))
      break;
  if (NULL == zone)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "$ORIGIN %s does not exist, creating...\n", ego_name);
    id_op = GNUNET_IDENTITY_create (id, ego_name, NULL,
                                    GNUNET_PUBLIC_KEY_TYPE_EDDSA, // FIXME make configurable
                                    origin_create_cb,
                                    NULL);
    return;
  }
  state = ZS_ORIGIN_SET;
  current_zone = zone;
  t = GNUNET_SCHEDULER_add_now (&parse, NULL);
}
 
 
static void
add_continuation (void *cls, enum GNUNET_ErrorCode ec)
{
  ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr,
             _ ("Failed to store records...\n"));
    GNUNET_SCHEDULER_shutdown ();
    ret = -1;
  }
  if (ZS_ORIGIN_CHANGED == state)
  {
    if (NULL != ego_name)
      GNUNET_free (ego_name);
    ego_name = GNUNET_strdup (origin);
    if (ego_name[strlen (ego_name) - 1] == '.')
      ego_name[strlen (ego_name) - 1] = '\0';
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Changing origin to %s\n", ego_name);
    ensure_ego_and_continue (ego_name);
    return;
  }
  t = GNUNET_SCHEDULER_add_now (&parse, NULL);
}
 
 
static void
process_queue (void *cls)
{
  struct Job *job;
 
  (void) cls;
  t = NULL;
  while (pending + pending_rs < THRESH)
  {
    job = GNUNET_CONTAINER_heap_peek (req_heap);
    if (NULL == job)
      break;
    if (NULL != job->qe)
      return;   /* namestore op still pending */
    if (GNUNET_TIME_absolute_get_remaining (job->expires).rel_value_us > 0)
      break;
    GNUNET_assert (job == GNUNET_CONTAINER_heap_remove_root (req_heap));
    job->hn = NULL;
    GNUNET_CONTAINER_DLL_insert (req_head, req_tail, job);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Requesting store for `%s'\n",
                job->label);
    job->op_start_time = GNUNET_TIME_absolute_get ();
    job->qe = GNUNET_NAMESTORE_record_set_store (ns,
                                                 &job->zone->key,
                                                 job->label,
                                                 job->rd_count,
                                                 job->rd,
                                                 &add_continuation,
                                                 job);
    GNUNET_assert (NULL != job->qe);
    pending++;
  }
  if (pending + pending_rs >= THRESH)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stopped processing queue (%u+%u/%u)]\n",
                pending,
                pending_rs,
                THRESH);
    return;   /* wait for replies */
  }
  job = GNUNET_CONTAINER_heap_peek (req_heap);
  if (NULL == job)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stopped processing queue: empty queue\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Throttling\n");
  if (NULL != t)
    GNUNET_SCHEDULER_cancel (t);
  sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
  t = GNUNET_SCHEDULER_add_delayed (SERIES_DELAY, &process_queue, NULL);
}
 
 
static void
insert_sorted (struct Job *job)
{
  job->hn =
    GNUNET_CONTAINER_heap_insert (req_heap, job, job->expires.abs_value_us);
}
 
 
static void
queue (const char *label,
       uint32_t rd_count,
       struct GNUNET_GNSRECORD_Data *rd,
       const struct Zone *zone)
{
  struct Job *job;
  struct GNUNET_HashContext *hctx;
  struct GNUNET_HashCode hc;
  size_t hlen;
 
  hlen = strlen (label) + 1;
  job = GNUNET_new (struct Job);
  job->rd = rd;
  job->rd_count = rd_count;
  GNUNET_assert (NULL != zone);
  job->zone = zone;
  GNUNET_memcpy (job->label, label, hlen);
  hctx = GNUNET_CRYPTO_hash_context_start ();
  GNUNET_CRYPTO_hash_context_read (hctx, job->label, hlen);
  GNUNET_CRYPTO_hash_context_read (hctx, job->zone, sizeof *zone);
  GNUNET_CRYPTO_hash_context_finish (hctx, &hc),
  insert_sorted (job);
}
 
 
static void
parse (void *cls)
{
  char buf[MAX_ZONEFILE_LINE_LEN];
  char payload[MAX_ZONEFILE_RECORD_DATA_LEN];
  char *next;
  char *token;
  char *payload_pos;
  static char lastname[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
  char newname[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
  void *data;
  size_t data_size;
  int ttl_line = 0;
  int type;
  int bracket_unclosed = 0;
  int quoted = 0;
  int ln = 0;
 
  t = NULL;
  /* use filename provided as 1st argument (stdin by default) */
  while ((res = fgets (buf, sizeof(buf), stdin)))                     /* read each line of input */
  {
    ln++;
    ttl_line = 0;
    token = trim (buf);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Trimmed line (bracket %s): `%s'\n",
                (bracket_unclosed > 0) ? "unclosed" : "closed",
                token);
    if ((0 == strlen (token)) ||
        ((1 == strlen (token)) && (' ' == *token)))
      continue; // I guess we can safely ignore blank lines
    if (bracket_unclosed == 0)
    {
      /* Payload is already parsed */
      payload_pos = payload;
      /* Find space */
      next = strchr (token, ' ');
      if (NULL == next)
      {
        fprintf (stderr, "Error at line %u: %s\n", ln, token);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      next[0] = '\0';
      next++;
      if (0 == (strcmp (token, "$ORIGIN")))
      {
        state = ZS_ORIGIN_CHANGED;
        token = next_token (next);
      }
      else if (0 == (strcmp (token, "$TTL")))
      {
        ttl_line = 1;
        token = next_token (next);
      }
      else
      {
        if (0 == strcmp (token, "IN")) // Inherit name from before
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Old name: %s\n", lastname);
          strcpy (newname, lastname);
          token[strlen (token)] = ' ';
        }
        else if (token[strlen (token) - 1] != '.') // no fqdn
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: %s\n", token);
          if (GNUNET_DNSPARSER_MAX_LABEL_LENGTH < strlen (token))
          {
            fprintf (stderr,
                     _ ("Name `%s' is too long\n"),
                     token);
            ret = 1;
            GNUNET_SCHEDULER_shutdown ();
            return;
          }
          strcpy (newname, token);
          token = next_token (next);
        }
        else if (0 == strcmp (token, origin))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: @\n");
          strcpy (newname, "@");
          token = next_token (next);
        }
        else
        {
          if (strlen (token) < strlen (origin))
          {
            fprintf (stderr, "Wrong origin: %s (expected %s)\n", token, origin);
            break; // FIXME error?
          }
          if (0 != strcmp (token + (strlen (token) - strlen (origin)), origin))
          {
            fprintf (stderr, "Wrong origin: %s (expected %s)\n", token, origin);
            break;
          }
          token[strlen (token) - strlen (origin) - 1] = '\0';
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: %s\n", token);
          if (GNUNET_DNSPARSER_MAX_LABEL_LENGTH < strlen (token))
          {
            fprintf (stderr,
                     _ ("Name `%s' is too long\n"),
                     token);
            ret = 1;
            GNUNET_SCHEDULER_shutdown ();
            return;
          }
          strcpy (newname, token);
          token = next_token (next);
        }
        if (0 != strcmp (newname, lastname) &&
            (0 < rd_count))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Name changed %s->%s, storing record set of %u elements\n",
                      lastname, newname,
                      rd_count);
          state = ZS_NAME_CHANGED;
        }
        else
        {
          strcpy (lastname, newname);
        }
      }
 
      if (ttl_line)
      {
        if (GNUNET_SYSERR == parse_ttl (token, &ttl))
        {
          fprintf (stderr, _ ("Failed to parse $TTL\n"));
          ret = 1;
          GNUNET_SCHEDULER_shutdown ();
          return;
        }
        continue;
      }
      if (ZS_ORIGIN_CHANGED == state)
      {
        if (GNUNET_SYSERR == parse_origin (token, origin))
        {
          fprintf (stderr, _ ("Failed to parse $ORIGIN from %s\n"), token);
          ret = 1;
          GNUNET_SCHEDULER_shutdown ();
          return;
        }
        break;
      }
      if (ZS_READY == state)
      {
        fprintf (stderr,
                 _ (
                   "You must provide $ORIGIN in your zonefile or via arguments (--zone)!\n"));
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      // This is a record, let's go
      if (MAX_RECORDS_PER_NAME == rd_count)
      {
        fprintf (stderr,
                 _ ("Only %u records per unique name supported.\n"),
                 MAX_RECORDS_PER_NAME);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      rd[rd_count].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
      rd[rd_count].expiration_time = ttl.rel_value_us;
      next = strchr (token, ' ');
      if (NULL == next)
      {
        fprintf (stderr, "Error, last token: %s\n", token);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        break;
      }
      next[0] = '\0';
      next++;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "class is: %s\n", token);
      while (*next == ' ')
        next++;
      token = next;
      next = strchr (token, ' ');
      if (NULL == next)
      {
        fprintf (stderr, "Error\n");
        break;
      }
      next[0] = '\0';
      next++;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "type is: %s\n", token);
      type = GNUNET_GNSRECORD_typename_to_number (token);
      rd[rd_count].record_type = type;
      while (*next == ' ')
        next++;
      token = next;
    }
    for (int i = 0; i < strlen (token); i++)
    {
      if (token[i] == '"')
        quoted = ! quoted;
      if ((token[i] == '(') && ! quoted)
        bracket_unclosed++;
      if ((token[i] == ')') && ! quoted)
        bracket_unclosed--;
    }
    GNUNET_assert (strlen (token) < sizeof payload - (payload_pos - payload));
    memcpy (payload_pos, token, strlen (token));
    payload_pos += strlen (token);
    if (bracket_unclosed > 0)
    {
      *payload_pos = ' ';
      payload_pos++;
      continue;
    }
    *payload_pos = '\0';
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "data is: %s\n\n", payload);
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_string_to_value (type, payload,
                                          &data,
                                          &data_size))
    {
      fprintf (stderr,
               _ ("Data `%s' invalid\n"),
               payload);
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    rd[rd_count].data = data;
    rd[rd_count].data_size = data_size;
    if (ZS_NAME_CHANGED == state)
      break;
    rd_count++;
  }
  if (rd_count > 0)
  {
    // We need to encode the lastname from punycode potentially.
    // FIXME we want to probably queue this request here.
    char *lastname_utf8;
    idna_to_unicode_8z8z (lastname,
                          &lastname_utf8,
                          IDNA_ALLOW_UNASSIGNED);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Queueing %d records\n",
                rd_count);
    queue (lastname_utf8,
           rd_count,
           rd,
           current_zone);
    published_sets++;
    published_records += rd_count;
    for (int i = 0; i < rd_count; i++)
    {
      data = (void*) rd[i].data;
      GNUNET_free (data);
    }
    if (ZS_NAME_CHANGED == state)
    {
      rd[0] = rd[rd_count]; // recover last rd parsed.
      rd_count = 1;
      strcpy (lastname, newname);
      state = ZS_ORIGIN_SET;
    }
    else
      rd_count = 0;
    if (ZS_ORIGIN_CHANGED == state)
    {
      if (NULL != ego_name)
        GNUNET_free (ego_name);
      ego_name = GNUNET_strdup (origin);
      if (ego_name[strlen (ego_name) - 1] == '.')
        ego_name[strlen (ego_name) - 1] = '\0';
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Changing origin to %s\n", ego_name);
      ensure_ego_and_continue (ego_name);
      return;
    }
    if (NULL != t)
      GNUNET_SCHEDULER_cancel (t);
    t = GNUNET_SCHEDULER_add_now (&parse, NULL);
    return;
  }
  if (ZS_ORIGIN_CHANGED == state)
  {
    if (NULL != ego_name)
      GNUNET_free (ego_name);
    ego_name = GNUNET_strdup (origin);
    if (ego_name[strlen (ego_name) - 1] == '.')
      ego_name[strlen (ego_name) - 1] = '\0';
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Changing origin to %s\n", ego_name);
    ensure_ego_and_continue (ego_name);
    return;
  }
  sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
  t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
  printf ("Published %u records sets with total %u records\n",
          published_sets, published_records);
  GNUNET_SCHEDULER_shutdown ();
}
 
 
static void
identity_cb (void *cls,
             struct GNUNET_IDENTITY_Ego *ego,
             void **ctx,
             const char *name)
{
  (void) cls;
  (void) ctx;
  static int initial_iteration = GNUNET_YES;
  static int ego_zone_found = GNUNET_NO;
 
  if (GNUNET_NO == initial_iteration)
    return;
  if (NULL == ego)
  {
    if (NULL == zone_head)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No zones found\n");
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    if ((NULL != ego_name) &&
        (GNUNET_NO == ego_zone_found))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Zone `%s' not found\n",
                  ego_name);
      ret = 2;
      GNUNET_SCHEDULER_shutdown ();
    }
    initial_iteration = GNUNET_NO;
    t = GNUNET_SCHEDULER_add_now (&parse, NULL);
    return;
  }
  if (NULL != name)
  {
    struct Zone *zone;
 
    zone = GNUNET_new (struct Zone);
    zone->key = *GNUNET_IDENTITY_ego_get_private_key (ego);
    zone->domain = GNUNET_strdup (name);
    GNUNET_CONTAINER_DLL_insert (zone_head, zone_tail, zone);
 
    if ((NULL != ego_name) &&
        (0 == strcmp (name,
                      ego_name)))
    {
      ego_zone_found = GNUNET_YES;
      sprintf (origin, "%s.", ego_name);
      state = ZS_ORIGIN_SET;
    }
  }
}
 
 
static void
run (void *cls,
     char *const *args,
     const char *cfgfile,
     const struct GNUNET_CONFIGURATION_Handle *_cfg)
{
  cfg = _cfg;
  req_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
  ns = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == ns)
  {
    fprintf (stderr,
             _ ("Failed to connect to NAMESTORE\n"));
    return;
  }
  id = GNUNET_IDENTITY_connect (cfg, identity_cb, NULL);
  if (NULL == id)
  {
    fprintf (stderr,
             _ ("Failed to connect to IDENTITY\n"));
    return;
  }
  state = ZS_READY;
}
 
 
int
main (int argc, char *const *argv)
{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_string ('z',
                                 "zone",
                                 "EGO",
                                 gettext_noop (
                                   "name of the ego controlling the zone"),
                                 &ego_name),
    GNUNET_GETOPT_OPTION_END
  };
  int lret;
 
  GNUNET_log_setup ("gnunet-namestore-dbtool", "WARNING", NULL);
  if (GNUNET_OK !=
      (lret = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                                  argc,
                                  argv,
                                  "gnunet-namestore-zonefile",
                                  _ (
                                    "GNUnet namestore database manipulation tool"),
                                  options,
                                  &run,
                                  NULL)))
  {
    return lret;
  }
  return ret;
}

Enumeration Type Documentation

ZonefileImportState

enum ZonefileImportState

Enumerator
ZS_READY
ZS_ORIGIN_SET
ZS_ORIGIN_CHANGED
ZS_NAME_CHANGED

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

{
 
  /* Uninitialized */
  ZS_READY,
 
  /* The initial state */
  ZS_ORIGIN_SET,
 
  /* The $ORIGIN has changed */
  ZS_ORIGIN_CHANGED,
 
  /* The record name/label has changed */
  ZS_NAME_CHANGED
 
};

Function Documentation

do_shutdown()

static void do_shutdown ( void *  cls )

static

Task run on shutdown.

Cleans up everything.

Parameters

cls

unused

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

{
  (void) cls;
  if (NULL != ego_name)
    GNUNET_free (ego_name);
  if (NULL != ns_qe)
    GNUNET_NAMESTORE_cancel (ns_qe);
  if (NULL != id_op)
    GNUNET_IDENTITY_cancel (id_op);
  if (NULL != ns)
    GNUNET_NAMESTORE_disconnect (ns);
  if (NULL != id)
    GNUNET_IDENTITY_disconnect (id);
  for (int i = 0; i < rd_count; i++)
  {
    void *rd_ptr = (void*) rd[i].data;
    GNUNET_free (rd_ptr);
  }
  if (NULL != t)
    GNUNET_SCHEDULER_cancel (t);
}

References data, ego_name, GNUNET_free, GNUNET_IDENTITY_cancel(), GNUNET_IDENTITY_disconnect(), GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_disconnect(), GNUNET_SCHEDULER_cancel(), id_op, ns, ns_qe, rd, rd_count, and t.

Here is the call graph for this function:

parse()

static void parse ( void *  cls )

static

Main function that will be run.

TODO:

• We must assume that names are not repeated later in the zonefile because our _store APIs are replacing. No sure if that is common in zonefiles.
• We must only actually store a record set when the name to store changes or the end of the file is reached. that way we can group them and add (see above).
• We need to hope our string formats are compatible, but seems ok.

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

{
  char buf[MAX_ZONEFILE_LINE_LEN];
  char payload[MAX_ZONEFILE_RECORD_DATA_LEN];
  char *next;
  char *token;
  char *payload_pos;
  static char lastname[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
  char newname[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
  void *data;
  size_t data_size;
  int ttl_line = 0;
  int type;
  int bracket_unclosed = 0;
  int quoted = 0;
  int ln = 0;
 
  t = NULL;
  /* use filename provided as 1st argument (stdin by default) */
  while ((res = fgets (buf, sizeof(buf), stdin)))                     /* read each line of input */
  {
    ln++;
    ttl_line = 0;
    token = trim (buf);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Trimmed line (bracket %s): `%s'\n",
                (bracket_unclosed > 0) ? "unclosed" : "closed",
                token);
    if ((0 == strlen (token)) ||
        ((1 == strlen (token)) && (' ' == *token)))
      continue; // I guess we can safely ignore blank lines
    if (bracket_unclosed == 0)
    {
      /* Payload is already parsed */
      payload_pos = payload;
      /* Find space */
      next = strchr (token, ' ');
      if (NULL == next)
      {
        fprintf (stderr, "Error at line %u: %s\n", ln, token);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      next[0] = '\0';
      next++;
      if (0 == (strcmp (token, "$ORIGIN")))
      {
        state = ZS_ORIGIN_CHANGED;
        token = next_token (next);
      }
      else if (0 == (strcmp (token, "$TTL")))
      {
        ttl_line = 1;
        token = next_token (next);
      }
      else
      {
        if (0 == strcmp (token, "IN")) // Inherit name from before
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Old name: %s\n", lastname);
          strcpy (newname, lastname);
          token[strlen (token)] = ' ';
        }
        else if (token[strlen (token) - 1] != '.') // no fqdn
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: %s\n", token);
          if (GNUNET_DNSPARSER_MAX_LABEL_LENGTH < strlen (token))
          {
            fprintf (stderr,
                     _ ("Name `%s' is too long\n"),
                     token);
            ret = 1;
            GNUNET_SCHEDULER_shutdown ();
            return;
          }
          strcpy (newname, token);
          token = next_token (next);
        }
        else if (0 == strcmp (token, origin))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: @\n");
          strcpy (newname, "@");
          token = next_token (next);
        }
        else
        {
          if (strlen (token) < strlen (origin))
          {
            fprintf (stderr, "Wrong origin: %s (expected %s)\n", token, origin);
            break; // FIXME error?
          }
          if (0 != strcmp (token + (strlen (token) - strlen (origin)), origin))
          {
            fprintf (stderr, "Wrong origin: %s (expected %s)\n", token, origin);
            break;
          }
          token[strlen (token) - strlen (origin) - 1] = '\0';
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "New name: %s\n", token);
          if (GNUNET_DNSPARSER_MAX_LABEL_LENGTH < strlen (token))
          {
            fprintf (stderr,
                     _ ("Name `%s' is too long\n"),
                     token);
            ret = 1;
            GNUNET_SCHEDULER_shutdown ();
            return;
          }
          strcpy (newname, token);
          token = next_token (next);
        }
        if (0 != strcmp (newname, lastname) &&
            (0 < rd_count))
        {
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Name changed %s->%s, storing record set of %u elements\n",
                      lastname, newname,
                      rd_count);
          state = ZS_NAME_CHANGED;
        }
        else
        {
          strcpy (lastname, newname);
        }
      }
 
      if (ttl_line)
      {
        if (GNUNET_SYSERR == parse_ttl (token, &ttl))
        {
          fprintf (stderr, _ ("Failed to parse $TTL\n"));
          ret = 1;
          GNUNET_SCHEDULER_shutdown ();
          return;
        }
        continue;
      }
      if (ZS_ORIGIN_CHANGED == state)
      {
        if (GNUNET_SYSERR == parse_origin (token, origin))
        {
          fprintf (stderr, _ ("Failed to parse $ORIGIN from %s\n"), token);
          ret = 1;
          GNUNET_SCHEDULER_shutdown ();
          return;
        }
        break;
      }
      if (ZS_READY == state)
      {
        fprintf (stderr,
                 _ (
                   "You must provide $ORIGIN in your zonefile or via arguments (--zone)!\n"));
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      // This is a record, let's go
      if (MAX_RECORDS_PER_NAME == rd_count)
      {
        fprintf (stderr,
                 _ ("Only %u records per unique name supported.\n"),
                 MAX_RECORDS_PER_NAME);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        return;
      }
      rd[rd_count].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
      rd[rd_count].expiration_time = ttl.rel_value_us;
      next = strchr (token, ' ');
      if (NULL == next)
      {
        fprintf (stderr, "Error, last token: %s\n", token);
        ret = 1;
        GNUNET_SCHEDULER_shutdown ();
        break;
      }
      next[0] = '\0';
      next++;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "class is: %s\n", token);
      while (*next == ' ')
        next++;
      token = next;
      next = strchr (token, ' ');
      if (NULL == next)
      {
        fprintf (stderr, "Error\n");
        break;
      }
      next[0] = '\0';
      next++;
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "type is: %s\n", token);
      type = GNUNET_GNSRECORD_typename_to_number (token);
      rd[rd_count].record_type = type;
      while (*next == ' ')
        next++;
      token = next;
    }
    for (int i = 0; i < strlen (token); i++)
    {
      if (token[i] == '"')
        quoted = ! quoted;
      if ((token[i] == '(') && ! quoted)
        bracket_unclosed++;
      if ((token[i] == ')') && ! quoted)
        bracket_unclosed--;
    }
    GNUNET_assert (strlen (token) < sizeof payload - (payload_pos - payload));
    memcpy (payload_pos, token, strlen (token));
    payload_pos += strlen (token);
    if (bracket_unclosed > 0)
    {
      *payload_pos = ' ';
      payload_pos++;
      continue;
    }
    *payload_pos = '\0';
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "data is: %s\n\n", payload);
    if (GNUNET_OK !=
        GNUNET_GNSRECORD_string_to_value (type, payload,
                                          &data,
                                          &data_size))
    {
      fprintf (stderr,
               _ ("Data `%s' invalid\n"),
               payload);
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    rd[rd_count].data = data;
    rd[rd_count].data_size = data_size;
    if (ZS_NAME_CHANGED == state)
      break;
    rd_count++;
  }
  if (rd_count > 0)
  {
    // We need to encode the lastname from punycode potentially.
    // FIXME we want to probably queue this request here.
    char *lastname_utf8;
    idna_to_unicode_8z8z (lastname,
                          &lastname_utf8,
                          IDNA_ALLOW_UNASSIGNED);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Queueing %d records\n",
                rd_count);
    queue (lastname_utf8,
           rd_count,
           rd,
           current_zone);
    published_sets++;
    published_records += rd_count;
    for (int i = 0; i < rd_count; i++)
    {
      data = (void*) rd[i].data;
      GNUNET_free (data);
    }
    if (ZS_NAME_CHANGED == state)
    {
      rd[0] = rd[rd_count]; // recover last rd parsed.
      rd_count = 1;
      strcpy (lastname, newname);
      state = ZS_ORIGIN_SET;
    }
    else
      rd_count = 0;
    if (ZS_ORIGIN_CHANGED == state)
    {
      if (NULL != ego_name)
        GNUNET_free (ego_name);
      ego_name = GNUNET_strdup (origin);
      if (ego_name[strlen (ego_name) - 1] == '.')
        ego_name[strlen (ego_name) - 1] = '\0';
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Changing origin to %s\n", ego_name);
      ensure_ego_and_continue (ego_name);
      return;
    }
    if (NULL != t)
      GNUNET_SCHEDULER_cancel (t);
    t = GNUNET_SCHEDULER_add_now (&parse, NULL);
    return;
  }
  if (ZS_ORIGIN_CHANGED == state)
  {
    if (NULL != ego_name)
      GNUNET_free (ego_name);
    ego_name = GNUNET_strdup (origin);
    if (ego_name[strlen (ego_name) - 1] == '.')
      ego_name[strlen (ego_name) - 1] = '\0';
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Changing origin to %s\n", ego_name);
    ensure_ego_and_continue (ego_name);
    return;
  }
  sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
  t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
  printf ("Published %u records sets with total %u records\n",
          published_sets, published_records);
  GNUNET_SCHEDULER_shutdown ();
}

References _, current_zone, data, GNUNET_GNSRECORD_Data::data, data_size, GNUNET_GNSRECORD_Data::data_size, ego_name, ensure_ego_and_continue(), GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_assert, GNUNET_DNSPARSER_MAX_LABEL_LENGTH, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_string_to_value(), GNUNET_GNSRECORD_typename_to_number(), GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_TIME_absolute_get(), MAX_RECORDS_PER_NAME, MAX_ZONEFILE_LINE_LEN, MAX_ZONEFILE_RECORD_DATA_LEN, next_token(), origin, parse(), parse_origin(), parse_ttl(), payload, process_queue(), published_records, published_sets, queue(), rd, rd_count, GNUNET_GNSRECORD_Data::record_type, GNUNET_TIME_Relative::rel_value_us, res, ret, sleep_time_reg_proc, state, t, trim(), ttl, type, ZS_NAME_CHANGED, ZS_ORIGIN_CHANGED, ZS_ORIGIN_SET, and ZS_READY.

Referenced by add_continuation(), ensure_ego_and_continue(), identity_cb(), origin_create_cb(), and parse().

Here is the call graph for this function:

Here is the caller graph for this function:

trim()

static char * trim ( char *  line )

static

Definition at line 376 of file gnunet-namestore-zonefile.c.

{
  char *ltrimmed = line;
  int ltrimmed_len;
  int quoted = 0;
 
  // Trim all whitespace to the left
  while (*ltrimmed == ' ')
    ltrimmed++;
  ltrimmed_len = strlen (ltrimmed);
  // Find the first occurrence of an unqoted ';', which is our comment
  for (int i = 0; i < ltrimmed_len; i++)
  {
    if (ltrimmed[i] == '"')
      quoted = ! quoted;
    if ((ltrimmed[i] != ';') || quoted)
      continue;
    ltrimmed[i] = '\0';
  }
  ltrimmed_len = strlen (ltrimmed);
  // Remove trailing whitespace
  for (int i = ltrimmed_len; i > 0; i--)
  {
    if (ltrimmed[i - 1] != ' ')
      break;
    ltrimmed[i - 1] = '\0';
  }
  ltrimmed_len = strlen (ltrimmed);
  if (ltrimmed[ltrimmed_len - 1] == '\n')
    ltrimmed[ltrimmed_len - 1] = ' ';
  return ltrimmed;
}

References line.

Referenced by parse().

Here is the caller graph for this function:

next_token()

static char * next_token ( char *  token )

static

Definition at line 411 of file gnunet-namestore-zonefile.c.

{
  char *next = token;
  while (*next == ' ')
    next++;
  return next;
}

Referenced by parse().

Here is the caller graph for this function:

parse_ttl()

static int parse_ttl ( char *  token, struct GNUNET_TIME_Relative *  pttl  )

static

Definition at line 421 of file gnunet-namestore-zonefile.c.

{
  char *next;
  unsigned int ttl_tmp;
 
  next = strchr (token, ';');
  if (NULL != next)
    next[0] = '\0';
  next = strchr (token, ' ');
  if (NULL != next)
    next[0] = '\0';
  if (1 != sscanf (token, "%u", &ttl_tmp))
  {
    fprintf (stderr, "Unable to parse TTL `%s'\n", token);
    return GNUNET_SYSERR;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "TTL is: %u\n", ttl_tmp);
  pttl->rel_value_us = ttl_tmp * 1000 * 1000;
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, and GNUNET_TIME_Relative::rel_value_us.

Referenced by parse().

Here is the caller graph for this function:

parse_origin()

static int parse_origin ( char *  token, char *  porigin  )

static

Definition at line 444 of file gnunet-namestore-zonefile.c.

{
  char *next;
  next = strchr (token, ';');
  if (NULL != next)
    next[0] = '\0';
  next = strchr (token, ' ');
  if (NULL != next)
    next[0] = '\0';
  strcpy (porigin, token);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Origin is: %s\n", porigin);
  return GNUNET_OK;
}

References GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, and GNUNET_OK.

Referenced by parse().

Here is the caller graph for this function:

origin_create_cb()

static void origin_create_cb ( void *  cls, const struct GNUNET_CRYPTO_PrivateKey *  pk, enum GNUNET_ErrorCode  ec  )

static

Definition at line 460 of file gnunet-namestore-zonefile.c.

{
  struct Zone *zone;
  id_op = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr, "Error: %s\n", GNUNET_ErrorCode_get_hint (ec));
    ret = 1;
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
              "Created missing ego `%s'\n",
              ego_name);
  zone = GNUNET_new (struct Zone);
  zone->key = *pk;
  zone->domain = GNUNET_strdup (ego_name);
  GNUNET_CONTAINER_DLL_insert (zone_head, zone_tail, zone);
  // FIXME add delegation to parent zone
  state = ZS_ORIGIN_SET;
  current_zone = zone;
  t = GNUNET_SCHEDULER_add_now (&parse, NULL);
}

References current_zone, Zone::domain, ego_name, GNUNET_CONTAINER_DLL_insert, GNUNET_EC_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, id_op, Zone::key, parse(), pk, ret, state, t, zone_head, zone_tail, and ZS_ORIGIN_SET.

Referenced by ensure_ego_and_continue().

Here is the call graph for this function:

Here is the caller graph for this function:

ensure_ego_and_continue()

static void ensure_ego_and_continue ( const char *  ego_name )

static

Definition at line 488 of file gnunet-namestore-zonefile.c.

{
  struct Zone *zone;
  for (zone = zone_head; NULL != zone; zone = zone->next)
    if (0 == strcmp (zone->domain, ego_name))
      break;
  if (NULL == zone)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "$ORIGIN %s does not exist, creating...\n", ego_name);
    id_op = GNUNET_IDENTITY_create (id, ego_name, NULL,
                                    GNUNET_PUBLIC_KEY_TYPE_EDDSA, // FIXME make configurable
                                    origin_create_cb,
                                    NULL);
    return;
  }
  state = ZS_ORIGIN_SET;
  current_zone = zone;
  t = GNUNET_SCHEDULER_add_now (&parse, NULL);
}

References current_zone, Zone::domain, ego_name, GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_create(), GNUNET_log, GNUNET_PUBLIC_KEY_TYPE_EDDSA, GNUNET_SCHEDULER_add_now(), id_op, Zone::next, origin_create_cb(), parse(), state, t, zone_head, and ZS_ORIGIN_SET.

Referenced by add_continuation(), and parse().

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

{
  ns_qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    fprintf (stderr,
             _ ("Failed to store records...\n"));
    GNUNET_SCHEDULER_shutdown ();
    ret = -1;
  }
  if (ZS_ORIGIN_CHANGED == state)
  {
    if (NULL != ego_name)
      GNUNET_free (ego_name);
    ego_name = GNUNET_strdup (origin);
    if (ego_name[strlen (ego_name) - 1] == '.')
      ego_name[strlen (ego_name) - 1] = '\0';
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Changing origin to %s\n", ego_name);
    ensure_ego_and_continue (ego_name);
    return;
  }
  t = GNUNET_SCHEDULER_add_now (&parse, NULL);
}

References _, ego_name, ensure_ego_and_continue(), GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, ns_qe, origin, parse(), ret, state, t, and ZS_ORIGIN_CHANGED.

Referenced by process_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

process_queue()

static void process_queue ( void *  cls )

static

Process as many requests as possible from the queue.

Parameters

cls

NULL

Definition at line 543 of file gnunet-namestore-zonefile.c.

{
  struct Job *job;
 
  (void) cls;
  t = NULL;
  while (pending + pending_rs < THRESH)
  {
    job = GNUNET_CONTAINER_heap_peek (req_heap);
    if (NULL == job)
      break;
    if (NULL != job->qe)
      return;   /* namestore op still pending */
    if (GNUNET_TIME_absolute_get_remaining (job->expires).rel_value_us > 0)
      break;
    GNUNET_assert (job == GNUNET_CONTAINER_heap_remove_root (req_heap));
    job->hn = NULL;
    GNUNET_CONTAINER_DLL_insert (req_head, req_tail, job);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Requesting store for `%s'\n",
                job->label);
    job->op_start_time = GNUNET_TIME_absolute_get ();
    job->qe = GNUNET_NAMESTORE_record_set_store (ns,
                                                 &job->zone->key,
                                                 job->label,
                                                 job->rd_count,
                                                 job->rd,
                                                 &add_continuation,
                                                 job);
    GNUNET_assert (NULL != job->qe);
    pending++;
  }
  if (pending + pending_rs >= THRESH)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stopped processing queue (%u+%u/%u)]\n",
                pending,
                pending_rs,
                THRESH);
    return;   /* wait for replies */
  }
  job = GNUNET_CONTAINER_heap_peek (req_heap);
  if (NULL == job)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stopped processing queue: empty queue\n");
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Throttling\n");
  if (NULL != t)
    GNUNET_SCHEDULER_cancel (t);
  sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
  t = GNUNET_SCHEDULER_add_delayed (SERIES_DELAY, &process_queue, NULL);
}

References add_continuation(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAMESTORE_record_set_store(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_remaining(), job, ns, pending, pending_rs, process_queue(), GNUNET_TIME_Relative::rel_value_us, req_head, req_heap, req_tail, SERIES_DELAY, sleep_time_reg_proc, t, and THRESH.

Referenced by parse(), and process_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_sorted()

static void insert_sorted ( struct Job *  job )

static

Insert req into DLL sorted by next fetch time.

Parameters

req	request to insert into req_heap

Definition at line 605 of file gnunet-namestore-zonefile.c.

{
  job->hn =
    GNUNET_CONTAINER_heap_insert (req_heap, job, job->expires.abs_value_us);
}

References GNUNET_CONTAINER_heap_insert(), job, and req_heap.

Referenced by queue().

Here is the call graph for this function:

Here is the caller graph for this function:

queue()

static void queue ( const char *  label, uint32_t  rd_count, struct GNUNET_GNSRECORD_Data *  rd, const struct Zone *  zone  )

static

Add hostname to the list of requests to be made.

Parameters

hostname

name to resolve

Definition at line 618 of file gnunet-namestore-zonefile.c.

{
  struct Job *job;
  struct GNUNET_HashContext *hctx;
  struct GNUNET_HashCode hc;
  size_t hlen;
 
  hlen = strlen (label) + 1;
  job = GNUNET_new (struct Job);
  job->rd = rd;
  job->rd_count = rd_count;
  GNUNET_assert (NULL != zone);
  job->zone = zone;
  GNUNET_memcpy (job->label, label, hlen);
  hctx = GNUNET_CRYPTO_hash_context_start ();
  GNUNET_CRYPTO_hash_context_read (hctx, job->label, hlen);
  GNUNET_CRYPTO_hash_context_read (hctx, job->zone, sizeof *zone);
  GNUNET_CRYPTO_hash_context_finish (hctx, &hc),
  insert_sorted (job);
}

References GNUNET_assert, GNUNET_CRYPTO_hash_context_finish(), GNUNET_CRYPTO_hash_context_read(), GNUNET_CRYPTO_hash_context_start(), GNUNET_memcpy, GNUNET_new, insert_sorted(), job, rd, and rd_count.

Referenced by boot_queue(), boot_queue(), check_for_global_natted(), check_for_queue_with_higher_prio(), check_vl_transmission(), core_read_finished_cb(), core_read_finished_cb(), decrypt_and_check_tc(), decrypt_and_check_tc(), destroy_message_control(), do_rekey(), do_rekey(), enqueue_message_control(), fragment_message(), free_pending_acknowledgement(), free_queue(), free_queue_entry(), free_timedout_queue_entry(), get_audiobin(), get_queue_delete_it(), get_queue_delete_it(), get_queue_delete_it(), GNUNET_TRANSPORT_TESTING_transport_communicator_service_stop(), handle_add_queue_message(), handle_del_queue_message(), handle_send_message_ack(), handshake_ack_monotime_cb(), handshake_ack_monotime_cb(), handshake_ack_monotime_store_cb(), handshake_ack_monotime_store_cb(), handshake_monotime_cb(), handshake_monotime_cb(), handshake_monotime_store_cb(), handshake_monotime_store_cb(), inject_rekey(), inject_rekey(), iterate_address_and_compare_cb(), iterate_message_control(), lookup_queue_it(), mq_cancel(), mq_cancel(), mq_cancel(), mq_destroy(), mq_destroy(), mq_destroy(), mq_error(), mq_error(), mq_error(), mq_init(), mq_init(), mq_init(), mq_send(), mq_send(), mq_send(), parse(), pass_plaintext_to_core(), pass_plaintext_to_core(), prepare_pending_acknowledgement(), proto_read_kx(), proto_read_kx(), queue_destroy(), queue_destroy(), queue_destroy(), queue_finish(), queue_finish(), queue_read(), queue_read(), queue_read_kx(), queue_read_kx(), queue_send_msg(), queue_timeout(), queue_write(), queue_write(), rekey_monotime_cb(), rekey_monotime_cb(), rekey_monotime_store_cb(), rekey_monotime_store_cb(), reliability_box_message(), reschedule_queue_timeout(), schedule_transmit_on_queue(), select_best_pending_from_link(), select_read_cb(), select_write_cb(), send_challenge(), send_challenge(), setup_in_cipher(), setup_in_cipher(), setup_in_cipher_elligator(), setup_in_cipher_elligator(), setup_out_cipher(), setup_out_cipher(), setup_queue(), start_initial_kx_out(), start_initial_kx_out(), task_message_control(), transmit_kx(), transmit_kx(), transmit_on_queue(), try_handle_plaintext(), and try_handle_plaintext().

Here is the call graph for this function:

identity_cb()

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

static

Definition at line 966 of file gnunet-namestore-zonefile.c.

{
  (void) cls;
  (void) ctx;
  static int initial_iteration = GNUNET_YES;
  static int ego_zone_found = GNUNET_NO;
 
  if (GNUNET_NO == initial_iteration)
    return;
  if (NULL == ego)
  {
    if (NULL == zone_head)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No zones found\n");
      ret = 1;
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    if ((NULL != ego_name) &&
        (GNUNET_NO == ego_zone_found))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  "Zone `%s' not found\n",
                  ego_name);
      ret = 2;
      GNUNET_SCHEDULER_shutdown ();
    }
    initial_iteration = GNUNET_NO;
    t = GNUNET_SCHEDULER_add_now (&parse, NULL);
    return;
  }
  if (NULL != name)
  {
    struct Zone *zone;
 
    zone = GNUNET_new (struct Zone);
    zone->key = *GNUNET_IDENTITY_ego_get_private_key (ego);
    zone->domain = GNUNET_strdup (name);
    GNUNET_CONTAINER_DLL_insert (zone_head, zone_tail, zone);
 
    if ((NULL != ego_name) &&
        (0 == strcmp (name,
                      ego_name)))
    {
      ego_zone_found = GNUNET_YES;
      sprintf (origin, "%s.", ego_name);
      state = ZS_ORIGIN_SET;
    }
  }
}

References ctx, Zone::domain, ego_name, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, GNUNET_YES, Zone::key, name, origin, parse(), ret, state, t, zone_head, zone_tail, and ZS_ORIGIN_SET.

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

Definition at line 1022 of file gnunet-namestore-zonefile.c.

{
  cfg = _cfg;
  req_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, (void *) cfg);
  ns = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == ns)
  {
    fprintf (stderr,
             _ ("Failed to connect to NAMESTORE\n"));
    return;
  }
  id = GNUNET_IDENTITY_connect (cfg, identity_cb, NULL);
  if (NULL == id)
  {
    fprintf (stderr,
             _ ("Failed to connect to IDENTITY\n"));
    return;
  }
  state = ZS_READY;
}

References _, cfg, do_shutdown, GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_IDENTITY_connect(), GNUNET_NAMESTORE_connect(), GNUNET_SCHEDULER_add_shutdown(), identity_cb(), ns, req_heap, state, and ZS_READY.

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

Parameters

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

Returns

0 ok, 1 on error

Definition at line 1056 of file gnunet-namestore-zonefile.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_option_string ('z',
                                 "zone",
                                 "EGO",
                                 gettext_noop (
                                   "name of the ego controlling the zone"),
                                 &ego_name),
    GNUNET_GETOPT_OPTION_END
  };
  int lret;
 
  GNUNET_log_setup ("gnunet-namestore-dbtool", "WARNING", NULL);
  if (GNUNET_OK !=
      (lret = GNUNET_PROGRAM_run (GNUNET_OS_project_data_gnunet (),
                                  argc,
                                  argv,
                                  "gnunet-namestore-zonefile",
                                  _ (
                                    "GNUnet namestore database manipulation tool"),
                                  options,
                                  &run,
                                  NULL)))
  {
    return lret;
  }
  return ret;
}

References _, ego_name, gettext_noop, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_string(), GNUNET_log_setup(), GNUNET_OK, GNUNET_OS_project_data_gnunet(), GNUNET_PROGRAM_run(), options, ret, and run().

Here is the call graph for this function:

Variable Documentation

req_heap

struct GNUNET_CONTAINER_Heap* req_heap

static

Heap of all requests to perform, sorted by the time we should next do the request (i.e.

by expires).

Definition at line 198 of file gnunet-namestore-zonefile.c.

Referenced by insert_sorted(), process_queue(), and run().

req_head

struct Job* req_head

static

Active requests are kept in a DLL.

Definition at line 203 of file gnunet-namestore-zonefile.c.

Referenced by process_queue().

req_tail

struct Job* req_tail

static

Active requests are kept in a DLL.

Definition at line 208 of file gnunet-namestore-zonefile.c.

Referenced by process_queue().

zone_head

struct Zone* zone_head

static

Head of list of zones we are managing.

Definition at line 214 of file gnunet-namestore-zonefile.c.

Referenced by ensure_ego_and_continue(), identity_cb(), and origin_create_cb().

zone_tail

struct Zone* zone_tail

static

Tail of list of zones we are managing.

Definition at line 219 of file gnunet-namestore-zonefile.c.

Referenced by identity_cb(), and origin_create_cb().

rd

struct GNUNET_GNSRECORD_Data rd[50]

static

The record data under a single label.

Reused. Hard limit.

Definition at line 226 of file gnunet-namestore-zonefile.c.

Referenced by array_cleanup(), attr_iter_cb(), attr_store_task(), backward_resolution(), block_create2(), block_create_ecdsa(), block_create_eddsa(), block_decrypt_ecdsa(), block_decrypt_eddsa(), block_get_size_ecdsa(), block_get_size_eddsa(), bulk_tx_start(), cb_key_monitor(), check_pkey(), check_rd(), check_result(), check_result(), clean_blind_sign_priv(), clean_blind_sign_pub(), clean_blinded_sig(), clean_rsa_public_key(), clean_rsa_signature(), clean_string(), clean_unblinded_sig(), clean_varsize_blob(), collect_tickets_cb(), consistency_iter(), continue_store_activity(), cred_iter_cb(), del_monitor(), DID_resolve_gns_lookup_cb(), dispatch_job(), dispatch_job_monitor(), display_record(), display_record_iterator(), display_record_lookup(), display_record_monitor(), display_records_from_block(), dns_result_parser(), do_shutdown(), filter_tickets_cb(), forward_resolution(), get_existing_rd_exp(), get_existing_record(), get_existing_record(), get_records_and_call_iterator(), GNUNET_CONVERSATION_phone_get_record(), GNUNET_GNSRECORD_block_calculate_size(), GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_create2(), GNUNET_GNSRECORD_block_create_unsigned(), GNUNET_GNSRECORD_is_expired(), GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_JSON_spec_gnsrecord(), GNUNET_GNSRECORD_normalize_record_set(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_NAMESTORE_record_set_store(), GNUNET_NAMESTORE_records_store(), handle_delegate_collection_cb(), handle_edit_record_set_response(), handle_gns2dns_result(), handle_gns_namecache_resolution_result(), handle_gns_resolution_result(), handle_gns_response(), handle_gns_response(), handle_gns_result(), handle_lookup_result(), handle_monitor_event(), handle_record(), handle_record_result(), handle_result(), handle_result(), handle_reverse_lookup(), handle_zone_to_name_it(), handle_zone_to_name_response(), lookup_authz_cb(), lookup_it(), lookup_nick_it(), lookup_redirect_uri_result(), monitor_iterate_cb(), namestore_flat_store_records(), namestore_list_iteration(), namestore_postgres_store_records(), namestore_sqlite_store_records(), ns_get_lookup_cb(), ns_lookup_cb(), ns_lookup_result_cb(), parse(), parse_record(), parse_result_call_iterator(), print_record(), process_lookup_result(), process_lookup_result(), process_parallel_lookup_result(), process_result(), process_result(), process_tickets(), purge_orphans_iterator(), purge_zone_iterator(), queue(), recursive_cname_resolution(), recursive_gns2dns_resolution(), recursive_pkey_resolution(), recursive_redirect_resolution(), reply_to_dns(), result_processor(), revoke_attrs_cb(), run(), run_edkey(), run_pkey(), run_with_zone_pkey(), rvk_move_attr_cb(), rvk_ticket_update(), send_lookup_response(), send_lookup_response_with_filter(), start_phone(), start_resolver_lookup(), store_record_set(), transmit_lookup_dns_result(), update_tickets(), vpn_allocation_cb(), zone_iterate_proc(), and zone_iterator().

ttl

struct GNUNET_TIME_Relative ttl

static

Current record $TTL to use.

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

Referenced by GNUNET_GNSRECORD_check_pow(), GNUNET_GNSRECORD_pow_start(), GSF_pending_request_create_(), GSF_pending_request_get_message_(), merge_pr(), and parse().

origin

char origin[GNUNET_DNSPARSER_MAX_NAME_LENGTH]

static

Current origin.

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

Referenced by add_continuation(), copy_list_messages(), create_response(), handle_connection_create(), handle_core_message(), handle_p2p_estimate(), identity_cb(), and parse().

rd_count

unsigned int rd_count = 0

static

Number of records for currently parsed set.

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

Referenced by attr_iter_cb(), backward_resolution(), block_create2(), block_create_ecdsa(), block_create_eddsa(), block_decrypt_ecdsa(), block_decrypt_eddsa(), block_get_size_ecdsa(), block_get_size_eddsa(), cb_key_monitor(), check_rd(), check_result(), check_result(), collect_tickets_cb(), consistency_iter(), continue_store_activity(), cred_iter_cb(), del_monitor(), DID_create_namestore_lookup_cb(), DID_resolve_gns_lookup_cb(), dispatch_job(), dispatch_job_monitor(), dns_result_parser(), do_shutdown(), filter_tickets_cb(), forward_resolution(), get_existing_rd_exp(), get_existing_record(), get_existing_record(), GNUNET_GNSRECORD_block_calculate_size(), GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_create2(), GNUNET_GNSRECORD_block_create_unsigned(), GNUNET_GNSRECORD_JSON_from_gnsrecord(), GNUNET_GNSRECORD_JSON_spec_gnsrecord(), GNUNET_GNSRECORD_normalize_record_set(), GNUNET_GNSRECORD_record_get_expiration_time(), GNUNET_GNSRECORD_records_deserialize(), GNUNET_GNSRECORD_records_deserialize_get_size(), GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_NAMESTORE_record_set_store(), GNUNET_NAMESTORE_records_store(), handle_delegate_collection_cb(), handle_edit_record_set_response(), handle_gns2dns_result(), handle_gns_namecache_resolution_result(), handle_gns_resolution_result(), handle_gns_response(), handle_gns_response(), handle_gns_result(), handle_lookup_result(), handle_monitor_event(), handle_record(), handle_record_result(), handle_result(), handle_result(), handle_reverse_lookup(), handle_zone_to_name_it(), handle_zone_to_name_response(), lookup_authz_cb(), lookup_it(), lookup_nick_it(), lookup_redirect_uri_result(), monitor_iterate_cb(), namestore_flat_store_records(), namestore_postgres_store_records(), namestore_sqlite_store_records(), ns_lookup_cb(), ns_lookup_result_cb(), parse(), process_command_stdin(), process_lookup_result(), process_lookup_result(), process_parallel_lookup_result(), process_result(), process_result(), process_tickets(), queue(), recursive_gns2dns_resolution(), reply_to_dns(), result_processor(), revoke_attrs_cb(), run_edkey(), run_pkey(), run_with_zone_pkey(), rvk_move_attr_cb(), rvk_ticket_update(), send_lookup_response(), send_lookup_response_with_filter(), store_record_set(), update_tickets(), vpn_allocation_cb(), and zone_iterate_proc().

ret

int ret = 0

static

Return code.

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

Referenced by add_continuation(), identity_cb(), main(), origin_create_cb(), and parse().

ego_name

char* ego_name = NULL

static

Name of the ego.

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

Referenced by add_continuation(), do_shutdown(), ensure_ego_and_continue(), identity_cb(), main(), origin_create_cb(), and parse().

res

char* res

static

Currently read line or NULL on EOF.

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

Referenced by add_dns_result(), add_services(), block_create2(), client_disconnect_cb(), decode_and_send(), decode_and_send(), delete_old_block(), extract_abs_time(), extract_blind_sign_priv(), extract_blind_sign_pub(), extract_blinded_sig(), extract_bool(), extract_filename(), extract_fixed_blob(), extract_int64(), extract_rel_time(), extract_rsa_public_key(), extract_rsa_signature(), extract_string(), extract_timestamp(), extract_uint16(), extract_uint32(), extract_uint64(), extract_unblinded_sig(), extract_varsize_blob(), file_hash_finish(), file_hash_task(), get_nick_record(), get_server_addresses(), get_server_addresses(), get_url_parameter_copy(), GNUNET_buffer_reap(), GNUNET_buffer_reap_str(), GNUNET_buffer_write_vfstr(), GNUNET_CONFIGURATION_get_data(), GNUNET_CONTAINER_bloomfilter_load(), GNUNET_CONTAINER_bloomfilter_test(), GNUNET_CRYPTO_ecc_dlog(), GNUNET_CRYPTO_ecdsa_sign_derived(), GNUNET_CRYPTO_eddsa_sign_(), GNUNET_CRYPTO_eddsa_sign_raw(), GNUNET_CRYPTO_eddsa_verify_(), GNUNET_CRYPTO_edx25519_verify_(), GNUNET_CRYPTO_hash_context_finish(), GNUNET_DISK_directory_create_for_file(), GNUNET_GNSRECORD_block_calculate_size(), GNUNET_GNSRECORD_block_create(), GNUNET_GNSRECORD_block_decrypt(), GNUNET_GNSRECORD_block_sign(), GNUNET_GNSRECORD_block_verify(), GNUNET_hton_double(), GNUNET_NT_scanner_get_type(), GNUNET_ntoh_double(), GNUNET_PQ_exec_prepared(), GNUNET_PQ_query_param_absolute_time(), GNUNET_PQ_query_param_blind_sign_priv(), GNUNET_PQ_query_param_blind_sign_pub(), GNUNET_PQ_query_param_blinded_sig(), GNUNET_PQ_query_param_fixed_size(), GNUNET_PQ_query_param_int16(), GNUNET_PQ_query_param_int64(), GNUNET_PQ_query_param_null(), GNUNET_PQ_query_param_relative_time(), GNUNET_PQ_query_param_rsa_public_key(), GNUNET_PQ_query_param_rsa_signature(), GNUNET_PQ_query_param_uint16(), GNUNET_PQ_query_param_uint32(), GNUNET_PQ_query_param_uint64(), GNUNET_PQ_query_param_unblinded_sig(), GNUNET_PQ_reconnect(), GNUNET_PQ_result_spec_absolute_time(), GNUNET_PQ_result_spec_absolute_time_nbo(), GNUNET_PQ_result_spec_array_abs_time(), GNUNET_PQ_result_spec_array_bool(), GNUNET_PQ_result_spec_array_fixed_size(), GNUNET_PQ_result_spec_array_rel_time(), GNUNET_PQ_result_spec_array_string(), GNUNET_PQ_result_spec_array_timestamp(), GNUNET_PQ_result_spec_array_uint16(), GNUNET_PQ_result_spec_array_uint32(), GNUNET_PQ_result_spec_array_uint64(), GNUNET_PQ_result_spec_array_variable_size(), GNUNET_PQ_result_spec_blind_sign_priv(), GNUNET_PQ_result_spec_blind_sign_pub(), GNUNET_PQ_result_spec_blinded_sig(), GNUNET_PQ_result_spec_bool(), GNUNET_PQ_result_spec_fixed_size(), GNUNET_PQ_result_spec_int64(), GNUNET_PQ_result_spec_relative_time(), GNUNET_PQ_result_spec_rsa_public_key(), GNUNET_PQ_result_spec_rsa_signature(), GNUNET_PQ_result_spec_string(), GNUNET_PQ_result_spec_timestamp(), GNUNET_PQ_result_spec_timestamp_nbo(), GNUNET_PQ_result_spec_uint16(), GNUNET_PQ_result_spec_uint32(), GNUNET_PQ_result_spec_uint64(), GNUNET_PQ_result_spec_unblinded_sig(), GNUNET_PQ_result_spec_variable_size(), GNUNET_SECRETSHARING_plaintext_generate_i(), GNUNET_STRINGS_string_to_data_alloc(), GNUNET_xstrdup_(), GNUNET_xstrndup_(), handle_arm_result(), handle_auto_result(), handle_block_cache(), handle_block_cache_response(), handle_edit_record_set(), handle_edit_record_set_cancel(), handle_generic_response(), handle_gns_redirect_result(), handle_monitor_notify(), handle_query_message(), handle_record_lookup(), handle_record_store(), handle_success_response(), handle_zone_to_name_response(), hash_for_index_cb(), hash_for_index_val(), list_count(), lookup_nick_it(), main(), namecache_postgres_cache_block(), namecache_postgres_expire_blocks(), namecache_postgres_lookup_block(), namestore_postgres_clear_editor_hint(), namestore_postgres_edit_records(), namestore_postgres_iterate_records(), namestore_postgres_lookup_records(), namestore_postgres_store_records(), namestore_postgres_zone_to_name(), open_static_resource(), pabc_get_issuer(), parse(), parse_result_call_iterator(), parse_rsa_signature(), postgres_plugin_del(), postgres_plugin_get(), postgres_plugin_get_closest(), postgres_plugin_get_key(), postgres_plugin_get_replication(), postgres_plugin_get_zero_anonymity(), pq_notice_receiver_cb(), prepare_check_patch(), prepare_get_oid_by_name(), process_peer_string(), process_result(), query_param_array_generic(), REGEX_BLOCK_check(), return_agpl(), return_agpl(), route_control_message_without_fc(), run(), run(), send_client_reply(), send_lookup_response_with_filter(), send_remaining_elements(), send_remaining_elements(), sign_cb(), store_record_set(), try_old_ax_keys(), and verify_fair().

published_sets

unsigned int published_sets = 0

static

Statistics, how many published record sets.

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

Referenced by parse().

published_records

unsigned int published_records = 0

static

Statistics, how many records published in aggregate.

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

Referenced by parse().

current_zone

struct Zone* current_zone

static

Private key for the our zone.

Definition at line 272 of file gnunet-namestore-zonefile.c.

Referenced by ensure_ego_and_continue(), origin_create_cb(), and parse().

ns_qe

struct GNUNET_NAMESTORE_QueueEntry* ns_qe

static

Queue entry for the 'add' operation.

Definition at line 277 of file gnunet-namestore-zonefile.c.

Referenced by add_continuation(), and do_shutdown().

ns

struct GNUNET_NAMESTORE_Handle* ns

static

Handle to the namestore.

Definition at line 282 of file gnunet-namestore-zonefile.c.

Referenced by do_shutdown(), process_queue(), and run().

id_op

struct GNUNET_IDENTITY_Operation* id_op

static

Origin create operations.

Definition at line 287 of file gnunet-namestore-zonefile.c.

Referenced by do_shutdown(), ensure_ego_and_continue(), and origin_create_cb().

id

struct GNUNET_IDENTITY_Handle* id

static

Handle to IDENTITY.

Definition at line 292 of file gnunet-namestore-zonefile.c.

Referenced by add_file(), close_service_room(), cred_iter_cb(), delete_attribute_cont(), delete_credential_cont(), do_read(), find_member_session_in_room(), get_handle_member_session(), GNUNET_CADET_get_path(), GNUNET_MQ_assoc_add(), GNUNET_PEER_change_rc(), GNUNET_PEER_decrement_rcs(), GNUNET_PEER_resolve(), GNUNET_PEER_resolve2(), GSF_plan_add_(), GSF_plan_notify_peer_disconnect_(), handle_arm_list_result(), handle_arm_result(), handle_ego_delete(), handle_ego_rename(), handle_identity_update(), handle_identity_update(), handle_member_id(), handle_search_result(), iter_cb(), load_member(), load_state(), mq_send_impl(), notify_srv_handle_message(), path_info_iterator(), process_attrs(), process_message_control(), process_sblock(), run(), run(), score_content(), send_srv_handle_message(), showcomp(), showlevel(), showpeer(), and write_cb().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Current configurataion.

Definition at line 297 of file gnunet-namestore-zonefile.c.

Referenced by run().

t

struct GNUNET_SCHEDULER_Task* t

static

Main task.

Definition at line 302 of file gnunet-namestore-zonefile.c.

Referenced by add_continuation(), add_without_sets(), automaton_create_proofs(), automaton_destroy_state(), automaton_merge_states(), automaton_state_traverse(), block_create_ecdsa(), block_create_eddsa(), check_dht_p2p_hello(), compute_scalar_product(), connection_ready_cb(), consider_path_cb(), construct_task_graph(), destroy_t_connection(), destroy_task(), destroy_tunnel(), destroy_tunnels_now(), dfa_add_multi_strides_helper(), dfa_compress_paths(), dfa_compress_paths_helper(), dfa_move(), dfa_remove_dead_states(), do_send(), do_shutdown(), driver_add_multiple(), dump_backtrace(), ensure_ego_and_continue(), extract_abs_time(), extract_abs_time_nbo(), extract_timestamp_nbo(), find_peer_context(), GCCH_channel_incoming_new(), GCP_drop_tunnel(), GCT_2s(), GCT_add_channel(), GCT_add_inbound_connection(), GCT_change_estate(), GCT_connection_lost(), GCT_consider_path(), GCT_count_any_connections(), GCT_count_channels(), GCT_create_tunnel(), GCT_debug(), GCT_destroy_tunnel_now(), GCT_get_destination(), GCT_get_estate(), GCT_handle_encrypted(), GCT_handle_kx(), GCT_handle_kx_auth(), GCT_iterate_channels(), GCT_iterate_connections(), GCT_remove_channel(), GCT_send(), GCT_send_cancel(), GCT_send_channel_destroy(), GDS_u_connect(), GDS_u_disconnect(), GDS_u_receive(), get_all_tunnels_iterator(), get_next_free_ctn(), get_ready_connection(), GNUNET_CRYPTO_hash_xorcmp(), GNUNET_DISK_file_seek(), GNUNET_DISK_mkdtemp(), GNUNET_DISK_mktemp(), GNUNET_FS_meta_data_add_publication_date(), GNUNET_JSON_pack_timestamp(), GNUNET_JSON_spec_timestamp(), GNUNET_log_setup(), GNUNET_SCHEDULER_add_at_with_priority(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_add_with_reason_and_priority(), GNUNET_SERVICE_client_drop(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_STRINGS_fancy_time_to_absolute(), GNUNET_STRINGS_timestamp_to_string(), GNUNET_TIME_absolute2s(), GNUNET_TIME_absolute_approx_eq(), GNUNET_TIME_get_current_year(), GNUNET_TIME_randomized_backoff(), GNUNET_TIME_time_to_year(), GNUNET_TIME_timestamp_hton(), GNUNET_TIME_timestamp_ntoh(), GNUNET_TIME_year_to_time(), GNUNET_TRANSPORT_TESTING_done(), GNUNET_TRANSPORT_TESTING_get_test_plugin_name(), handle_connection_create(), handle_decrypted(), handle_dht_p2p_get(), handle_dht_p2p_hello(), handle_dht_p2p_put(), handle_dht_p2p_result(), handle_p2p_estimate(), handle_plaintext_channel_destroy(), handle_plaintext_channel_open(), handle_plaintext_channel_open_ack(), handle_plaintext_data(), handle_plaintext_data_ack(), handle_plaintext_keepalive(), helper_read(), helper_write(), identity_cb(), init_backtrace(), init_fd_info(), iterate_initial_edge(), lookup_channel(), maintain_connections_cb(), mark_connection_unready(), mktemp_name(), origin_create_cb(), parse(), parse_definitions(), parse_pattern(), process_queue(), progress_cb(), put_task(), REGEX_INTERNAL_dfa_add_multi_strides(), restore_fair(), retry_kx(), rsa_gcd_validate(), scc_tarjan_strongconnect(), send_create(), send_done_cb(), send_kx(), send_kx_auth(), set_timestamp(), shutdown_if_no_lifeness(), state_add_transition(), state_get_edges(), trigger_transmissions(), try_send_normal_payload(), and vec_for().

pending

unsigned int pending

static

The number of DNS queries that are outstanding.

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

Referenced by GNUNET_NETWORK_socket_recvfrom_amount(), and process_queue().

pending_rs

unsigned int pending_rs

static

The number of NAMESTORE record store operations that are outstanding.

Definition at line 312 of file gnunet-namestore-zonefile.c.

Referenced by process_queue().

state

int state

static

The current state of the parser.

Definition at line 318 of file gnunet-namestore-zonefile.c.

Referenced by add_continuation(), check_icmp_remote(), check_icmp_service(), check_tcp_data(), check_tcp_remote(), check_tcp_service(), check_udp_remote(), check_udp_service(), cleanup_s5r(), clear_message_state(), deserialize_unindex_file(), ensure_ego_and_continue(), GCT_change_estate(), get_message_state_chain_hash(), get_message_state_merge_hash(), get_redirect_state(), handle_icmp_remote(), handle_icmp_service(), handle_tcp_data(), handle_tcp_remote(), handle_tcp_service(), handle_udp_remote(), handle_udp_service(), icmp_from_helper(), identity_cb(), init_message_state(), intersection_accept(), intersection_evaluate(), iterate_initial_edge(), iterate_reachables(), load_message_state(), make_up_icmp_service_payload(), make_up_icmpv4_payload(), make_up_icmpv6_payload(), mark_as_reachable(), monitor_cb(), origin_create_cb(), parse(), parse_definitions(), print_info(), print_plugin_event_info(), process_peer_iteration_cb(), process_peer_monitoring_cb(), reachability_iterator(), resolve_peer_address(), run(), save_message_state(), setup_state_record(), state_remove_transition(), state_set_append(), tcp_from_helper(), udp_from_helper(), union_accept(), union_copy_state(), union_evaluate(), and update_message_state().

sleep_time_reg_proc

struct GNUNET_TIME_Absolute sleep_time_reg_proc

static

Last time we worked before going idle.

Definition at line 323 of file gnunet-namestore-zonefile.c.

Referenced by parse(), and process_queue().