gnunet-zoneimport.c File Reference

import a DNS zone for publication in GNS, incremental More...

#include "platform.h"
#include <gnunet_util_lib.h>
#include <gnunet_gnsrecord_lib.h>
#include <gnunet_namestore_service.h>
#include <gnunet_statistics_service.h>
#include <gnunet_identity_service.h>

Include dependency graph for gnunet-zoneimport.c:

Go to the source code of this file.

Data Structures
struct	Zone
	Some zones may include authoritative records for other zones, such as foo.com.uk or bar.com.fr. More...
struct	Record
	Record for the request to be stored by GNS. More...
struct	Request
	Request we should make. More...
struct	GlueClosure
	Closure for check_for_glue. More...
struct	ProcessRecordContext
	Closure for process_record(). More...

Macros
#define	THRESH   100
	Maximum number of queries pending at the same time. More...
#define	TIME_THRESH   10
	TIME_THRESH is in usecs. More...
#define	MAX_RETRIES   5
	How often do we retry a query before giving up for good? More...
#define	MAX_SERIES   10
	How many DNS requests do we at most issue in rapid series? More...
#define	SERIES_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 10)
	How long do we wait at least between series of requests? More...
#define	NS_BATCH_SIZE   1024
	How many requests do we request from NAMESTORE in one batch during our initial iteration? More...

Typedefs
typedef void(*	RecordProcessor) (void *cls, const struct GNUNET_DNSPARSER_Record *rec)
	Callback for for_all_records. More...

Functions
static void	for_all_records (const struct GNUNET_DNSPARSER_Packet *p, RecordProcessor rp, void *rp_cls)
	Call rp for each record in p, regardless of what response section it is in. More...
static const char *	get_label (struct Request *req)
	Return just the label of the hostname in req. More...
static void *	build_dns_query (struct Request *req, size_t *raw_size)
	Build DNS query for hostname. More...
static void	free_records (struct Request *req)
	Free records associated with req. More...
static void	free_request (struct Request *req)
	Free req and data structures reachable from it. More...
static void	process_queue (void *cls)
	Process as many requests as possible from the queue. More...
static void	insert_sorted (struct Request *req)
	Insert req into DLL sorted by next fetch time. More...
static void	add_record (struct Request *req, uint32_t type, struct GNUNET_TIME_Absolute expiration_time, const void *data, size_t data_len)
	Add record to the GNS record set for req. More...
static void	check_for_glue (void *cls, const struct GNUNET_DNSPARSER_Record *rec)
	Try to find glue records for a given NS record. More...
static void	process_record (void *cls, const struct GNUNET_DNSPARSER_Record *rec)
	We received rec for req. More...
static void	store_completed_cb (void *cls, enum GNUNET_ErrorCode ec)
static void	process_result (void *cls, const struct GNUNET_TUN_DnsHeader *dns, size_t dns_len)
	Function called with the result of a DNS resolution. More...
static int	free_request_it (void *cls, const struct GNUNET_HashCode *key, void *value)
	Iterator called during do_shutdown() to free requests in the ns_pending map. More...
static void	do_shutdown (void *cls)
	Clean up and terminate the process. More...
static void	iterate_zones (void *cls)
	Iterate over all of the zones we care about and see which records we may need to re-fetch when. More...
static void	ns_lookup_error_cb (void *cls)
	Function called if GNUNET_NAMESTORE_records_lookup() failed. More...
static void	ns_lookup_result_cb (void *cls, const struct GNUNET_IDENTITY_PrivateKey *key, const char *label, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Process a record that was stored in the namestore. More...
static void	queue (const char *hostname)
	Add hostname to the list of requests to be made. More...
static int	move_to_queue (void *cls, const struct GNUNET_HashCode *key, void *value)
	We have completed the initial iteration over the namestore's database. More...
static void	process_stdin (void *cls)
	Begin processing hostnames from stdin. More...
static void	identity_cb (void *cls, struct GNUNET_IDENTITY_Ego *ego, void **ctx, const char *name)
	Method called to inform about the egos of this peer. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
	Process requests from the queue, then if the queue is not empty, try again. More...
int	main (int argc, char *const *argv)
	Call with IP address of resolver to query. More...

Variables
static struct GNUNET_TIME_Relative	minimum_expiration_time
	How long do DNS records have to last at least after being imported? More...
static unsigned int	map_size = 1024
	Command-line argument specifying desired size of the hash map with all of our pending names. More...
static struct GNUNET_IDENTITY_Handle *	id
	Handle to the identity service. More...
static struct GNUNET_NAMESTORE_Handle *	ns
	Namestore handle. More...
static struct GNUNET_STATISTICS_Handle *	stats
	Handle to the statistics service. More...
static struct GNUNET_DNSSTUB_Context *	ctx
	Context for DNS resolution. More...
static unsigned int	pending
	The number of DNS queries that are outstanding. More...
static unsigned int	pending_rs
	The number of NAMESTORE record store operations that are outstanding. More...
static unsigned int	lookups
	Number of lookups we performed overall. More...
static unsigned int	cached
	Number of records we had cached. More...
static unsigned int	rejects
	How many hostnames did we reject (malformed). More...
static unsigned int	failures
	Number of lookups that failed. More...
static unsigned int	records
	Number of records we found. More...
static unsigned int	record_sets
	Number of record sets given to namestore. More...
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. More...
static struct Request *	req_head
	Active requests are kept in a DLL. More...
static struct Request *	req_tail
	Active requests are kept in a DLL. More...
static struct GNUNET_SCHEDULER_Task *	t
	Main task. More...
static struct GNUNET_CONTAINER_MultiHashMap *	ns_pending
	Hash map of requests for which we may still get a response from the namestore. More...
static struct GNUNET_NAMESTORE_ZoneIterator *	zone_it
	Current zone iteration handle. More...
static struct Zone *	zone_head
	Head of list of zones we are managing. More...
static struct Zone *	zone_tail
	Tail of list of zones we are managing. More...
static uint64_t	ns_iterator_trigger_next
	After how many more results must ns_lookup_result_cb() ask the namestore for more? More...
static uint64_t	total_dns_latency_cnt
	Number of DNS requests counted in latency total. More...
static struct GNUNET_TIME_Relative	total_dns_latency
	Sum of DNS latencies observed. More...
static uint64_t	total_reg_proc_dns
	Number of records processed (DNS lookup, no NAMESTORE) in total. More...
static uint64_t	total_reg_proc_dns_ns
	Number of records processed (DNS lookup, with NAMESTORE) in total. More...
static struct GNUNET_TIME_Absolute	start_time_reg_proc
	Start time of the regular processing. More...
static struct GNUNET_TIME_Absolute	sleep_time_reg_proc
	Last time we worked before going idle. More...
static struct GNUNET_TIME_Relative	idle_time
	Time we slept just waiting for work. More...

Detailed Description

import a DNS zone for publication in GNS, incremental

Author

Christian Grothoff

Definition in file gnunet-zoneimport.c.

Macro Definition Documentation

THRESH

#define THRESH   100

Maximum number of queries pending at the same time.

Definition at line 36 of file gnunet-zoneimport.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 42 of file gnunet-zoneimport.c.

MAX_RETRIES

#define MAX_RETRIES   5

How often do we retry a query before giving up for good?

Definition at line 47 of file gnunet-zoneimport.c.

MAX_SERIES

#define MAX_SERIES   10

How many DNS requests do we at most issue in rapid series?

Definition at line 52 of file gnunet-zoneimport.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 57 of file gnunet-zoneimport.c.

NS_BATCH_SIZE

#define NS_BATCH_SIZE   1024

How many requests do we request from NAMESTORE in one batch during our initial iteration?

Definition at line 69 of file gnunet-zoneimport.c.

Typedef Documentation

RecordProcessor

typedef void(* RecordProcessor) (void *cls, const struct GNUNET_DNSPARSER_Record *rec)

Callback for for_all_records.

Parameters

cls	closure
rec	a DNS record

Definition at line 366 of file gnunet-zoneimport.c.

Function Documentation

for_all_records()

static void for_all_records ( const struct GNUNET_DNSPARSER_Packet *  p, RecordProcessor  rp, void *  rp_cls  )

static

Call rp for each record in p, regardless of what response section it is in.

Parameters

p	packet from DNS
rp	function to call
rp_cls	closure for rp

Definition at line 379 of file gnunet-zoneimport.c.

{
  for (unsigned int i = 0; i < p->num_answers; i++)
  {
    struct GNUNET_DNSPARSER_Record *rs = &p->answers[i];
 
    rp (rp_cls, rs);
  }
  for (unsigned int i = 0; i < p->num_authority_records; i++)
  {
    struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i];
 
    rp (rp_cls, rs);
  }
  for (unsigned int i = 0; i < p->num_additional_records; i++)
  {
    struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i];
 
    rp (rp_cls, rs);
  }
}

References p, and rp.

Referenced by process_record(), and process_result().

Here is the caller graph for this function:

get_label()

static const char* get_label ( struct Request *  req )

static

Return just the label of the hostname in req.

Parameters

req	request to process hostname of

Returns

statically allocated pointer to the label, overwritten upon the next request!

Definition at line 412 of file gnunet-zoneimport.c.

{
  static char label[64];
  const char *dot;
 
  dot = strchr (req->hostname, (unsigned char) '.');
  if (NULL == dot)
  {
    GNUNET_break (0);
    return NULL;
  }
  if (((size_t) (dot - req->hostname)) >= sizeof(label))
  {
    GNUNET_break (0);
    return NULL;
  }
  GNUNET_memcpy (label, req->hostname, dot - req->hostname);
  label[dot - req->hostname] = '\0';
  return label;
}

References GNUNET_break, GNUNET_memcpy, and Request::hostname.

Referenced by ns_lookup_result_cb(), and process_result().

Here is the caller graph for this function:

build_dns_query()

static void* build_dns_query ( struct Request *  req, size_t *  raw_size  )

static

Build DNS query for hostname.

Parameters

	hostname	host to build query for
[out]	raw_size	number of bytes in the query

Returns

NULL on error, otherwise pointer to statically (!) allocated query buffer

Definition at line 443 of file gnunet-zoneimport.c.

{
  static char raw[512];
  char *rawp;
  struct GNUNET_DNSPARSER_Packet p;
  struct GNUNET_DNSPARSER_Query q;
  int ret;
 
  q.name = (char *) req->hostname;
  q.type = GNUNET_DNSPARSER_TYPE_NS;
  q.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
 
  memset (&p, 0, sizeof(p));
  p.num_queries = 1;
  p.queries = &q;
  p.id = req->id;
  ret = GNUNET_DNSPARSER_pack (&p, UINT16_MAX, &rawp, raw_size);
  if (GNUNET_OK != ret)
  {
    if (GNUNET_NO == ret)
      GNUNET_free (rawp);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to pack query for hostname `%s'\n",
                req->hostname);
    rejects++;
    return NULL;
  }
  if (*raw_size > sizeof(raw))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to pack query for hostname `%s'\n",
                req->hostname);
    rejects++;
    GNUNET_break (0);
    GNUNET_free (rawp);
    return NULL;
  }
  GNUNET_memcpy (raw, rawp, *raw_size);
  GNUNET_free (rawp);
  return raw;
}

References GNUNET_break, GNUNET_DNSPARSER_pack(), GNUNET_DNSPARSER_TYPE_NS, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_TUN_DNS_CLASS_INTERNET, Request::hostname, Request::id, p, q, raw, rejects, and ret.

Referenced by process_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

free_records()

static void free_records ( struct Request *  req )

static

Free records associated with req.

Parameters

req	request to free records of

Definition at line 492 of file gnunet-zoneimport.c.

{
  struct Record *rec;
 
  /* Free records */
  while (NULL != (rec = req->rec_head))
  {
    GNUNET_CONTAINER_DLL_remove (req->rec_head, req->rec_tail, rec);
    GNUNET_free (rec);
  }
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_free, Request::rec_head, and Request::rec_tail.

Referenced by free_request(), ns_lookup_result_cb(), and store_completed_cb().

Here is the caller graph for this function:

free_request()

static void free_request ( struct Request *  req )

static

Free req and data structures reachable from it.

Parameters

req	request to free

Definition at line 511 of file gnunet-zoneimport.c.

{
  free_records (req);
  GNUNET_free (req);
}

References free_records(), and GNUNET_free.

Referenced by do_shutdown(), free_request_it(), process_queue(), and process_result().

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 1171 of file gnunet-zoneimport.c.

{
  struct Request *req;
  unsigned int series;
  void *raw;
  size_t raw_size;
  struct GNUNET_TIME_Relative delay;
 
  (void) cls;
  delay = GNUNET_TIME_absolute_get_duration (sleep_time_reg_proc);
  idle_time = GNUNET_TIME_relative_add (idle_time, delay);
  series = 0;
  t = NULL;
  while (pending + pending_rs < THRESH)
  {
    req = GNUNET_CONTAINER_heap_peek (req_heap);
    if (NULL == req)
      break;
    if (NULL != req->qe)
      return;   /* namestore op still pending */
    if (NULL != req->rs)
    {
      GNUNET_break (0);
      return;     /* already submitted */
    }
    if (GNUNET_TIME_absolute_get_remaining (req->expires).rel_value_us > 0)
      break;
    GNUNET_assert (req == GNUNET_CONTAINER_heap_remove_root (req_heap));
    req->hn = NULL;
    GNUNET_CONTAINER_DLL_insert (req_head, req_tail, req);
    GNUNET_assert (NULL == req->rs);
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Requesting resolution for `%s'\n",
                req->hostname);
    raw = build_dns_query (req, &raw_size);
    if (NULL == raw)
    {
      GNUNET_break (0);
      free_request (req);
      continue;
    }
    req->op_start_time = GNUNET_TIME_absolute_get ();
    req->rs = GNUNET_DNSSTUB_resolve (ctx, raw, raw_size, &process_result, req);
    GNUNET_assert (NULL != req->rs);
    req->issue_num++;
    lookups++;
    pending++;
    series++;
    if (series > MAX_SERIES)
      break;
  }
  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 */
  }
  req = GNUNET_CONTAINER_heap_peek (req_heap);
  if (NULL == req)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stopped processing queue: empty queue\n");
    return;
  }
  if (GNUNET_TIME_absolute_get_remaining (req->expires).rel_value_us > 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Waiting until %s for next record (`%s') to expire\n",
                GNUNET_STRINGS_absolute_time_to_string (req->expires),
                req->hostname);
    if (NULL != t)
      GNUNET_SCHEDULER_cancel (t);
    sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
    t = GNUNET_SCHEDULER_add_at (req->expires, &process_queue, NULL);
    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 build_dns_query(), ctx, delay, Request::expires, free_request(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_heap_peek(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_DNSSTUB_resolve(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_add(), Request::hn, Request::hostname, idle_time, Request::issue_num, lookups, MAX_SERIES, Request::op_start_time, pending, pending_rs, process_result(), Request::qe, raw, GNUNET_TIME_Relative::rel_value_us, req_head, req_heap, req_tail, Request::rs, SERIES_DELAY, sleep_time_reg_proc, t, and THRESH.

Referenced by insert_sorted(), process_result(), and store_completed_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

insert_sorted()

static void insert_sorted ( struct Request *  req )

static

Insert req into DLL sorted by next fetch time.

Parameters

req	request to insert into req_heap

Definition at line 533 of file gnunet-zoneimport.c.

{
  req->hn =
    GNUNET_CONTAINER_heap_insert (req_heap, req, req->expires.abs_value_us);
  if (req == GNUNET_CONTAINER_heap_peek (req_heap))
  {
    if (NULL != t)
      GNUNET_SCHEDULER_cancel (t);
    sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
    t = GNUNET_SCHEDULER_add_at (req->expires, &process_queue, NULL);
  }
}

References GNUNET_TIME_Absolute::abs_value_us, Request::expires, GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_peek(), GNUNET_SCHEDULER_add_at(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_absolute_get(), Request::hn, process_queue(), req_heap, sleep_time_reg_proc, and t.

Referenced by move_to_queue(), ns_lookup_result_cb(), and process_result().

Here is the call graph for this function:

Here is the caller graph for this function:

add_record()

static void add_record ( struct Request *  req, uint32_t  type, struct GNUNET_TIME_Absolute  expiration_time, const void *  data, size_t  data_len  )

static

Add record to the GNS record set for req.

Parameters

req	the request to expand GNS record set for
type	type to use
expiration_time	when should rec expire
data	raw data to store
data_len	number of bytes in data

Definition at line 557 of file gnunet-zoneimport.c.

{
  struct Record *rec;
 
  rec = GNUNET_malloc (sizeof(struct Record) + data_len);
  rec->grd.data = &rec[1];
  rec->grd.expiration_time = expiration_time.abs_value_us;
  rec->grd.data_size = data_len;
  rec->grd.record_type = type;
  rec->grd.flags = GNUNET_GNSRECORD_RF_NONE;
  GNUNET_memcpy (&rec[1], data, data_len);
  GNUNET_CONTAINER_DLL_insert (req->rec_head, req->rec_tail, rec);
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_GNSRECORD_Data::data, data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNUNET_CONTAINER_DLL_insert, GNUNET_GNSRECORD_RF_NONE, GNUNET_malloc, GNUNET_memcpy, Record::grd, Request::rec_head, Request::rec_tail, GNUNET_GNSRECORD_Data::record_type, and type.

Referenced by check_for_glue(), ns_lookup_result_cb(), and process_record().

Here is the caller graph for this function:

check_for_glue()

static void check_for_glue ( void *  cls, const struct GNUNET_DNSPARSER_Record *  rec  )

static

Try to find glue records for a given NS record.

Parameters

cls	a struct GlueClosure *
rec	record that may contain glue information

Definition at line 605 of file gnunet-zoneimport.c.

{
  struct GlueClosure *gc = cls;
  char dst[65536];
  size_t dst_len;
  size_t off;
  char ip[INET6_ADDRSTRLEN + 1];
  socklen_t ip_size = (socklen_t) sizeof(ip);
  struct GNUNET_TIME_Absolute expiration_time;
  struct GNUNET_TIME_Relative left;
 
  if (0 != strcasecmp (rec->name, gc->ns))
    return;
  expiration_time = rec->expiration_time;
  left = GNUNET_TIME_absolute_get_remaining (expiration_time);
  if (0 == left.rel_value_us)
    return; /* ignore expired glue records */
  /* if expiration window is too short, bump it to configured minimum */
  if (left.rel_value_us < minimum_expiration_time.rel_value_us)
    expiration_time =
      GNUNET_TIME_relative_to_absolute (minimum_expiration_time);
  dst_len = sizeof(dst);
  off = 0;
  switch (rec->type)
  {
  case GNUNET_DNSPARSER_TYPE_A:
    if (sizeof(struct in_addr) != rec->data.raw.data_len)
    {
      GNUNET_break (0);
      return;
    }
    if (NULL == inet_ntop (AF_INET, rec->data.raw.data, ip, ip_size))
    {
      GNUNET_break (0);
      return;
    }
    if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                         dst_len,
                                                         &off,
                                                         gc->req->hostname)) &&
        (GNUNET_OK ==
         GNUNET_DNSPARSER_builder_add_name (dst, dst_len, &off, ip)))
    {
      add_record (gc->req,
                  GNUNET_GNSRECORD_TYPE_GNS2DNS,
                  expiration_time,
                  dst,
                  off);
      gc->found = GNUNET_YES;
    }
    break;
 
  case GNUNET_DNSPARSER_TYPE_AAAA:
    if (sizeof(struct in6_addr) != rec->data.raw.data_len)
    {
      GNUNET_break (0);
      return;
    }
    if (NULL == inet_ntop (AF_INET6, rec->data.raw.data, ip, ip_size))
    {
      GNUNET_break (0);
      return;
    }
    if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                         dst_len,
                                                         &off,
                                                         gc->req->hostname)) &&
        (GNUNET_OK ==
         GNUNET_DNSPARSER_builder_add_name (dst, dst_len, &off, ip)))
    {
      add_record (gc->req,
                  GNUNET_GNSRECORD_TYPE_GNS2DNS,
                  expiration_time,
                  dst,
                  off);
      gc->found = GNUNET_YES;
    }
    break;
 
  case GNUNET_DNSPARSER_TYPE_CNAME:
    if ((GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                         dst_len,
                                                         &off,
                                                         gc->req->hostname)) &&
        (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                         dst_len,
                                                         &off,
                                                         rec->data.hostname)))
    {
      add_record (gc->req,
                  GNUNET_GNSRECORD_TYPE_GNS2DNS,
                  expiration_time,
                  dst,
                  off);
      gc->found = GNUNET_YES;
    }
    break;
 
  default:
    /* useless, do nothing */
    break;
  }
}

References add_record(), GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, GNUNET_DNSPARSER_RawRecord::data_len, GNUNET_DNSPARSER_Record::expiration_time, GlueClosure::found, GNUNET_break, GNUNET_DNSPARSER_builder_add_name(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_GNSRECORD_TYPE_GNS2DNS, GNUNET_OK, GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, Request::hostname, GNUNET_DNSPARSER_Record::hostname, minimum_expiration_time, GNUNET_DNSPARSER_Record::name, GlueClosure::ns, GNUNET_DNSPARSER_Record::raw, GNUNET_TIME_Relative::rel_value_us, GlueClosure::req, and GNUNET_DNSPARSER_Record::type.

Referenced by process_record().

Here is the call graph for this function:

Here is the caller graph for this function:

process_record()

static void process_record ( void *  cls, const struct GNUNET_DNSPARSER_Record *  rec  )

static

We received rec for req.

Remember the answer.

Parameters

cls	a struct ProcessRecordContext
rec	response

Definition at line 735 of file gnunet-zoneimport.c.

{
  struct ProcessRecordContext *prc = cls;
  struct Request *req = prc->req;
  char dst[65536];
  size_t dst_len;
  size_t off;
  struct GNUNET_TIME_Absolute expiration_time;
  struct GNUNET_TIME_Relative left;
 
  dst_len = sizeof(dst);
  off = 0;
  records++;
  if (0 != strcasecmp (rec->name, req->hostname))
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_DEBUG,
      "DNS returned record from zone `%s' of type %u while resolving `%s'\n",
      rec->name,
      (unsigned int) rec->type,
      req->hostname);
    return;   /* does not match hostname, might be glue, but
                 not useful for this pass! */
  }
  expiration_time = rec->expiration_time;
  left = GNUNET_TIME_absolute_get_remaining (expiration_time);
  if (0 == left.rel_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "DNS returned expired record for `%s'\n",
                req->hostname);
    GNUNET_STATISTICS_update (stats,
                              "# expired records obtained from DNS",
                              1,
                              GNUNET_NO);
    return;   /* record expired */
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "DNS returned record that expires at %s for `%s'\n",
              GNUNET_STRINGS_absolute_time_to_string (expiration_time),
              req->hostname);
  /* if expiration window is too short, bump it to configured minimum */
  if (left.rel_value_us < minimum_expiration_time.rel_value_us)
    expiration_time =
      GNUNET_TIME_relative_to_absolute (minimum_expiration_time);
  switch (rec->type)
  {
  case GNUNET_DNSPARSER_TYPE_NS: {
      struct GlueClosure gc;
 
      /* check for glue */
      gc.req = req;
      gc.ns = rec->data.hostname;
      gc.found = GNUNET_NO;
      for_all_records (prc->p, &check_for_glue, &gc);
      if ((GNUNET_NO == gc.found) &&
          (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                           dst_len,
                                                           &off,
                                                           req->hostname)) &&
          (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                           dst_len,
                                                           &off,
                                                           rec->data.hostname)))
      {
        /* FIXME: actually check if this is out-of-bailiwick,
             and if not request explicit resolution... */
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Converted OOB (`%s') NS record for `%s'\n",
                    rec->data.hostname,
                    rec->name);
        add_record (req,
                    GNUNET_GNSRECORD_TYPE_GNS2DNS,
                    expiration_time,
                    dst,
                    off);
      }
      else
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Converted NS record for `%s' using glue\n",
                    rec->name);
      }
      break;
    }
 
  case GNUNET_DNSPARSER_TYPE_CNAME:
    if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                        dst_len,
                                                        &off,
                                                        rec->data.hostname))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Converting CNAME (`%s') record for `%s'\n",
                  rec->data.hostname,
                  rec->name);
      add_record (req, rec->type, expiration_time, dst, off);
    }
    break;
 
  case GNUNET_DNSPARSER_TYPE_DNAME:
    /* No support for DNAME in GNS yet! FIXME: support later! */
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "FIXME: not supported: %s DNAME %s\n",
                rec->name,
                rec->data.hostname);
    break;
 
  case GNUNET_DNSPARSER_TYPE_MX:
    if (GNUNET_OK ==
        GNUNET_DNSPARSER_builder_add_mx (dst, dst_len, &off, rec->data.mx))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Converting MX (`%s') record for `%s'\n",
                  rec->data.mx->mxhost,
                  rec->name);
      add_record (req, rec->type, expiration_time, dst, off);
    }
    break;
 
  case GNUNET_DNSPARSER_TYPE_SOA:
    if (GNUNET_OK ==
        GNUNET_DNSPARSER_builder_add_soa (dst, dst_len, &off, rec->data.soa))
    {
      /* NOTE: GNS does not really use SOAs */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Converting SOA record for `%s'\n",
                  rec->name);
      add_record (req, rec->type, expiration_time, dst, off);
    }
    break;
 
  case GNUNET_DNSPARSER_TYPE_SRV:
    if (GNUNET_OK ==
        GNUNET_DNSPARSER_builder_add_srv (dst, dst_len, &off, rec->data.srv))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Converting SRV record for `%s'\n",
                  rec->name);
      add_record (req, rec->type, expiration_time, dst, off);
    }
    break;
 
  case GNUNET_DNSPARSER_TYPE_PTR:
    if (GNUNET_OK == GNUNET_DNSPARSER_builder_add_name (dst,
                                                        dst_len,
                                                        &off,
                                                        rec->data.hostname))
    {
      /* !?: what does a PTR record do in a regular TLD??? */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Converting PTR record for `%s' (weird)\n",
                  rec->name);
      add_record (req, rec->type, expiration_time, dst, off);
    }
    break;
 
  case GNUNET_DNSPARSER_TYPE_CERT:
    if (GNUNET_OK ==
        GNUNET_DNSPARSER_builder_add_cert (dst, dst_len, &off, rec->data.cert))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Converting CERT record for `%s'\n",
                  rec->name);
      add_record (req, rec->type, expiration_time, dst, off);
    }
    break;
 
  /* Rest is 'raw' encoded and just needs to be copied IF
     the hostname matches the requested name; otherwise we
     simply cannot use it. */
  case GNUNET_DNSPARSER_TYPE_A:
  case GNUNET_DNSPARSER_TYPE_AAAA:
  case GNUNET_DNSPARSER_TYPE_TXT:
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Converting record of type %u for `%s'\n",
                (unsigned int) rec->type,
                rec->name);
    add_record (req,
                rec->type,
                expiration_time,
                rec->data.raw.data,
                rec->data.raw.data_len);
    break;
  }
}

References add_record(), GNUNET_DNSPARSER_Record::cert, check_for_glue(), GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, GNUNET_DNSPARSER_RawRecord::data_len, GNUNET_DNSPARSER_Record::expiration_time, for_all_records(), GlueClosure::found, GNUNET_DNSPARSER_builder_add_cert(), GNUNET_DNSPARSER_builder_add_mx(), GNUNET_DNSPARSER_builder_add_name(), GNUNET_DNSPARSER_builder_add_soa(), GNUNET_DNSPARSER_builder_add_srv(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_CERT, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_DNSPARSER_TYPE_DNAME, GNUNET_DNSPARSER_TYPE_MX, GNUNET_DNSPARSER_TYPE_NS, GNUNET_DNSPARSER_TYPE_PTR, GNUNET_DNSPARSER_TYPE_SOA, GNUNET_DNSPARSER_TYPE_SRV, GNUNET_DNSPARSER_TYPE_TXT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_GNSRECORD_TYPE_GNS2DNS, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_relative_to_absolute(), Request::hostname, GNUNET_DNSPARSER_Record::hostname, minimum_expiration_time, GNUNET_DNSPARSER_Record::mx, GNUNET_DNSPARSER_MxRecord::mxhost, GNUNET_DNSPARSER_Record::name, GlueClosure::ns, ProcessRecordContext::p, GNUNET_DNSPARSER_Record::raw, records, GNUNET_TIME_Relative::rel_value_us, GlueClosure::req, ProcessRecordContext::req, GNUNET_DNSPARSER_Record::soa, GNUNET_DNSPARSER_Record::srv, stats, and GNUNET_DNSPARSER_Record::type.

Referenced by process_result().

Here is the call graph for this function:

Here is the caller graph for this function:

store_completed_cb()

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

static

Definition at line 926 of file gnunet-zoneimport.c.

{
  static struct GNUNET_TIME_Absolute last;
  struct Request *req = cls;
 
  req->qe = NULL;
  if (GNUNET_EC_NONE != ec)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to store zone data for `%s': %s\n",
                req->hostname,
                GNUNET_ErrorCode_get_hint (ec));
  }
  else
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Stored records under `%s' (%d)\n",
                req->hostname,
                ec);
  }
  total_reg_proc_dns_ns++; /* finished regular processing */
  pending_rs--;
  free_records (req);
  /* compute NAMESTORE statistics */
  {
    static uint64_t total_ns_latency_cnt;
    static struct GNUNET_TIME_Relative total_ns_latency;
    struct GNUNET_TIME_Relative ns_latency;
 
    ns_latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
    total_ns_latency = GNUNET_TIME_relative_add (total_ns_latency, ns_latency);
    if (0 == total_ns_latency_cnt)
      last = GNUNET_TIME_absolute_get ();
    total_ns_latency_cnt++;
    if (0 == (total_ns_latency_cnt % 1000))
    {
      struct GNUNET_TIME_Relative delta;
 
      delta = GNUNET_TIME_absolute_get_duration (last);
      last = GNUNET_TIME_absolute_get ();
      fprintf (stderr,
               "Processed 1000 records in %s\n",
               GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
      GNUNET_STATISTICS_set (stats,
                             "# average NAMESTORE PUT latency (μs)",
                             total_ns_latency.rel_value_us
                             / total_ns_latency_cnt,
                             GNUNET_NO);
    }
  }
  /* compute and publish overall velocity */
  if (0 == (total_reg_proc_dns_ns % 100))
  {
    struct GNUNET_TIME_Relative runtime;
 
    runtime = GNUNET_TIME_absolute_get_duration (start_time_reg_proc);
    runtime = GNUNET_TIME_relative_subtract (runtime, idle_time);
    runtime =
      GNUNET_TIME_relative_divide (runtime,
                                   total_reg_proc_dns + total_reg_proc_dns_ns);
    GNUNET_STATISTICS_set (stats,
                           "# Regular processing completed without NAMESTORE",
                           total_reg_proc_dns,
                           GNUNET_NO);
    GNUNET_STATISTICS_set (stats,
                           "# Regular processing completed with NAMESTORE PUT",
                           total_reg_proc_dns_ns,
                           GNUNET_NO);
    GNUNET_STATISTICS_set (stats,
                           "# average request processing latency (μs)",
                           runtime.rel_value_us,
                           GNUNET_NO);
    GNUNET_STATISTICS_set (stats,
                           "# total time spent idle (μs)",
                           idle_time.rel_value_us,
                           GNUNET_NO);
  }
 
  if (NULL == t)
  {
    sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
    t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
  }
}

References delta, free_records(), GNUNET_EC_NONE, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ErrorCode_get_hint(), GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_divide(), GNUNET_TIME_relative_subtract(), GNUNET_YES, Request::hostname, idle_time, Request::op_start_time, pending_rs, process_queue(), Request::qe, GNUNET_TIME_Relative::rel_value_us, sleep_time_reg_proc, start_time_reg_proc, stats, t, total_reg_proc_dns, and total_reg_proc_dns_ns.

Referenced by process_result().

Here is the call graph for this function:

Here is the caller graph for this function:

process_result()

static void process_result ( void *  cls, const struct GNUNET_TUN_DnsHeader *  dns, size_t  dns_len  )

static

Function called with the result of a DNS resolution.

Parameters

cls	closure with the struct Request
dns	dns response, never NULL
dns_len	number of bytes in dns

Definition at line 1020 of file gnunet-zoneimport.c.

{
  struct Request *req = cls;
  struct Record *rec;
  struct GNUNET_DNSPARSER_Packet *p;
  unsigned int rd_count;
 
  GNUNET_assert (NULL == req->hn);
  if (NULL == dns)
  {
    /* stub gave up */
    GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req);
    pending--;
    if (NULL == t)
    {
      sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
      t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
    }
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Stub gave up on DNS reply for `%s'\n",
                req->hostname);
    GNUNET_STATISTICS_update (stats, "# DNS lookups timed out", 1, GNUNET_NO);
    if (req->issue_num > MAX_RETRIES)
    {
      failures++;
      free_request (req);
      GNUNET_STATISTICS_update (stats, "# requests given up on", 1, GNUNET_NO);
      return;
    }
    total_reg_proc_dns++;
    req->rs = NULL;
    insert_sorted (req);
    return;
  }
  if (req->id != dns->id)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "DNS ID did not match request, ignoring reply\n");
    GNUNET_STATISTICS_update (stats, "# DNS ID mismatches", 1, GNUNET_NO);
    return;
  }
  GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req);
  GNUNET_DNSSTUB_resolve_cancel (req->rs);
  req->rs = NULL;
  pending--;
  p = GNUNET_DNSPARSER_parse ((const char *) dns, dns_len);
  if (NULL == p)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to parse DNS reply for `%s'\n",
                req->hostname);
    GNUNET_STATISTICS_update (stats, "# DNS parser errors", 1, GNUNET_NO);
    if (NULL == t)
    {
      sleep_time_reg_proc = GNUNET_TIME_absolute_get ();
      t = GNUNET_SCHEDULER_add_now (&process_queue, NULL);
    }
    if (req->issue_num > MAX_RETRIES)
    {
      failures++;
      free_request (req);
      GNUNET_STATISTICS_update (stats, "# requests given up on", 1, GNUNET_NO);
      return;
    }
    insert_sorted (req);
    return;
  }
  /* import new records */
  req->issue_num = 0; /* success, reset counter! */
  {
    struct ProcessRecordContext prc = { .req = req, .p = p };
 
    for_all_records (p, &process_record, &prc);
  }
  GNUNET_DNSPARSER_free_packet (p);
  /* count records found, determine minimum expiration time */
  req->expires = GNUNET_TIME_UNIT_FOREVER_ABS;
  {
    struct GNUNET_TIME_Relative dns_latency;
 
    dns_latency = GNUNET_TIME_absolute_get_duration (req->op_start_time);
    total_dns_latency =
      GNUNET_TIME_relative_add (total_dns_latency, dns_latency);
    total_dns_latency_cnt++;
    if (0 == (total_dns_latency_cnt % 1000))
    {
      GNUNET_STATISTICS_set (stats,
                             "# average DNS lookup latency (μs)",
                             total_dns_latency.rel_value_us
                             / total_dns_latency_cnt,
                             GNUNET_NO);
    }
  }
  rd_count = 0;
  for (rec = req->rec_head; NULL != rec; rec = rec->next)
  {
    struct GNUNET_TIME_Absolute at;
 
    at.abs_value_us = rec->grd.expiration_time;
    req->expires = GNUNET_TIME_absolute_min (req->expires, at);
    rd_count++;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Obtained %u records for `%s'\n",
              rd_count,
              req->hostname);
  /* Instead of going for SOA, simplified for now to look each
     day in case we got an empty response */
  if (0 == rd_count)
  {
    req->expires = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_DAYS);
    GNUNET_STATISTICS_update (stats,
                              "# empty DNS replies (usually NXDOMAIN)",
                              1,
                              GNUNET_NO);
  }
  else
  {
    record_sets++;
  }
  /* convert records to namestore import format */
  {
    struct GNUNET_GNSRECORD_Data rd[GNUNET_NZL (rd_count)];
    unsigned int off = 0;
 
    /* convert linked list into array */
    for (rec = req->rec_head; NULL != rec; rec = rec->next)
      rd[off++] = rec->grd;
    pending_rs++;
    req->op_start_time = GNUNET_TIME_absolute_get ();
    req->qe = GNUNET_NAMESTORE_records_store (ns,
                                              &req->zone->key,
                                              get_label (req),
                                              rd_count,
                                              rd,
                                              &store_completed_cb,
                                              req);
    GNUNET_assert (NULL != req->qe);
  }
  insert_sorted (req);
}

References GNUNET_TIME_Absolute::abs_value_us, GNUNET_GNSRECORD_Data::expiration_time, Request::expires, failures, for_all_records(), free_request(), get_label(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_parse(), GNUNET_DNSSTUB_resolve_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NAMESTORE_records_store(), GNUNET_NO, GNUNET_NZL, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_absolute_min(), GNUNET_TIME_relative_add(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_DAYS, GNUNET_TIME_UNIT_FOREVER_ABS, Record::grd, Request::hn, Request::hostname, Request::id, GNUNET_TUN_DnsHeader::id, insert_sorted(), Request::issue_num, Zone::key, MAX_RETRIES, Record::next, ns, Request::op_start_time, p, pending, pending_rs, process_queue(), process_record(), Request::qe, rd, rd_count, Request::rec_head, record_sets, GNUNET_TIME_Relative::rel_value_us, ProcessRecordContext::req, req_head, req_tail, Request::rs, sleep_time_reg_proc, stats, store_completed_cb(), t, total_dns_latency, total_dns_latency_cnt, total_reg_proc_dns, and Request::zone.

Referenced by process_queue().

Here is the call graph for this function:

Here is the caller graph for this function:

free_request_it()

static int free_request_it ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

Iterator called during do_shutdown() to free requests in the ns_pending map.

Parameters

cls	NULL
key	unused
value	the struct Request to free

Returns

GNUNET_OK

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

{
  struct Request *req = value;
 
  (void) cls;
  (void) key;
  free_request (req);
  return GNUNET_OK;
}

References free_request(), GNUNET_OK, key, and value.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Clean up and terminate the process.

Parameters

cls

NULL

Definition at line 1285 of file gnunet-zoneimport.c.

{
  struct Request *req;
  struct Zone *zone;
 
  (void) cls;
  if (NULL != id)
  {
    GNUNET_IDENTITY_disconnect (id);
    id = NULL;
  }
  if (NULL != t)
  {
    GNUNET_SCHEDULER_cancel (t);
    t = NULL;
  }
  while (NULL != (req = req_head))
  {
    GNUNET_CONTAINER_DLL_remove (req_head, req_tail, req);
    if (NULL != req->qe)
      GNUNET_NAMESTORE_cancel (req->qe);
    free_request (req);
  }
  while (NULL != (req = GNUNET_CONTAINER_heap_remove_root (req_heap)))
  {
    req->hn = NULL;
    if (NULL != req->qe)
      GNUNET_NAMESTORE_cancel (req->qe);
    free_request (req);
  }
  if (NULL != zone_it)
  {
    GNUNET_NAMESTORE_zone_iteration_stop (zone_it);
    zone_it = NULL;
  }
  if (NULL != ns)
  {
    GNUNET_NAMESTORE_disconnect (ns);
    ns = NULL;
  }
  if (NULL != ctx)
  {
    GNUNET_DNSSTUB_stop (ctx);
    ctx = NULL;
  }
  if (NULL != req_heap)
  {
    GNUNET_CONTAINER_heap_destroy (req_heap);
    req_heap = NULL;
  }
  if (NULL != ns_pending)
  {
    GNUNET_CONTAINER_multihashmap_iterate (ns_pending, &free_request_it, NULL);
    GNUNET_CONTAINER_multihashmap_destroy (ns_pending);
    ns_pending = NULL;
  }
  while (NULL != (zone = zone_head))
  {
    GNUNET_CONTAINER_DLL_remove (zone_head, zone_tail, zone);
    GNUNET_free (zone->domain);
    GNUNET_free (zone);
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
    stats = NULL;
  }
}

References ctx, free_request(), free_request_it(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_destroy(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_DNSSTUB_stop(), GNUNET_free, GNUNET_IDENTITY_disconnect(), GNUNET_NAMESTORE_cancel(), GNUNET_NAMESTORE_disconnect(), GNUNET_NAMESTORE_zone_iteration_stop(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), Request::hn, ns, ns_pending, Request::qe, req_head, req_heap, req_tail, stats, t, zone, zone_head, zone_it, and zone_tail.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_zones()

static void iterate_zones ( void *  cls )

static

Iterate over all of the zones we care about and see which records we may need to re-fetch when.

Parameters

cls

NULL

Definition at line 1585 of file gnunet-zoneimport.c.

{
  static struct Zone *last;
 
  (void) cls;
  if (NULL != zone_it)
  {
    zone_it = NULL;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Finished iteration over zone `%s'!\n",
                last->domain);
    /* subtract left-overs from previous iteration */
    GNUNET_STATISTICS_update (stats,
                              "# NAMESTORE records requested from cache",
                              (long long) (-ns_iterator_trigger_next),
                              GNUNET_NO);
    ns_iterator_trigger_next = 0;
  }
  GNUNET_assert (NULL != zone_tail);
  if (zone_tail == last)
  {
    /* Done iterating over relevant zones in NAMESTORE, move
       rest of hash map to work queue as well. */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Finished all NAMESTORE iterations!\n");
    GNUNET_STATISTICS_set (stats,
                           "# Domain names without cached reply",
                           GNUNET_CONTAINER_multihashmap_size (ns_pending),
                           GNUNET_NO);
    GNUNET_CONTAINER_multihashmap_iterate (ns_pending, &move_to_queue, NULL);
    GNUNET_CONTAINER_multihashmap_destroy (ns_pending);
    ns_pending = NULL;
    start_time_reg_proc = GNUNET_TIME_absolute_get ();
    total_reg_proc_dns = 0;
    total_reg_proc_dns_ns = 0;
    return;
  }
  if (NULL == last)
    last = zone_head;
  else
    last = last->next;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting iteration over zone `%s'!\n",
              last->domain);
  /* subtract left-overs from previous iteration */
  GNUNET_STATISTICS_update (stats,
                            "# NAMESTORE records requested from cache",
                            1,
                            GNUNET_NO);
  ns_iterator_trigger_next = 1;
  GNUNET_STATISTICS_update (stats, "# zones iterated", 1, GNUNET_NO);
  zone_it = GNUNET_NAMESTORE_zone_iteration_start (ns,
                                                   &last->key,
                                                   &ns_lookup_error_cb,
                                                   NULL,
                                                   &ns_lookup_result_cb,
                                                   last,
                                                   &iterate_zones,
                                                   NULL);
}

References Zone::domain, GNUNET_assert, GNUNET_CONTAINER_multihashmap_destroy(), GNUNET_CONTAINER_multihashmap_iterate(), GNUNET_CONTAINER_multihashmap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NAMESTORE_zone_iteration_start(), GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get(), Zone::key, move_to_queue(), Zone::next, ns, ns_iterator_trigger_next, ns_lookup_error_cb(), ns_lookup_result_cb(), ns_pending, start_time_reg_proc, stats, total_reg_proc_dns, total_reg_proc_dns_ns, zone_head, zone_it, and zone_tail.

Referenced by ns_lookup_error_cb(), and process_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

ns_lookup_error_cb()

static void ns_lookup_error_cb ( void *  cls )

static

Function called if GNUNET_NAMESTORE_records_lookup() failed.

Just logs an error.

Parameters

cls	a struct Zone

Definition at line 1372 of file gnunet-zoneimport.c.

{
  struct Zone *zone = cls;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Failed to load data from namestore for zone `%s'\n",
              zone->domain);
  zone_it = NULL;
  ns_iterator_trigger_next = 0;
  iterate_zones (NULL);
}

References GNUNET_ERROR_TYPE_INFO, GNUNET_log, iterate_zones(), ns_iterator_trigger_next, zone, and zone_it.

Referenced by iterate_zones().

Here is the call graph for this function:

Here is the caller graph for this function:

ns_lookup_result_cb()

static void ns_lookup_result_cb ( void *  cls, const struct GNUNET_IDENTITY_PrivateKey *  key, const char *  label, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Process a record that was stored in the namestore.

Parameters

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

Definition at line 1395 of file gnunet-zoneimport.c.

{
  struct Zone *zone = cls;
  struct Request *req;
  struct GNUNET_HashCode hc;
  char *fqdn;
 
  ns_iterator_trigger_next--;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Obtained NAMESTORE reply, %llu left in round\n",
              (unsigned long long) ns_iterator_trigger_next);
  if (0 == ns_iterator_trigger_next)
  {
    ns_iterator_trigger_next = NS_BATCH_SIZE;
    GNUNET_STATISTICS_update (stats,
                              "# NAMESTORE records requested from cache",
                              ns_iterator_trigger_next,
                              GNUNET_NO);
    GNUNET_NAMESTORE_zone_iterator_next (zone_it, ns_iterator_trigger_next);
  }
  GNUNET_asprintf (&fqdn, "%s.%s", label, zone->domain);
  GNUNET_CRYPTO_hash (fqdn, strlen (fqdn) + 1, &hc);
  GNUNET_free (fqdn);
  req = GNUNET_CONTAINER_multihashmap_get (ns_pending, &hc);
  if (NULL == req)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Ignoring record `%s' in zone `%s': not on my list!\n",
                label,
                zone->domain);
    return;
  }
  GNUNET_assert (GNUNET_OK ==
                 GNUNET_CONTAINER_multihashmap_remove (ns_pending, &hc, req));
  GNUNET_break (0 == GNUNET_memcmp (key, &req->zone->key));
  GNUNET_break (0 == strcasecmp (label, get_label (req)));
  for (unsigned int i = 0; i < rd_count; i++)
  {
    struct GNUNET_TIME_Absolute at;
 
    if (0 != (rd->flags & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION))
    {
      struct GNUNET_TIME_Relative rel;
 
      rel.rel_value_us = rd->expiration_time;
      at = GNUNET_TIME_relative_to_absolute (rel);
    }
    else
    {
      at.abs_value_us = rd->expiration_time;
    }
    add_record (req, rd->record_type, at, rd->data, rd->data_size);
  }
  if (0 == rd_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Empty record set in namestore for `%s'\n",
                req->hostname);
  }
  else
  {
    unsigned int pos = 0;
 
    cached++;
    req->expires = GNUNET_TIME_UNIT_FOREVER_ABS;
    for (struct Record *rec = req->rec_head; NULL != rec; rec = rec->next)
    {
      struct GNUNET_TIME_Absolute at;
 
      at.abs_value_us = rec->grd.expiration_time;
      req->expires = GNUNET_TIME_absolute_min (req->expires, at);
      pos++;
    }
    if (0 == pos)
      req->expires = GNUNET_TIME_UNIT_ZERO_ABS;
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Hot-start with %u existing records for `%s'\n",
                pos,
                req->hostname);
  }
  free_records (req);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Adding `%s' to worklist to start at %s\n",
              req->hostname,
              GNUNET_STRINGS_absolute_time_to_string (req->expires));
  insert_sorted (req);
}

References GNUNET_TIME_Absolute::abs_value_us, add_record(), cached, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, Request::expires, GNUNET_GNSRECORD_Data::flags, free_records(), get_label(), GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_multihashmap_get(), GNUNET_CONTAINER_multihashmap_remove(), GNUNET_CRYPTO_hash(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_log, GNUNET_memcmp, GNUNET_NAMESTORE_zone_iterator_next(), GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_min(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_ZERO_ABS, Request::hostname, insert_sorted(), key, Zone::key, Record::next, NS_BATCH_SIZE, ns_iterator_trigger_next, ns_pending, rd, rd_count, Request::rec_head, GNUNET_GNSRECORD_Data::record_type, GNUNET_TIME_Relative::rel_value_us, stats, zone, Request::zone, and zone_it.

Referenced by iterate_zones().

Here is the call graph for this function:

Here is the caller graph for this function:

queue()

static void queue ( const char *  hostname )

static

Add hostname to the list of requests to be made.

Parameters

hostname

name to resolve

Definition at line 1495 of file gnunet-zoneimport.c.

{
  struct Request *req;
  const char *dot;
  struct Zone *zone;
  size_t hlen;
  struct GNUNET_HashCode hc;
 
  if (GNUNET_OK != GNUNET_DNSPARSER_check_name (hostname))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Refusing invalid hostname `%s'\n",
                hostname);
    rejects++;
    return;
  }
  dot = strchr (hostname, (unsigned char) '.');
  if (NULL == dot)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Refusing invalid hostname `%s' (lacks '.')\n",
                hostname);
    rejects++;
    return;
  }
  for (zone = zone_head; NULL != zone; zone = zone->next)
    if (0 == strcmp (zone->domain, dot + 1))
      break;
  if (NULL == zone)
  {
    rejects++;
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Domain name `%s' not in ego list!\n",
                dot + 1);
    return;
  }
 
  hlen = strlen (hostname) + 1;
  req = GNUNET_malloc (sizeof(struct Request) + hlen);
  req->zone = zone;
  req->hostname = (char *) &req[1];
  GNUNET_memcpy (req->hostname, hostname, hlen);
  req->id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                                 UINT16_MAX);
  GNUNET_CRYPTO_hash (req->hostname, hlen, &hc);
  if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (
        ns_pending,
        &hc,
        req,
        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Duplicate hostname `%s' ignored\n",
                hostname);
    GNUNET_free (req);
    return;
  }
}

References GNUNET_CONTAINER_multihashmap_put(), GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_DNSPARSER_check_name(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, Request::hostname, hostname, Request::id, ns_pending, rejects, zone, Request::zone, and zone_head.

Referenced by process_stdin().

Here is the call graph for this function:

Here is the caller graph for this function:

move_to_queue()

static int move_to_queue ( void *  cls, const struct GNUNET_HashCode *  key, void *  value  )

static

We have completed the initial iteration over the namestore's database.

This function is called on each of the remaining records in move_to_queue to queue() them, as we will simply not find existing records for them any longer.

Parameters

cls	NULL
key	unused
value	a struct Request

Returns

GNUNET_OK (continue to iterate)

Definition at line 1567 of file gnunet-zoneimport.c.

{
  struct Request *req = value;
 
  (void) cls;
  (void) key;
  insert_sorted (req);
  return GNUNET_OK;
}

References GNUNET_OK, insert_sorted(), key, and value.

Referenced by iterate_zones().

Here is the call graph for this function:

Here is the caller graph for this function:

process_stdin()

static void process_stdin ( void *  cls )

static

Begin processing hostnames from stdin.

Parameters

cls

NULL

Definition at line 1653 of file gnunet-zoneimport.c.

{
  static struct GNUNET_TIME_Absolute last;
  static uint64_t idot;
  char hn[256];
 
  (void) cls;
  t = NULL;
  if (NULL != id)
  {
    GNUNET_IDENTITY_disconnect (id);
    id = NULL;
  }
  while (NULL != fgets (hn, sizeof(hn), stdin))
  {
    if (strlen (hn) > 0)
      hn[strlen (hn) - 1] = '\0';  /* eat newline */
    if (0 == idot)
      last = GNUNET_TIME_absolute_get ();
    idot++;
    if (0 == idot % 100000)
    {
      struct GNUNET_TIME_Relative delta;
 
      delta = GNUNET_TIME_absolute_get_duration (last);
      last = GNUNET_TIME_absolute_get ();
      fprintf (stderr,
               "Read 100000 domain names in %s\n",
               GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_YES));
      GNUNET_STATISTICS_set (stats, "# domain names provided", idot, GNUNET_NO);
    }
    queue (hn);
  }
  fprintf (stderr,
           "Done reading %llu domain names\n",
           (unsigned long long) idot);
  GNUNET_STATISTICS_set (stats, "# domain names provided", idot, GNUNET_NO);
  iterate_zones (NULL);
}

References delta, GNUNET_IDENTITY_disconnect(), GNUNET_NO, GNUNET_STATISTICS_set(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_absolute_get_duration(), GNUNET_YES, iterate_zones(), queue(), stats, and t.

Referenced by identity_cb().

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, void **  ctx, const char *  name  )

static

Method called to inform about the egos of this peer.

When used with GNUNET_IDENTITY_connect, this function is initially called for all egos and then again whenever a ego's name changes or if it is deleted. At the end of the initial pass over all egos, the function is once called with 'NULL' for ego. That does NOT mean that the callback won't be invoked in the future or that there was an error.

When used with GNUNET_IDENTITY_create or GNUNET_IDENTITY_get, this function is only called ONCE, and 'NULL' being passed in ego does indicate an error (for example because name is taken or no default value is known). If ego is non-NULL and if '*ctx' is set in those callbacks, the value WILL be passed to a subsequent call to the identity callback of GNUNET_IDENTITY_connect (if that one was not NULL).

When an identity is renamed, this function is called with the (known) ego but the NEW name.

When an identity is deleted, this function is called with the (known) ego and "NULL" for the name. In this case, the ego is henceforth invalid (and the ctx should also be cleaned up).

Parameters

cls	closure
ego	ego handle, NULL for end of list
ctx	context for application to store data for this ego (during the lifetime of this process, initially NULL)
name	name assigned by the user for this ego, NULL if the user just deleted the ego and it must thus no longer be used

Definition at line 1728 of file gnunet-zoneimport.c.

{
  (void) cls;
  (void) ctx;
 
  if (NULL == ego)
  {
    /* end of iteration */
    if (NULL == zone_head)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "No zone found\n");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    /* zone_head non-null, process hostnames from stdin */
    t = GNUNET_SCHEDULER_add_now (&process_stdin, 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);
  }
}

References ctx, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_IDENTITY_ego_get_private_key(), GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_shutdown(), GNUNET_strdup, name, process_stdin(), t, zone, zone_head, and zone_tail.

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

Process requests from the queue, then if the queue is not empty, try again.

Parameters

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

Definition at line 1771 of file gnunet-zoneimport.c.

{
  (void) cls;
  (void) args;
  (void) cfgfile;
  stats = GNUNET_STATISTICS_create ("zoneimport", cfg);
  req_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  ns_pending = GNUNET_CONTAINER_multihashmap_create (map_size, GNUNET_NO);
  if (NULL == ns_pending)
  {
    fprintf (stderr, "Failed to allocate memory for main hash map\n");
    return;
  }
  ctx = GNUNET_DNSSTUB_start (256);
  if (NULL == ctx)
  {
    fprintf (stderr, "Failed to initialize GNUnet DNS STUB\n");
    return;
  }
  if (NULL == args[0])
  {
    fprintf (stderr,
             "You must provide a list of DNS resolvers on the command line\n");
    return;
  }
  for (unsigned int i = 0; NULL != args[i]; i++)
  {
    if (GNUNET_OK != GNUNET_DNSSTUB_add_dns_ip (ctx, args[i]))
    {
      fprintf (stderr, "Failed to use `%s' for DNS resolver\n", args[i]);
      return;
    }
  }
 
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown, NULL);
  ns = GNUNET_NAMESTORE_connect (cfg);
  if (NULL == ns)
  {
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  id = GNUNET_IDENTITY_connect (cfg, &identity_cb, NULL);
}

References consensus-simulation::args, cfg, ctx, do_shutdown(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_CONTAINER_multihashmap_create(), GNUNET_DNSSTUB_add_dns_ip(), GNUNET_DNSSTUB_start(), GNUNET_IDENTITY_connect(), GNUNET_NAMESTORE_connect(), GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), identity_cb(), map_size, ns, ns_pending, req_heap, and stats.

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
	)

Call with IP address of resolver to query.

Parameters

argc	should be 2
argv[1]	should contain IP address

Returns

0 on success

Definition at line 1828 of file gnunet-zoneimport.c.

{
  struct GNUNET_GETOPT_CommandLineOption options[] =
  { GNUNET_GETOPT_option_uint ('s',
                               "size",
                               "MAPSIZE",
                               gettext_noop (
                                 "size to use for the main hash map"),
                               &map_size),
    GNUNET_GETOPT_option_relative_time (
      'm',
      "minimum-expiration",
      "RELATIVETIME",
      gettext_noop ("minimum expiration time we assume for imported records"),
      &minimum_expiration_time),
    GNUNET_GETOPT_OPTION_END };
  int ret;
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc, argv, &argc, &argv))
    return 2;
  if (GNUNET_OK != (ret = GNUNET_PROGRAM_run (argc,
                                              argv,
                                              "gnunet-zoneimport",
                                              "import DNS zone into namestore",
                                              options,
                                              &run,
                                              NULL)))
    return ret;
  GNUNET_free_nz ((void *) argv);
  fprintf (stderr,
           "Rejected %u names, had %u cached, did %u lookups, stored %u record sets\n"
           "Found %u records, %u lookups failed, %u/%u pending on shutdown\n",
           rejects,
           cached,
           lookups,
           record_sets,
           records,
           failures,
           pending,
           pending_rs);
  return 0;
}

References cached, failures, gettext_noop, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_GETOPT_option_relative_time(), GNUNET_GETOPT_option_uint(), GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), lookups, map_size, minimum_expiration_time, options, pending, pending_rs, record_sets, records, rejects, ret, and run().

Here is the call graph for this function:

Variable Documentation

minimum_expiration_time

struct GNUNET_TIME_Relative minimum_expiration_time

static

How long do DNS records have to last at least after being imported?

Definition at line 1 of file gnunet-zoneimport.c.

Referenced by check_for_glue(), main(), and process_record().

map_size

unsigned int map_size = 1024

static

Command-line argument specifying desired size of the hash map with all of our pending names.

Usually, we use an automatically growing map, but this is only OK up to about a million entries. Above that number, the user must explicitly specify the size at startup.

Definition at line 213 of file gnunet-zoneimport.c.

Referenced by main(), and run().

id

struct GNUNET_IDENTITY_Handle* id

static

Handle to the identity service.

Definition at line 218 of file gnunet-zoneimport.c.

ns

struct GNUNET_NAMESTORE_Handle* ns

static

Namestore handle.

Definition at line 223 of file gnunet-zoneimport.c.

Referenced by do_shutdown(), iterate_zones(), process_result(), and run().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Handle to the statistics service.

Definition at line 228 of file gnunet-zoneimport.c.

Referenced by do_shutdown(), iterate_zones(), ns_lookup_result_cb(), process_record(), process_result(), process_stdin(), run(), and store_completed_cb().

ctx

struct GNUNET_DNSSTUB_Context* ctx

static

Context for DNS resolution.

Definition at line 233 of file gnunet-zoneimport.c.

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

pending

unsigned int pending

static

The number of DNS queries that are outstanding.

Definition at line 238 of file gnunet-zoneimport.c.

Referenced by main(), process_queue(), and process_result().

pending_rs

unsigned int pending_rs

static

The number of NAMESTORE record store operations that are outstanding.

Definition at line 243 of file gnunet-zoneimport.c.

Referenced by main(), process_queue(), process_result(), and store_completed_cb().

lookups

unsigned int lookups

static

Number of lookups we performed overall.

Definition at line 248 of file gnunet-zoneimport.c.

Referenced by main(), and process_queue().

cached

unsigned int cached

static

Number of records we had cached.

Definition at line 253 of file gnunet-zoneimport.c.

Referenced by main(), and ns_lookup_result_cb().

rejects

unsigned int rejects

static

How many hostnames did we reject (malformed).

Definition at line 258 of file gnunet-zoneimport.c.

Referenced by build_dns_query(), main(), and queue().

failures

unsigned int failures

static

Number of lookups that failed.

Definition at line 263 of file gnunet-zoneimport.c.

Referenced by main(), and process_result().

records

unsigned int records

static

Number of records we found.

Definition at line 268 of file gnunet-zoneimport.c.

Referenced by main(), and process_record().

record_sets

unsigned int record_sets

static

Number of record sets given to namestore.

Definition at line 273 of file gnunet-zoneimport.c.

Referenced by main(), and process_result().

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 279 of file gnunet-zoneimport.c.

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

req_head

struct Request* req_head

static

Active requests are kept in a DLL.

Definition at line 284 of file gnunet-zoneimport.c.

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

req_tail

struct Request* req_tail

static

Active requests are kept in a DLL.

Definition at line 289 of file gnunet-zoneimport.c.

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

t

struct GNUNET_SCHEDULER_Task* t

static

Main task.

Definition at line 294 of file gnunet-zoneimport.c.

Referenced by do_shutdown(), identity_cb(), insert_sorted(), process_queue(), process_result(), process_stdin(), and store_completed_cb().

ns_pending

struct GNUNET_CONTAINER_MultiHashMap* ns_pending

static

Hash map of requests for which we may still get a response from the namestore.

Set to NULL once the initial namestore iteration is done.

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

Referenced by do_shutdown(), iterate_zones(), ns_lookup_result_cb(), queue(), and run().

zone_it

struct GNUNET_NAMESTORE_ZoneIterator* zone_it

static

Current zone iteration handle.

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

Referenced by do_shutdown(), iterate_zones(), ns_lookup_error_cb(), and ns_lookup_result_cb().

zone_head

struct Zone* zone_head

static

Head of list of zones we are managing.

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

Referenced by do_shutdown(), identity_cb(), iterate_zones(), and queue().

zone_tail

struct Zone* zone_tail

static

Tail of list of zones we are managing.

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

Referenced by do_shutdown(), identity_cb(), and iterate_zones().

ns_iterator_trigger_next

uint64_t ns_iterator_trigger_next

static

After how many more results must ns_lookup_result_cb() ask the namestore for more?

Definition at line 322 of file gnunet-zoneimport.c.

Referenced by iterate_zones(), ns_lookup_error_cb(), and ns_lookup_result_cb().

total_dns_latency_cnt

uint64_t total_dns_latency_cnt

static

Number of DNS requests counted in latency total.

Definition at line 327 of file gnunet-zoneimport.c.

Referenced by process_result().

total_dns_latency

struct GNUNET_TIME_Relative total_dns_latency

static

Sum of DNS latencies observed.

Definition at line 327 of file gnunet-zoneimport.c.

Referenced by process_result().

total_reg_proc_dns

uint64_t total_reg_proc_dns

static

Number of records processed (DNS lookup, no NAMESTORE) in total.

Definition at line 337 of file gnunet-zoneimport.c.

Referenced by iterate_zones(), process_result(), and store_completed_cb().

total_reg_proc_dns_ns

uint64_t total_reg_proc_dns_ns

static

Number of records processed (DNS lookup, with NAMESTORE) in total.

Definition at line 342 of file gnunet-zoneimport.c.

Referenced by iterate_zones(), and store_completed_cb().

start_time_reg_proc

struct GNUNET_TIME_Absolute start_time_reg_proc

static

Start time of the regular processing.

Definition at line 342 of file gnunet-zoneimport.c.

Referenced by iterate_zones(), and store_completed_cb().

sleep_time_reg_proc

struct GNUNET_TIME_Absolute sleep_time_reg_proc

static

Last time we worked before going idle.

Definition at line 342 of file gnunet-zoneimport.c.

Referenced by insert_sorted(), process_queue(), process_result(), and store_completed_cb().

idle_time

struct GNUNET_TIME_Relative idle_time

static

Time we slept just waiting for work.

Definition at line 342 of file gnunet-zoneimport.c.

Referenced by process_queue(), and store_completed_cb().