gnunet-zonewalk.c File Reference

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

Include dependency graph for gnunet-zonewalk.c:

Go to the source code of this file.

Data Structures
struct	Request
	Request we should make. More...

Macros
#define	THRESH   20
	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...

Functions
static void	process_record (struct Request *req, struct GNUNET_DNSPARSER_Record *rec)
	We received rec for req. More...
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	submit_req (struct Request *req)
	Submit a request to DNS unless we need to slow down because we are at the rate limit. More...
static void	process_queue (void *cls)
	Process as many requests as possible from the queue. More...
static void	do_shutdown (void *cls)
	Clean up and terminate the process. More...
static void	run (void *cls)
	Process requests from the queue, then if the queue is not empty, try again. More...
static void	queue (const char *hostname)
	Add hostname to the list of requests to be made. More...
int	main (int argc, char **argv)
	Call with IP address of resolver to query. More...

Variables
static struct GNUNET_DNSSTUB_Context *	ctx
	Context for DNS resolution. More...
static unsigned int	pending
	The number of queries that are outstanding. More...
static unsigned int	lookups
	Number of lookups we performed overall. More...
static unsigned int	failures
	Number of lookups that failed. More...
static unsigned int	records
	Number of records we found. More...
static struct Request *	req_head
	Head of DLL of all requests to perform. More...
static struct Request *	req_tail
	Tail of DLL of all requests to perform. More...
static struct GNUNET_SCHEDULER_Task *	t
	Main task. More...

Macro Definition Documentation

THRESH

#define THRESH   20

Maximum number of queries pending at the same time.

Definition at line 124 of file gnunet-zonewalk.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 130 of file gnunet-zonewalk.c.

MAX_RETRIES

#define MAX_RETRIES   5

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

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

Function Documentation

process_record()

static void process_record ( struct Request *  req, struct GNUNET_DNSPARSER_Record *  rec  )

static

We received rec for req.

Remember the answer.

Parameters

req	request
rec	response

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

{
  char buf[INET6_ADDRSTRLEN];
 
  records++;
  switch (rec->type)
  {
  case GNUNET_DNSPARSER_TYPE_A:
    fprintf (stdout,
             "%s A %s\n",
             req->hostname,
             inet_ntop (AF_INET,
                        rec->data.raw.data,
                        buf,
                        sizeof(buf)));
    break;
 
  case GNUNET_DNSPARSER_TYPE_AAAA:
    fprintf (stdout,
             "%s AAAA %s\n",
             req->hostname,
             inet_ntop (AF_INET6,
                        rec->data.raw.data,
                        buf,
                        sizeof(buf)));
    break;
 
  case GNUNET_DNSPARSER_TYPE_NS:
    fprintf (stdout,
             "%s NS %s\n",
             req->hostname,
             rec->data.hostname);
    break;
 
  case GNUNET_DNSPARSER_TYPE_CNAME:
    fprintf (stdout,
             "%s CNAME %s\n",
             req->hostname,
             rec->data.hostname);
    break;
 
  case GNUNET_DNSPARSER_TYPE_MX:
    fprintf (stdout,
             "%s MX %u %s\n",
             req->hostname,
             (unsigned int) rec->data.mx->preference,
             rec->data.mx->mxhost);
    break;
 
  case GNUNET_DNSPARSER_TYPE_SOA:
    fprintf (stdout,
             "%s SOA %s %s %u %u %u %u %u\n",
             req->hostname,
             rec->data.soa->mname,
             rec->data.soa->rname,
             (unsigned int) rec->data.soa->serial,
             (unsigned int) rec->data.soa->refresh,
             (unsigned int) rec->data.soa->retry,
             (unsigned int) rec->data.soa->expire,
             (unsigned int) rec->data.soa->minimum_ttl);
    break;
 
  case GNUNET_DNSPARSER_TYPE_SRV:
    fprintf (stdout,
             "%s SRV %s %u %u %u\n",
             req->hostname,
             rec->data.srv->target,
             rec->data.srv->priority,
             rec->data.srv->weight,
             rec->data.srv->port);
    break;
  
  case GNUNET_DNSPARSER_TYPE_URI:
    fprintf (stdout,
             "%s URI \"%s\" %u %u\n",
             req->hostname,
             rec->data.uri->target,
             rec->data.uri->priority,
             rec->data.uri->weight);
    break;
 
  case GNUNET_DNSPARSER_TYPE_PTR:
    fprintf (stdout,
             "%s PTR %s\n",
             req->hostname,
             rec->data.hostname);
    break;
 
  case GNUNET_DNSPARSER_TYPE_TXT:
    fprintf (stdout,
             "%s TXT %.*s\n",
             req->hostname,
             (int) rec->data.raw.data_len,
             (char *) rec->data.raw.data);
    break;
 
  case GNUNET_DNSPARSER_TYPE_DNAME:
    fprintf (stdout,
             "%s DNAME %s\n",
             req->hostname,
             rec->data.hostname);
    break;
 
  /* obscure records */
  case GNUNET_DNSPARSER_TYPE_AFSDB:
  case GNUNET_DNSPARSER_TYPE_NAPTR:
  case GNUNET_DNSPARSER_TYPE_APL:
  case GNUNET_DNSPARSER_TYPE_DHCID:
  case GNUNET_DNSPARSER_TYPE_HIP:
  case GNUNET_DNSPARSER_TYPE_LOC:
  case GNUNET_DNSPARSER_TYPE_RP:
  case GNUNET_DNSPARSER_TYPE_TKEY:
  case GNUNET_DNSPARSER_TYPE_TSIG:
  case GNUNET_DNSPARSER_TYPE_TA:
 
  /* DNSSEC */
  case GNUNET_DNSPARSER_TYPE_DS:
  case GNUNET_DNSPARSER_TYPE_RRSIG:
  case GNUNET_DNSPARSER_TYPE_NSEC:
  case GNUNET_DNSPARSER_TYPE_DNSKEY:
  case GNUNET_DNSPARSER_TYPE_NSEC3:
  case GNUNET_DNSPARSER_TYPE_NSEC3PARAM:
  case GNUNET_DNSPARSER_TYPE_CDS:
  case GNUNET_DNSPARSER_TYPE_CDNSKEY:
 
  /* DNSSEC payload */
  case GNUNET_DNSPARSER_TYPE_CERT:
  case GNUNET_DNSPARSER_TYPE_SSHFP:
  case GNUNET_DNSPARSER_TYPE_IPSECKEY:
  case GNUNET_DNSPARSER_TYPE_TLSA:
  case GNUNET_DNSPARSER_TYPE_SMIMEA:
  case GNUNET_DNSPARSER_TYPE_OPENPGPKEY:
 
  /* obsolete records */
  case GNUNET_DNSPARSER_TYPE_SIG:
  case GNUNET_DNSPARSER_TYPE_KEY:
  case GNUNET_DNSPARSER_TYPE_KX:
    {
      char *base32;
 
      base32 = GNUNET_STRINGS_data_to_string_alloc (rec->data.raw.data,
                                                    rec->data.raw.data_len);
      fprintf (stdout,
               "%s (%u) %s\n",
               req->hostname,
               rec->type,
               base32);
      GNUNET_free (base32);
    }
    break;
 
  default:
    fprintf (stderr,
             "Unsupported type %u\n",
             (unsigned int) rec->type);
    break;
  }
}

References GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, GNUNET_DNSPARSER_RawRecord::data_len, GNUNET_DNSPARSER_SoaRecord::expire, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_AFSDB, GNUNET_DNSPARSER_TYPE_APL, GNUNET_DNSPARSER_TYPE_CDNSKEY, GNUNET_DNSPARSER_TYPE_CDS, GNUNET_DNSPARSER_TYPE_CERT, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_DNSPARSER_TYPE_DHCID, GNUNET_DNSPARSER_TYPE_DNAME, GNUNET_DNSPARSER_TYPE_DNSKEY, GNUNET_DNSPARSER_TYPE_DS, GNUNET_DNSPARSER_TYPE_HIP, GNUNET_DNSPARSER_TYPE_IPSECKEY, GNUNET_DNSPARSER_TYPE_KEY, GNUNET_DNSPARSER_TYPE_KX, GNUNET_DNSPARSER_TYPE_LOC, GNUNET_DNSPARSER_TYPE_MX, GNUNET_DNSPARSER_TYPE_NAPTR, GNUNET_DNSPARSER_TYPE_NS, GNUNET_DNSPARSER_TYPE_NSEC, GNUNET_DNSPARSER_TYPE_NSEC3, GNUNET_DNSPARSER_TYPE_NSEC3PARAM, GNUNET_DNSPARSER_TYPE_OPENPGPKEY, GNUNET_DNSPARSER_TYPE_PTR, GNUNET_DNSPARSER_TYPE_RP, GNUNET_DNSPARSER_TYPE_RRSIG, GNUNET_DNSPARSER_TYPE_SIG, GNUNET_DNSPARSER_TYPE_SMIMEA, GNUNET_DNSPARSER_TYPE_SOA, GNUNET_DNSPARSER_TYPE_SRV, GNUNET_DNSPARSER_TYPE_SSHFP, GNUNET_DNSPARSER_TYPE_TA, GNUNET_DNSPARSER_TYPE_TKEY, GNUNET_DNSPARSER_TYPE_TLSA, GNUNET_DNSPARSER_TYPE_TSIG, GNUNET_DNSPARSER_TYPE_TXT, GNUNET_DNSPARSER_TYPE_URI, GNUNET_free, GNUNET_STRINGS_data_to_string_alloc(), Request::hostname, GNUNET_DNSPARSER_Record::hostname, GNUNET_DNSPARSER_SoaRecord::minimum_ttl, GNUNET_DNSPARSER_SoaRecord::mname, GNUNET_DNSPARSER_Record::mx, GNUNET_DNSPARSER_MxRecord::mxhost, GNUNET_DNSPARSER_SrvRecord::port, GNUNET_DNSPARSER_MxRecord::preference, GNUNET_DNSPARSER_SrvRecord::priority, GNUNET_DNSPARSER_UriRecord::priority, GNUNET_DNSPARSER_Record::raw, records, GNUNET_DNSPARSER_SoaRecord::refresh, GNUNET_DNSPARSER_SoaRecord::retry, GNUNET_DNSPARSER_SoaRecord::rname, GNUNET_DNSPARSER_SoaRecord::serial, GNUNET_DNSPARSER_Record::soa, GNUNET_DNSPARSER_Record::srv, GNUNET_DNSPARSER_SrvRecord::target, GNUNET_DNSPARSER_UriRecord::target, GNUNET_DNSPARSER_Record::type, GNUNET_DNSPARSER_Record::uri, GNUNET_DNSPARSER_SrvRecord::weight, and GNUNET_DNSPARSER_UriRecord::weight.

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 314 of file gnunet-zonewalk.c.

{
  struct Request *req = cls;
  struct GNUNET_DNSPARSER_Packet *p;
 
  if (NULL == dns)
  {
    /* stub gave up */
    pending--;
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Stub gave up on DNS reply for `%s'\n",
                req->hostname);
    GNUNET_CONTAINER_DLL_remove (req_head,
                                 req_tail,
                                 req);
    if (req->issue_num > MAX_RETRIES)
    {
      failures++;
      GNUNET_free (req->hostname);
      GNUNET_free (req->raw);
      GNUNET_free (req);
      return;
    }
    GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                      req_tail,
                                      req);
    req->rs = NULL;
    return;
  }
  if (req->id != dns->id)
    return;
  pending--;
  GNUNET_DNSSTUB_resolve_cancel (req->rs);
  req->rs = NULL;
  GNUNET_CONTAINER_DLL_remove (req_head,
                               req_tail,
                               req);
  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);
    if (req->issue_num > MAX_RETRIES)
    {
      failures++;
      GNUNET_free (req->hostname);
      GNUNET_free (req->raw);
      GNUNET_free (req);
      return;
    }
    GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                      req_tail,
                                      req);
    return;
  }
  for (unsigned int i = 0; i < p->num_answers; i++)
  {
    struct GNUNET_DNSPARSER_Record *rs = &p->answers[i];
 
    process_record (req,
                    rs);
  }
  for (unsigned int i = 0; i < p->num_authority_records; i++)
  {
    struct GNUNET_DNSPARSER_Record *rs = &p->authority_records[i];
 
    process_record (req,
                    rs);
  }
  for (unsigned int i = 0; i < p->num_additional_records; i++)
  {
    struct GNUNET_DNSPARSER_Record *rs = &p->additional_records[i];
 
    process_record (req,
                    rs);
  }
  GNUNET_DNSPARSER_free_packet (p);
  GNUNET_free (req->hostname);
  GNUNET_free (req->raw);
  GNUNET_free (req);
}

References failures, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_parse(), GNUNET_DNSSTUB_resolve_cancel(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, Request::hostname, Request::id, GNUNET_TUN_DnsHeader::id, Request::issue_num, MAX_RETRIES, p, pending, process_record(), Request::raw, req_head, req_tail, and Request::rs.

Referenced by submit_req().

Here is the call graph for this function:

Here is the caller graph for this function:

submit_req()

static int submit_req ( struct Request *  req )

static

Submit a request to DNS unless we need to slow down because we are at the rate limit.

Parameters

req	request to submit

Returns

GNUNET_OK if request was submitted GNUNET_NO if request was already submitted GNUNET_SYSERR if we are at the rate limit

Definition at line 411 of file gnunet-zonewalk.c.

{
  static struct timeval last_request;
  struct timeval now;
 
  if (NULL != req->rs)
    return GNUNET_NO; /* already submitted */
  gettimeofday (&now,
                NULL);
  if ((((now.tv_sec - last_request.tv_sec) == 0) &&
       ((now.tv_usec - last_request.tv_usec) < TIME_THRESH)) ||
      (pending >= THRESH))
    return GNUNET_SYSERR;
  GNUNET_assert (NULL == req->rs);
  req->rs = GNUNET_DNSSTUB_resolve (ctx,
                                    req->raw,
                                    req->raw_len,
                                    &process_result,
                                    req);
  GNUNET_assert (NULL != req->rs);
  req->issue_num++;
  last_request = now;
  lookups++;
  pending++;
  req->time = time (NULL);
  return GNUNET_OK;
}

References ctx, GNUNET_assert, GNUNET_DNSSTUB_resolve(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, Request::issue_num, lookups, pending, process_result(), Request::raw, Request::raw_len, Request::rs, THRESH, Request::time, and TIME_THRESH.

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 446 of file gnunet-zonewalk.c.

{
  (void) cls;
  t = NULL;
  for (struct Request *req = req_head;
       NULL != req;
       req = req->next)
  {
    if (GNUNET_SYSERR == submit_req (req))
      break;
  }
  if (NULL != req_head)
    t = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
                                      &process_queue,
                                      NULL);
  else
    GNUNET_SCHEDULER_shutdown ();
}

References GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_shutdown(), GNUNET_SYSERR, GNUNET_TIME_UNIT_MILLISECONDS, Request::next, process_queue(), req_head, submit_req(), and t.

Referenced by process_queue(), and run().

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 472 of file gnunet-zonewalk.c.

{
  (void) cls;
  if (NULL != t)
  {
    GNUNET_SCHEDULER_cancel (t);
    t = NULL;
  }
  GNUNET_DNSSTUB_stop (ctx);
  ctx = NULL;
}

References ctx, GNUNET_DNSSTUB_stop(), GNUNET_SCHEDULER_cancel(), and t.

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 )

static

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

Parameters

cls

NULL

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

{
  (void) cls;
 
  GNUNET_SCHEDULER_add_shutdown (&do_shutdown,
                                 NULL);
  t = GNUNET_SCHEDULER_add_now (&process_queue,
                                NULL);
}

References do_shutdown(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), process_queue(), and t.

Referenced by main().

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 509 of file gnunet-zonewalk.c.

{
  struct GNUNET_DNSPARSER_Packet p;
  struct GNUNET_DNSPARSER_Query q;
  struct Request *req;
  char *raw;
  size_t raw_size;
  int ret;
 
  if (GNUNET_OK !=
      GNUNET_DNSPARSER_check_name (hostname))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Refusing invalid hostname `%s'\n",
                hostname);
    return;
  }
  q.name = (char *) 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 = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                              UINT16_MAX);
  ret = GNUNET_DNSPARSER_pack (&p,
                               UINT16_MAX,
                               &raw,
                               &raw_size);
  if (GNUNET_OK != ret)
  {
    if (GNUNET_NO == ret)
      GNUNET_free (raw);
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to pack query for hostname `%s'\n",
                hostname);
    return;
  }
 
  req = GNUNET_new (struct Request);
  req->hostname = strdup (hostname);
  req->raw = raw;
  req->raw_len = raw_size;
  req->id = p.id;
  GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                    req_tail,
                                    req);
}

References GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_DNSPARSER_check_name(), GNUNET_DNSPARSER_pack(), GNUNET_DNSPARSER_TYPE_NS, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_TUN_DNS_CLASS_INTERNET, Request::hostname, Request::id, p, q, raw, Request::raw, Request::raw_len, req_head, req_tail, and ret.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	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 570 of file gnunet-zonewalk.c.

{
  char hn[256];
 
  if (2 != argc)
  {
    fprintf (stderr,
             "Missing required configuration argument\n");
    return -1;
  }
  ctx = GNUNET_DNSSTUB_start (256);
  if (NULL == ctx)
  {
    fprintf (stderr,
             "Failed to initialize GNUnet DNS STUB\n");
    return 1;
  }
  if (GNUNET_OK !=
      GNUNET_DNSSTUB_add_dns_ip (ctx,
                                 argv[1]))
  {
    fprintf (stderr,
             "Failed to use `%s' for DNS resolver\n",
             argv[1]);
    return 1;
  }
 
  while (NULL !=
         fgets (hn,
                sizeof(hn),
                stdin))
  {
    if (strlen (hn) > 0)
      hn[strlen (hn) - 1] = '\0';  /* eat newline */
    queue (hn);
  }
  GNUNET_SCHEDULER_run (&run,
                        NULL);
  fprintf (stderr,
           "Did %u lookups, found %u records, %u lookups failed, %u pending on shutdown\n",
           lookups,
           records,
           failures,
           pending);
  return 0;
}

References ctx, failures, GNUNET_DNSSTUB_add_dns_ip(), GNUNET_DNSSTUB_start(), GNUNET_OK, GNUNET_SCHEDULER_run(), Request::hn, lookups, pending, queue(), records, and run().

Here is the call graph for this function:

Variable Documentation

ctx

struct GNUNET_DNSSTUB_Context* ctx

static

Context for DNS resolution.

Definition at line 84 of file gnunet-zonewalk.c.

Referenced by do_shutdown(), main(), and submit_req().

pending

unsigned int pending

static

The number of queries that are outstanding.

Definition at line 89 of file gnunet-zonewalk.c.

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

lookups

unsigned int lookups

static

Number of lookups we performed overall.

Definition at line 94 of file gnunet-zonewalk.c.

Referenced by main(), and submit_req().

failures

unsigned int failures

static

Number of lookups that failed.

Definition at line 99 of file gnunet-zonewalk.c.

Referenced by main(), and process_result().

records

unsigned int records

static

Number of records we found.

Definition at line 104 of file gnunet-zonewalk.c.

Referenced by main(), and process_record().

req_head

struct Request* req_head

static

Head of DLL of all requests to perform.

Definition at line 109 of file gnunet-zonewalk.c.

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

req_tail

struct Request* req_tail

static

Tail of DLL of all requests to perform.

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

Referenced by process_result(), and queue().

t

struct GNUNET_SCHEDULER_Task* t

static

Main task.

Definition at line 119 of file gnunet-zonewalk.c.

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