gnunet-service-gns_resolver.c File Reference

GNU Name System resolver logic. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_namecache_service.h"
#include "gnunet_dns_service.h"
#include "gnunet_resolver_service.h"
#include "gnunet_revocation_service.h"
#include "gnunet_gns_service.h"
#include "gns.h"
#include "gnunet-service-gns.h"
#include "gnunet-service-gns_resolver.h"

Include dependency graph for gnunet-service-gns_resolver.c:

Go to the source code of this file.

Data Structures
struct	Gns2DnsPending
	Element of a resolution process for looking up the responsible DNS server hostname in a GNS2DNS recursive resolution. More...
struct	AuthorityChain
	DLL to hold the authority chain we had to pass in the resolution process. More...
struct	DnsResult
	A result we got from DNS. More...
struct	GNS_ResolverHandle
	Handle to a currently pending resolution. More...
struct	CacheOps
	Active namestore caching operations. More...

Macros
#define	DHT_LOOKUP_TIMEOUT
	Default DHT timeout for lookups. More...
#define	DNS_LOOKUP_TIMEOUT
	Default timeout for DNS lookups. More...
#define	DHT_GNS_REPLICATION_LEVEL   10
	DHT replication level. More...

Functions
int	is_canonical (const char *name)
	Determine if this name is canonical (is a legal name in a zone, without delegation); note that we do not test that the name does not contain illegal characters, we only test for delegation. More...
static char *	translate_dot_plus (struct GNS_ResolverHandle *rh, char *name)
	Expands a name ending in . More...
static void	GNS_resolver_lookup_cancel_ (void *cls)
	Wrapper around GNS_resolver_lookup_cancel() as a task. More...
static void	fail_resolution (struct GNS_ResolverHandle *rh)
	Function called to asynchronously fail a resolution. More...
static void	timeout_resolution (void *cls)
	Function called when a resolution times out. More...
static char *	resolver_lookup_get_next_label (struct GNS_ResolverHandle *rh)
	Get the next, rightmost label from the name that we are trying to resolve, and update the resolution position accordingly. More...
static void	transmit_lookup_dns_result (struct GNS_ResolverHandle *rh)
	Gives the cumulative result obtained to the callback and clean up the request. More...
static void	add_dns_result (struct GNS_ResolverHandle *rh, uint64_t expiration_time, uint32_t record_type, size_t data_size, const void *data)
	Add a result from DNS to the records to be returned to the application. More...
static void	handle_dns_result (void *cls, const struct sockaddr *addr, socklen_t addrlen)
	We had to do a DNS lookup. More...
static void	recursive_resolution (void *cls)
	Task scheduled to continue with the resolution process. More...
static void	start_resolver_lookup (void *cls)
	Begin the resolution process from 'name', starting with the identification of the zone specified by 'name'. More...
static void	dns_result_parser (void *cls, const struct GNUNET_TUN_DnsHeader *dns, size_t dns_len)
	Function called with the result of a DNS resolution. More...
static void	recursive_dns_resolution (struct GNS_ResolverHandle *rh)
	Perform recursive DNS resolution. More...
static void	handle_gns_redirect_result (struct GNS_ResolverHandle *rh, const char *rname)
	We encountered a REDIRECT record during our resolution. More...
static void	handle_gns_cname_result (struct GNS_ResolverHandle *rh, const char *cname)
	We encountered a CNAME record during our resolution. More...
static void	handle_gns_resolution_result (void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Process records that were decrypted from a block. More...
static void	continue_with_gns2dns (struct AuthorityChain *ac)
	We have resolved one or more of the nameservers for a GNS2DNS lookup. More...
static void	handle_gns2dns_result (void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	We've resolved the IP address for the DNS resolver to use after encountering a GNS2DNS record. More...
static void	handle_gns2dns_ip (void *cls, const struct sockaddr *addr, socklen_t addrlen)
	Function called by the resolver for each address obtained from DNS. More...
static void	recursive_redirect_resolution (struct GNS_ResolverHandle *rh, const struct GNUNET_GNSRECORD_Data *rd)
	We found a REDIRECT record, perform recursive resolution on it. More...
static void	recursive_cname_resolution (struct GNS_ResolverHandle *rh, const struct GNUNET_GNSRECORD_Data *rd)
	We found a CNAME record, perform recursive resolution on it. More...
static void	recursive_pkey_resolution (struct GNS_ResolverHandle *rh, const struct GNUNET_GNSRECORD_Data *rd)
	We found a PKEY record, perform recursive resolution on it. More...
static int	recursive_gns2dns_resolution (struct GNS_ResolverHandle *rh, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	We found one or more GNS2DNS records, perform recursive resolution on it. More...
static void	namecache_cache_continuation (void *cls, int32_t success, const char *emsg)
	Function called once the namestore has completed the request for caching a block. More...
static void	handle_dht_response (void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
	Iterator called on each result obtained for a DHT operation that expects a reply. More...
static void	start_dht_request (struct GNS_ResolverHandle *rh, const struct GNUNET_HashCode *query)
	Initiate a DHT query for a set of GNS records. More...
static void	handle_gns_namecache_resolution_result (void *cls, unsigned int rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Process a records that were decrypted from a block that we got from the namecache. More...
static void	handle_namecache_block_response (void *cls, const struct GNUNET_GNSRECORD_Block *block)
	Process a record that was stored in the namecache. More...
static void	recursive_gns_resolution_namecache (struct GNS_ResolverHandle *rh)
	Lookup tail of our authority chain in the namecache. More...
static void	handle_revocation_result (void *cls, int is_valid)
	Function called with the result from a revocation check. More...
static void	recursive_gns_resolution_revocation (struct GNS_ResolverHandle *rh)
	Perform revocation check on tail of our authority chain. More...
struct GNS_ResolverHandle *	GNS_resolver_lookup (const struct GNUNET_IDENTITY_PublicKey *zone, uint32_t record_type, const char *name, enum GNUNET_GNS_LocalOptions options, uint16_t recursion_depth_limit, GNS_ResultProcessor proc, void *proc_cls)
	Lookup of a record in a specific zone calls lookup result processor on result. More...
void	GNS_resolver_lookup_cancel (struct GNS_ResolverHandle *rh)
	Cancel active resolution (i.e. More...
void	GNS_resolver_init (struct GNUNET_NAMECACHE_Handle *nc, struct GNUNET_DHT_Handle *dht, const struct GNUNET_CONFIGURATION_Handle *c, unsigned long long max_bg_queries)
	Initialize the resolver. More...
void	GNS_resolver_done ()
	Shutdown resolver. More...

Variables
static struct GNUNET_NAMECACHE_Handle *	namecache_handle
	Our handle to the namecache service. More...
static struct GNUNET_DHT_Handle *	dht_handle
	Resolver handle to the dht. More...
static struct GNUNET_CONTAINER_Heap *	dht_lookup_heap
	Heap for limiting parallel DHT lookups. More...
static unsigned long long	max_allowed_background_queries
	Maximum amount of parallel queries to the DHT. More...
static struct GNS_ResolverHandle *	rlh_head
	Head of resolver lookup list. More...
static struct GNS_ResolverHandle *	rlh_tail
	Tail of resolver lookup list. More...
static struct CacheOps *	co_head
	Organized in a DLL. More...
static struct CacheOps *	co_tail
	Organized in a DLL. More...
static int	disable_cache
	Use namecache. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Global configuration. More...

Detailed Description

GNU Name System resolver logic.

Author

Martin Schanzenbach

Christian Grothoff

Definition in file gnunet-service-gns_resolver.c.

Macro Definition Documentation

DHT_LOOKUP_TIMEOUT

#define DHT_LOOKUP_TIMEOUT

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 60)

Default DHT timeout for lookups.

Definition at line 57 of file gnunet-service-gns_resolver.c.

DNS_LOOKUP_TIMEOUT

#define DNS_LOOKUP_TIMEOUT

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_SECONDS, 15)

Default timeout for DNS lookups.

Definition at line 63 of file gnunet-service-gns_resolver.c.

DHT_GNS_REPLICATION_LEVEL

#define DHT_GNS_REPLICATION_LEVEL   10

DHT replication level.

Definition at line 69 of file gnunet-service-gns_resolver.c.

Function Documentation

is_canonical()

int is_canonical

(

const char *

name

)

Determine if this name is canonical (is a legal name in a zone, without delegation); note that we do not test that the name does not contain illegal characters, we only test for delegation.

Note that service records (like _foo._srv) are canonical names even though they consist of multiple labels.

Examples: a.b.gnu = not canonical a = canonical _foo._srv = canonical _f.bar = not canonical

Parameters

name	the name to test

Returns

GNUNET_YES if canonical

Definition at line 482 of file gnunet-service-gns_resolver.c.

{
  const char *pos;
  const char *dot;
 
  if (NULL == strchr (name,
                      (unsigned char) '.'))
    return GNUNET_YES;
  if ('_' != name[0])
    return GNUNET_NO;
  pos = &name[1];
  while (NULL != (dot = strchr (pos,
                                (unsigned char) '.')))
    if ('_' != dot[1])
      return GNUNET_NO;
    else
      pos = dot + 1;
  return GNUNET_YES;
}

References GNUNET_NO, GNUNET_YES, and name.

translate_dot_plus()

static char* translate_dot_plus ( struct GNS_ResolverHandle *  rh, char *  name  )

static

Expands a name ending in .

• with the zone of origin.

Parameters

rh	resolution context
name	name to modify (to be free'd or returned)

Returns

updated name

Definition at line 513 of file gnunet-service-gns_resolver.c.

{
  char *ret;
  size_t s_len = strlen (name);
 
  if (0 != strcmp (&name[s_len - 2],
                   ".+"))
    return name; /* did not end in ".+" */
  GNUNET_assert (GNUNET_YES == rh->ac_tail->gns_authority);
  GNUNET_asprintf (&ret,
                   "%.*s.%s",
                   (int) (s_len - 2),
                   name,
                   GNUNET_GNSRECORD_pkey_to_zkey (
                     &rh->ac_tail->authority_info.gns_authority));
  GNUNET_free (name);
  return ret;
}

References GNS_ResolverHandle::ac_tail, AuthorityChain::authority_info, AuthorityChain::gns_authority, GNUNET_asprintf(), GNUNET_assert, GNUNET_free, GNUNET_GNSRECORD_pkey_to_zkey(), GNUNET_YES, name, and ret.

Referenced by handle_gns_resolution_result(), and recursive_gns2dns_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_resolver_lookup_cancel_()

static void GNS_resolver_lookup_cancel_ ( void *  cls )

static

Wrapper around GNS_resolver_lookup_cancel() as a task.

Used for delayed cleanup so we can unwind the stack first.

Parameters

cls	the struct GNS_ResolverHandle

Definition at line 541 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
 
  rh->task_id = NULL;
  GNS_resolver_lookup_cancel (rh);
}

References GNS_resolver_lookup_cancel(), and GNS_ResolverHandle::task_id.

Referenced by dns_result_parser(), fail_resolution(), GNS_resolver_lookup_cancel(), handle_gns_resolution_result(), recursive_dns_resolution(), and start_resolver_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

fail_resolution()

static void fail_resolution ( struct GNS_ResolverHandle *  rh )

static

Function called to asynchronously fail a resolution.

Parameters

rh	the resolution to fail

Definition at line 556 of file gnunet-service-gns_resolver.c.

{
  rh->proc (rh->proc_cls,
            0,
            NULL);
  GNUNET_assert (NULL == rh->task_id);
  rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
                                          rh);
}

References GNS_resolver_lookup_cancel_(), GNUNET_assert, GNUNET_SCHEDULER_add_now(), GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, and GNS_ResolverHandle::task_id.

Referenced by continue_with_gns2dns(), dns_result_parser(), handle_dht_response(), handle_gns_resolution_result(), handle_namecache_block_response(), handle_revocation_result(), recursive_cname_resolution(), recursive_pkey_resolution(), recursive_resolution(), start_dht_request(), and timeout_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

timeout_resolution()

static void timeout_resolution ( void *  cls )

static

Function called when a resolution times out.

Parameters

cls	the struct GNS_ResolverHandle

Definition at line 573 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
 
  rh->task_id = NULL;
  fail_resolution (rh);
}

References fail_resolution(), and GNS_ResolverHandle::task_id.

Referenced by recursive_dns_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

resolver_lookup_get_next_label()

static char* resolver_lookup_get_next_label ( struct GNS_ResolverHandle *  rh )

static

Get the next, rightmost label from the name that we are trying to resolve, and update the resolution position accordingly.

Labels usually consist of up to 63 characters without a period ("."); however, we use a special convention to support SRV and TLSA records where the domain name includes an encoding for a service and protocol in the name. The syntax (see RFC 2782) here is "_Service._Proto.Name" and in this special case we include the "_Service._Proto" in the rightmost label. Thus, for "_443._tcp.foo.bar" we first return the label "bar" and then the label "_443._tcp.foo". The special case is detected by the presence of labels beginning with an underscore. Whenever a label begins with an underscore, it is combined with the label to its right (and the "." is preserved).

Parameters

rh	handle to the resolution operation to get the next label from

Returns

NULL if there are no more labels

Do not advance a label. This seems to be a name only consisting of a BOX indicator (_443,_tcp). Which means, it is a BOX under the empty label. leaving name_resolution_pos as is and returning empty label.

Definition at line 600 of file gnunet-service-gns_resolver.c.

{
  const char *rp;
  const char *dot;
  size_t len;
  char *ret;
  char *srv_name;
  char *proto_name;
  struct protoent *pe;
  struct servent *se;
 
  if (0 == rh->name_resolution_pos)
    return NULL;
  dot = memrchr (rh->name,
                 (int) '.',
                 rh->name_resolution_pos);
  if (NULL == dot)
  {
    /* done, this was the last one */
    len = rh->name_resolution_pos;
    rp = rh->name;
    rh->name_resolution_pos = 0;
  }
  else if (('_' == dot[1]) &&
           ('_' == rh->name[0]) &&
           (dot == memchr (rh->name, (int) '.', rh->name_resolution_pos)))
  {
    rp = GNUNET_GNS_EMPTY_LABEL_AT;
    len = strlen (GNUNET_GNS_EMPTY_LABEL_AT);
  }
  else
  {
    /* advance by one label */
    len = rh->name_resolution_pos - (dot - rh->name) - 1;
    rp = dot + 1;
    rh->name_resolution_pos = dot - rh->name;
  }
  rh->protocol = 0;
  rh->service = 0;
  ret = GNUNET_strndup (rp, len);
  /* If we have labels starting with underscore with label on
   * the right (SRV/DANE/BOX case), determine port/protocol;
   * The format of `rh->name` must be "_PORT._PROTOCOL".
   */
  if (('_' == rh->name[0]) &&
      (NULL != (dot = memrchr (rh->name,
                               (int) '.',
                               rh->name_resolution_pos))) &&
      ('_' == dot[1]) &&
      (NULL == memrchr (rh->name,
                        (int) '.',
                        dot - rh->name)))
  {
    srv_name = GNUNET_strndup (&rh->name[1],
                               (dot - rh->name) - 1);
    proto_name = GNUNET_strndup (&dot[2],
                                 rh->name_resolution_pos - (dot - rh->name)
                                 - 2);
    rh->name_resolution_pos = 0;
    pe = getprotobyname (proto_name);
    if (NULL == pe)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ ("Protocol `%s' unknown, skipping labels.\n"),
                  proto_name);
      GNUNET_free (proto_name);
      GNUNET_free (srv_name);
      return ret;
    }
    se = getservbyname (srv_name,
                        proto_name);
    if (NULL == se)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ (
                    "Service `%s' unknown for protocol `%s', trying as number.\n"),
                  srv_name,
                  proto_name);
      if (1 != sscanf (srv_name, "%u", &rh->service))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    _ ("Service `%s' not a port, skipping service labels.\n"),
                    srv_name);
        GNUNET_free (proto_name);
        GNUNET_free (srv_name);
        return ret;
      }
    }
    else
    {
      rh->service = ntohs (se->s_port);
    }
    rh->protocol = pe->p_proto;
    GNUNET_free (proto_name);
    GNUNET_free (srv_name);
  }
  return ret;
}

References _, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_log, GNUNET_strndup, len, memrchr, GNS_ResolverHandle::name, GNS_ResolverHandle::name_resolution_pos, GNS_ResolverHandle::protocol, ret, rp, and GNS_ResolverHandle::service.

Referenced by handle_gns_redirect_result(), recursive_pkey_resolution(), and start_resolver_lookup().

Here is the caller graph for this function:

transmit_lookup_dns_result()

static void transmit_lookup_dns_result ( struct GNS_ResolverHandle *  rh )

static

Gives the cumulative result obtained to the callback and clean up the request.

Parameters

rh	resolution process that has culminated in a result

If this is a LEHO, we added this before. It must be a supplemental record #LSD0001

Definition at line 712 of file gnunet-service-gns_resolver.c.

{
  struct DnsResult *pos;
  unsigned int n;
  unsigned int i;
 
  n = 0;
  for (pos = rh->dns_result_head; NULL != pos; pos = pos->next)
    n++;
  {
    struct GNUNET_GNSRECORD_Data rd[n];
 
    i = 0;
    for (pos = rh->dns_result_head; NULL != pos; pos = pos->next)
    {
      rd[i].data = pos->data;
      rd[i].data_size = pos->data_size;
      rd[i].record_type = pos->record_type;
      rd[i].flags = GNUNET_GNSRECORD_RF_NONE;
      if (GNUNET_GNSRECORD_TYPE_LEHO == rd[i].record_type)
        rd[i].flags |= GNUNET_GNSRECORD_RF_SUPPLEMENTAL;
      if (0 == pos->expiration_time)
      {
        rd[i].flags |= GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
        rd[i].expiration_time = 0;
      }
      else
      {
        rd[i].expiration_time = pos->expiration_time;
      }
      i++;
    }
    GNUNET_assert (i == n);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Transmitting standard DNS result with %u records\n",
                n);
    rh->proc (rh->proc_cls,
              n,
              rd);
  }
  GNS_resolver_lookup_cancel (rh);
}

References DnsResult::data, GNUNET_GNSRECORD_Data::data, DnsResult::data_size, GNUNET_GNSRECORD_Data::data_size, GNS_ResolverHandle::dns_result_head, DnsResult::expiration_time, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNS_resolver_lookup_cancel(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_RF_NONE, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SUPPLEMENTAL, GNUNET_GNSRECORD_TYPE_LEHO, GNUNET_log, DnsResult::next, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, rd, DnsResult::record_type, and GNUNET_GNSRECORD_Data::record_type.

Referenced by handle_dns_result().

Here is the call graph for this function:

Here is the caller graph for this function:

add_dns_result()

static void add_dns_result ( struct GNS_ResolverHandle *  rh, uint64_t  expiration_time, uint32_t  record_type, size_t  data_size, const void *  data  )

static

Add a result from DNS to the records to be returned to the application.

Parameters

rh	resolution request to extend with a result
expiration_time	expiration time for the answer
record_type	DNS record type of the answer
data_size	number of bytes in data
data	binary data to return in DNS record

Definition at line 770 of file gnunet-service-gns_resolver.c.

{
  struct DnsResult *res;
 
  res = GNUNET_malloc (sizeof(struct DnsResult) + data_size);
  res->expiration_time = expiration_time;
  res->data_size = data_size;
  res->record_type = record_type;
  res->data = &res[1];
  GNUNET_memcpy (&res[1],
                 data,
                 data_size);
  GNUNET_CONTAINER_DLL_insert (rh->dns_result_head,
                               rh->dns_result_tail,
                               res);
}

References data, data_size, GNS_ResolverHandle::dns_result_head, GNS_ResolverHandle::dns_result_tail, DnsResult::expiration_time, GNUNET_CONTAINER_DLL_insert, GNUNET_malloc, GNUNET_memcpy, DnsResult::record_type, and res.

Referenced by dns_result_parser(), and handle_dns_result().

Here is the caller graph for this function:

handle_dns_result()

static void handle_dns_result ( void *  cls, const struct sockaddr *  addr, socklen_t  addrlen  )

static

We had to do a DNS lookup.

Convert the result (if any) and return it.

Parameters

cls	closure with the struct GNS_ResolverHandle
addr	one of the addresses of the host, NULL for the last address
addrlen	length of the address

Definition at line 801 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
  const struct sockaddr_in *sa4;
  const struct sockaddr_in6 *sa6;
 
  if (NULL == addr)
  {
    rh->std_resolve = NULL;
    transmit_lookup_dns_result (rh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u bytes of DNS IP data\n",
              addrlen);
  switch (addr->sa_family)
  {
  case AF_INET:
    sa4 = (const struct sockaddr_in *) addr;
    add_dns_result (rh,
                    0 /* expiration time is unknown */,
                    GNUNET_DNSPARSER_TYPE_A,
                    sizeof(struct in_addr),
                    &sa4->sin_addr);
    break;
 
  case AF_INET6:
    sa6 = (const struct sockaddr_in6 *) addr;
    add_dns_result (rh,
                    0 /* expiration time is unknown */,
                    GNUNET_DNSPARSER_TYPE_AAAA,
                    sizeof(struct in6_addr),
                    &sa6->sin6_addr);
    break;
 
  default:
    GNUNET_break (0);
    break;
  }
}

References add_dns_result(), GNUNET_break, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNS_ResolverHandle::std_resolve, and transmit_lookup_dns_result().

Referenced by dns_result_parser(), handle_gns_cname_result(), and handle_gns_redirect_result().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_resolution()

static void recursive_resolution ( void *  cls )

static

Task scheduled to continue with the resolution process.

Parameters

cls	the 'struct GNS_ResolverHandle' of the resolution

Definition at line 2691 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
 
  rh->task_id = NULL;
  if (rh->loop_threshold < rh->loop_limiter++)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Encountered unbounded recursion resolving `%s'\n",
                rh->name);
    fail_resolution (rh);
    return;
  }
  if (GNUNET_YES == rh->ac_tail->gns_authority)
    recursive_gns_resolution_revocation (rh);
  else
    recursive_dns_resolution (rh);
}

References GNS_ResolverHandle::ac_tail, fail_resolution(), AuthorityChain::gns_authority, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_YES, GNS_ResolverHandle::loop_limiter, GNS_ResolverHandle::loop_threshold, GNS_ResolverHandle::name, recursive_dns_resolution(), recursive_gns_resolution_revocation(), and GNS_ResolverHandle::task_id.

Referenced by continue_with_gns2dns(), handle_gns_redirect_result(), handle_gns_resolution_result(), recursive_pkey_resolution(), and start_resolver_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

start_resolver_lookup()

static void start_resolver_lookup ( void *  cls )

static

Begin the resolution process from 'name', starting with the identification of the zone specified by 'name'.

Parameters

cls	closure with struct GNS_ResolverHandle *rh

Definition at line 2712 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
  struct AuthorityChain *ac;
  struct in_addr v4;
  struct in6_addr v6;
 
  rh->task_id = NULL;
  if (1 == inet_pton (AF_INET,
                      rh->name,
                      &v4))
  {
    /* name is IPv4 address, pretend it's an A record */
    struct GNUNET_GNSRECORD_Data rd;
 
    rd.data = &v4;
    rd.data_size = sizeof(v4);
    rd.expiration_time = UINT64_MAX;
    rd.record_type = GNUNET_DNSPARSER_TYPE_A;
    rd.flags = 0;
    rh->proc (rh->proc_cls,
              1,
              &rd);
    GNUNET_assert (NULL == rh->task_id);
    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
                                            rh);
    return;
  }
  if (1 == inet_pton (AF_INET6,
                      rh->name,
                      &v6))
  {
    /* name is IPv6 address, pretend it's an AAAA record */
    struct GNUNET_GNSRECORD_Data rd;
 
    rd.data = &v6;
    rd.data_size = sizeof(v6);
    rd.expiration_time = UINT64_MAX;
    rd.record_type = GNUNET_DNSPARSER_TYPE_AAAA;
    rd.flags = 0;
    rh->proc (rh->proc_cls,
              1,
              &rd);
    GNUNET_assert (NULL == rh->task_id);
    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
                                            rh);
    return;
  }
 
  ac = GNUNET_new (struct AuthorityChain);
  ac->rh = rh;
  ac->label = resolver_lookup_get_next_label (rh);
  if (NULL == ac->label)
    /* name was just the "TLD", so we default to label
     #GNUNET_GNS_EMPTY_LABEL_AT */
    ac->label = GNUNET_strdup (GNUNET_GNS_EMPTY_LABEL_AT);
  ac->gns_authority = GNUNET_YES;
  ac->authority_info.gns_authority = rh->authority_zone;
  GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
                                    rh->ac_tail,
                                    ac);
  rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
                                          rh);
}

References ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, GNS_ResolverHandle::authority_zone, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_GNSRECORD_Data::flags, GNS_resolver_lookup_cancel_(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_YES, GNS_ResolverHandle::name, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, rd, GNUNET_GNSRECORD_Data::record_type, recursive_resolution(), resolver_lookup_get_next_label(), and GNS_ResolverHandle::task_id.

Referenced by GNS_resolver_lookup(), and recursive_gns2dns_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

dns_result_parser()

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

static

Function called with the result of a DNS resolution.

Parameters

cls	the request handle of the resolution that we were attempting to make
dns	dns response, never NULL
dns_len	number of bytes in dns

Definition at line 873 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
  struct GNUNET_DNSPARSER_Packet *p;
  const struct GNUNET_DNSPARSER_Record *rec;
  unsigned int rd_count;
 
  if (NULL == dns)
  {
    rh->dns_request = NULL;
    GNUNET_SCHEDULER_cancel (rh->task_id);
    rh->task_id = NULL;
    fail_resolution (rh);
    return;
  }
  if (rh->original_dns_id != dns->id)
  {
    /* DNS answer, but for another query */
    return;
  }
  p = GNUNET_DNSPARSER_parse ((const char *) dns,
                              dns_len);
  if (NULL == p)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to parse DNS response\n"));
    return;
  }
 
  /* We got a result from DNS */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received DNS response for `%s' with %u answers\n",
              rh->ac_tail->label,
              (unsigned int) p->num_answers);
  if ((p->num_answers > 0) &&
      (GNUNET_DNSPARSER_TYPE_CNAME == p->answers[0].type) &&
      (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type))
  {
    int af;
 
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Got CNAME `%s' from DNS for `%s'\n",
                p->answers[0].data.hostname,
                rh->name);
    if (NULL != rh->std_resolve)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Multiple CNAME results from DNS resolving `%s'! Not really allowed...\n",
                  rh->name);
      GNUNET_RESOLVER_request_cancel (rh->std_resolve);
    }
    GNUNET_free (rh->name);
    rh->name = GNUNET_strdup (p->answers[0].data.hostname);
    rh->name_resolution_pos = strlen (rh->name);
    switch (rh->record_type)
    {
    case GNUNET_DNSPARSER_TYPE_A:
      af = AF_INET;
      break;
 
    case GNUNET_DNSPARSER_TYPE_AAAA:
      af = AF_INET6;
      break;
 
    default:
      af = AF_UNSPEC;
      break;
    }
    if (NULL != rh->leho)
      add_dns_result (rh,
                      GNUNET_TIME_UNIT_HOURS.rel_value_us,
                      GNUNET_GNSRECORD_TYPE_LEHO,
                      strlen (rh->leho),
                      rh->leho);
    rh->std_resolve = GNUNET_RESOLVER_ip_get (rh->name,
                                              af,
                                              DNS_LOOKUP_TIMEOUT,
                                              &handle_dns_result,
                                              rh);
    GNUNET_DNSPARSER_free_packet (p);
    GNUNET_DNSSTUB_resolve_cancel (rh->dns_request);
    rh->dns_request = NULL;
    return;
  }
 
  /* convert from (parsed) DNS to (binary) GNS format! */
  rd_count = p->num_answers + p->num_authority_records
             + p->num_additional_records;
  {
    struct GNUNET_GNSRECORD_Data rd[rd_count + 1]; /* +1 for LEHO */
    int skip;
    char buf[UINT16_MAX];
    size_t buf_off;
    size_t buf_start;
 
    buf_off = 0;
    skip = 0;
    memset (rd,
            0,
            sizeof(rd));
    for (unsigned int i = 0; i < rd_count; i++)
    {
      if (i < p->num_answers)
        rec = &p->answers[i];
      else if (i < p->num_answers + p->num_authority_records)
        rec = &p->authority_records[i - p->num_answers];
      else
        rec = &p->additional_records[i - p->num_answers
                                     - p->num_authority_records];
      /* As we copied the full DNS name to 'rh->ac_tail->label', this
         should be the correct check to see if this record is actually
         a record for our label... */
      if (0 != strcmp (rec->name,
                       rh->ac_tail->label))
      {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                    "Dropping record `%s', does not match desired name `%s'\n",
                    rec->name,
                    rh->ac_tail->label);
        skip++;
        continue;
      }
      rd[i - skip].record_type = rec->type;
      rd[i - skip].expiration_time = rec->expiration_time.abs_value_us;
      switch (rec->type)
      {
      case GNUNET_DNSPARSER_TYPE_A:
        if (rec->data.raw.data_len != sizeof(struct in_addr))
        {
          GNUNET_break_op (0);
          skip++;
          continue;
        }
        rd[i - skip].data_size = rec->data.raw.data_len;
        rd[i - skip].data = rec->data.raw.data;
        break;
 
      case GNUNET_DNSPARSER_TYPE_AAAA:
        if (rec->data.raw.data_len != sizeof(struct in6_addr))
        {
          GNUNET_break_op (0);
          skip++;
          continue;
        }
        rd[i - skip].data_size = rec->data.raw.data_len;
        rd[i - skip].data = rec->data.raw.data;
        break;
 
      case GNUNET_DNSPARSER_TYPE_CNAME:
      case GNUNET_DNSPARSER_TYPE_PTR:
      case GNUNET_DNSPARSER_TYPE_NS:
        buf_start = buf_off;
        if (GNUNET_OK !=
            GNUNET_DNSPARSER_builder_add_name (buf,
                                               sizeof(buf),
                                               &buf_off,
                                               rec->data.hostname))
        {
          GNUNET_break (0);
          skip++;
          continue;
        }
        rd[i - skip].data_size = buf_off - buf_start;
        rd[i - skip].data = &buf[buf_start];
        break;
 
      case GNUNET_DNSPARSER_TYPE_SOA:
        buf_start = buf_off;
        if (GNUNET_OK !=
            GNUNET_DNSPARSER_builder_add_soa (buf,
                                              sizeof(buf),
                                              &buf_off,
                                              rec->data.soa))
        {
          GNUNET_break (0);
          skip++;
          continue;
        }
        rd[i - skip].data_size = buf_off - buf_start;
        rd[i - skip].data = &buf[buf_start];
        break;
 
      case GNUNET_DNSPARSER_TYPE_MX:
        buf_start = buf_off;
        if (GNUNET_OK !=
            GNUNET_DNSPARSER_builder_add_mx (buf,
                                             sizeof(buf),
                                             &buf_off,
                                             rec->data.mx))
        {
          GNUNET_break (0);
          skip++;
          continue;
        }
        rd[i - skip].data_size = buf_off - buf_start;
        rd[i - skip].data = &buf[buf_start];
        break;
 
      case GNUNET_DNSPARSER_TYPE_SRV:
        buf_start = buf_off;
        if (GNUNET_OK !=
            GNUNET_DNSPARSER_builder_add_srv (buf,
                                              sizeof(buf),
                                              &buf_off,
                                              rec->data.srv))
        {
          GNUNET_break (0);
          skip++;
          continue;
        }
        rd[i - skip].data_size = buf_off - buf_start;
        rd[i - skip].data = &buf[buf_start];
        break;
 
      default:
        GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                    _ ("Skipping record of unsupported type %d\n"),
                    rec->type);
        skip++;
        continue;
      }
    }   /* end of for all records in answer */
    if (NULL != rh->leho)
    {
      rd[rd_count - skip].record_type = GNUNET_GNSRECORD_TYPE_LEHO;
      rd[rd_count - skip].flags = GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION;
      rd[rd_count - skip].flags |= GNUNET_GNSRECORD_RF_SUPPLEMENTAL;
      rd[rd_count - skip].expiration_time = GNUNET_TIME_UNIT_HOURS.rel_value_us;
      rd[rd_count - skip].data = rh->leho;
      rd[rd_count - skip].data_size = strlen (rh->leho);
      skip--;   /* skip one LESS */
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Adding LEHO %s\n",
                  rh->leho);
    }
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Returning DNS response for `%s' with %u answers\n",
                rh->ac_tail->label,
                (unsigned int) (rd_count - skip));
    rh->proc (rh->proc_cls,
              rd_count - skip,
              rd);
    GNUNET_DNSSTUB_resolve_cancel (rh->dns_request);
    rh->dns_request = NULL;
  }
  GNUNET_DNSPARSER_free_packet (p);
  if (NULL != rh->task_id)
    GNUNET_SCHEDULER_cancel (rh->task_id); /* should be timeout task */
  rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
                                          rh);
}

References _, GNUNET_TIME_Absolute::abs_value_us, GNS_ResolverHandle::ac_tail, add_dns_result(), buf, GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, GNUNET_GNSRECORD_Data::data, GNUNET_DNSPARSER_RawRecord::data_len, GNUNET_GNSRECORD_Data::data_size, DNS_LOOKUP_TIMEOUT, GNS_ResolverHandle::dns_request, GNUNET_DNSPARSER_Record::expiration_time, GNUNET_GNSRECORD_Data::expiration_time, fail_resolution(), GNUNET_GNSRECORD_Data::flags, GNS_resolver_lookup_cancel_(), GNUNET_break, GNUNET_break_op, GNUNET_DNSPARSER_builder_add_mx(), GNUNET_DNSPARSER_builder_add_name(), GNUNET_DNSPARSER_builder_add_soa(), GNUNET_DNSPARSER_builder_add_srv(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_parse(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_DNSPARSER_TYPE_MX, GNUNET_DNSPARSER_TYPE_NS, GNUNET_DNSPARSER_TYPE_PTR, GNUNET_DNSPARSER_TYPE_SOA, GNUNET_DNSPARSER_TYPE_SRV, GNUNET_DNSSTUB_resolve_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_GNSRECORD_RF_SUPPLEMENTAL, GNUNET_GNSRECORD_TYPE_LEHO, GNUNET_log, GNUNET_OK, GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_request_cancel(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_strdup, GNUNET_TIME_UNIT_HOURS, handle_dns_result(), GNUNET_DNSPARSER_Record::hostname, GNUNET_TUN_DnsHeader::id, AuthorityChain::label, GNS_ResolverHandle::leho, GNUNET_DNSPARSER_Record::mx, GNS_ResolverHandle::name, GNUNET_DNSPARSER_Record::name, GNS_ResolverHandle::name_resolution_pos, GNS_ResolverHandle::original_dns_id, p, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, GNUNET_DNSPARSER_Record::raw, rd, rd_count, GNS_ResolverHandle::record_type, GNUNET_GNSRECORD_Data::record_type, GNUNET_DNSPARSER_Record::soa, GNUNET_DNSPARSER_Record::srv, GNS_ResolverHandle::std_resolve, GNS_ResolverHandle::task_id, and GNUNET_DNSPARSER_Record::type.

Referenced by recursive_dns_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_dns_resolution()

static void recursive_dns_resolution ( struct GNS_ResolverHandle *  rh )

static

Perform recursive DNS resolution.

Asks the given DNS resolver to resolve "rh->dns_name", possibly recursively proceeding following NS delegations, CNAMES, etc., until 'rh->loop_limiter' bounds us or we find the answer.

Parameters

rh	resolution information

Definition at line 1137 of file gnunet-service-gns_resolver.c.

{
  struct AuthorityChain *ac;
  struct GNUNET_DNSPARSER_Query *query;
  struct GNUNET_DNSPARSER_Packet *p;
  char *dns_request;
  size_t dns_request_length;
  int ret;
 
  ac = rh->ac_tail;
  GNUNET_assert (NULL != ac);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting DNS lookup for `%s'\n",
              ac->label);
  GNUNET_assert (GNUNET_NO == ac->gns_authority);
  query = GNUNET_new (struct GNUNET_DNSPARSER_Query);
  query->name = GNUNET_strdup (ac->label);
  query->type = rh->record_type;
  query->dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
  p = GNUNET_new (struct GNUNET_DNSPARSER_Packet);
  p->queries = query;
  p->num_queries = 1;
  p->id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                               UINT16_MAX);
  p->flags.opcode = GNUNET_TUN_DNS_OPCODE_QUERY;
  p->flags.recursion_desired = 1;
  ret = GNUNET_DNSPARSER_pack (p,
                               1024,
                               &dns_request,
                               &dns_request_length);
  if (GNUNET_OK != ret)
  {
    GNUNET_break (0);
    rh->proc (rh->proc_cls,
              0,
              NULL);
    GNUNET_assert (NULL == rh->task_id);
    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
                                            rh);
  }
  else
  {
    rh->original_dns_id = p->id;
    GNUNET_assert (NULL != ac->authority_info.dns_authority.dns_handle);
    GNUNET_assert (NULL == rh->dns_request);
    rh->leho = GNUNET_strdup (ac->label);
    rh->dns_request = GNUNET_DNSSTUB_resolve (
      ac->authority_info.dns_authority.dns_handle,
      dns_request,
      dns_request_length,
      &dns_result_parser,
      rh);
    rh->task_id = GNUNET_SCHEDULER_add_delayed (DNS_LOOKUP_TIMEOUT,
                                                &timeout_resolution,
                                                rh);
  }
  if (GNUNET_SYSERR != ret)
    GNUNET_free (dns_request);
  GNUNET_DNSPARSER_free_packet (p);
}

References ac, GNS_ResolverHandle::ac_tail, DNS_LOOKUP_TIMEOUT, GNS_ResolverHandle::dns_request, dns_result_parser(), GNUNET_DNSPARSER_Query::dns_traffic_class, GNS_resolver_lookup_cancel_(), GNUNET_assert, GNUNET_break, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_pack(), GNUNET_DNSSTUB_resolve(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_TUN_DNS_CLASS_INTERNET, GNUNET_TUN_DNS_OPCODE_QUERY, GNS_ResolverHandle::leho, GNUNET_DNSPARSER_Query::name, GNS_ResolverHandle::original_dns_id, p, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, GNS_ResolverHandle::record_type, ret, GNS_ResolverHandle::task_id, timeout_resolution(), and GNUNET_DNSPARSER_Query::type.

Referenced by recursive_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_gns_redirect_result()

static void handle_gns_redirect_result ( struct GNS_ResolverHandle *  rh, const char *  rname  )

static

We encountered a REDIRECT record during our resolution.

Merge it into our chain.

Parameters

rh	resolution we are performing
rname	value of the redirect record we got for the current authority chain tail

Definition at line 1208 of file gnunet-service-gns_resolver.c.

{
  size_t nlen;
  char *res;
  const char *tld;
  struct AuthorityChain *ac;
  int af;
  struct GNUNET_IDENTITY_PublicKey zone;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling GNS REDIRECT result `%s'\n",
              rname);
  nlen = strlen (rname);
  tld = GNS_get_tld (rname);
  if (0 == strcmp ("+", tld))
  {
    /* REDIRECT resolution continues relative to current domain */
    if (0 == rh->name_resolution_pos)
    {
      res = GNUNET_strndup (rname, nlen - 2);
      rh->name_resolution_pos = nlen - 2;
    }
    else
    {
      GNUNET_asprintf (&res,
                       "%.*s.%.*s",
                       (int) rh->name_resolution_pos,
                       rh->name,
                       (int) (nlen - 2),
                       rname);
      rh->name_resolution_pos = strlen (res);
    }
    GNUNET_free (rh->name);
    rh->name = res;
    ac = GNUNET_new (struct AuthorityChain);
    ac->rh = rh;
    ac->gns_authority = GNUNET_YES;
    ac->authority_info.gns_authority =
      rh->ac_tail->authority_info.gns_authority;
    ac->label = resolver_lookup_get_next_label (rh);
    /* add AC to tail */
    GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
                                      rh->ac_tail,
                                      ac);
    rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
                                            rh);
    return;
  }
  if (GNUNET_OK == GNUNET_GNSRECORD_zkey_to_pkey (tld, &zone))
  {
    /* REDIRECT resolution continues relative to current domain */
    if (0 == rh->name_resolution_pos)
    {
      GNUNET_asprintf (&res,
                       "%.*s",
                       (int) (strlen (rname) - (strlen (tld) + 1)),
                       rname);
    }
    else
    {
      GNUNET_asprintf (&res,
                       "%.*s.%.*s",
                       (int) rh->name_resolution_pos,
                       rh->name,
                       (int) (strlen (rname) - (strlen (tld) + 1)),
                       rname);
    }
    rh->name_resolution_pos = strlen (res);
    GNUNET_free (rh->name);
    rh->name = res;
    ac = GNUNET_new (struct AuthorityChain);
    ac->rh = rh;
    ac->gns_authority = GNUNET_YES;
    ac->authority_info.gns_authority = zone;
    ac->label = resolver_lookup_get_next_label (rh);
    /* add AC to tail */
    GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
                                      rh->ac_tail,
                                      ac);
    rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
                                            rh);
    return;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Got REDIRECT `%s' from GNS for `%s'\n",
              rname,
              rh->name);
  if (NULL != rh->std_resolve)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Multiple REDIRECT results from GNS resolving `%s'! Not really allowed...\n",
                rh->name);
    GNUNET_RESOLVER_request_cancel (rh->std_resolve);
  }
  /* name is absolute, go to DNS */
  GNUNET_free (rh->name);
  rh->name = GNUNET_strdup (rname);
  rh->name_resolution_pos = strlen (rh->name);
  switch (rh->record_type)
  {
  case GNUNET_DNSPARSER_TYPE_A:
    af = AF_INET;
    break;
 
  case GNUNET_DNSPARSER_TYPE_AAAA:
    af = AF_INET6;
    break;
 
  default:
    af = AF_UNSPEC;
    break;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Doing standard DNS lookup for `%s'\n",
              rh->name);
 
  rh->std_resolve = GNUNET_RESOLVER_ip_get (rh->name,
                                            af,
                                            DNS_LOOKUP_TIMEOUT,
                                            &handle_dns_result,
                                            rh);
}

References ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, AuthorityChain::authority_info, DNS_LOOKUP_TIMEOUT, AuthorityChain::gns_authority, GNS_get_tld(), GNUNET_asprintf(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNSRECORD_zkey_to_pkey(), GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_request_cancel(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_strndup, GNUNET_YES, handle_dns_result(), GNS_ResolverHandle::name, GNS_ResolverHandle::name_resolution_pos, GNS_ResolverHandle::record_type, recursive_resolution(), res, resolver_lookup_get_next_label(), GNS_ResolverHandle::std_resolve, GNS_ResolverHandle::task_id, and zone.

Referenced by handle_gns_resolution_result(), and recursive_redirect_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_gns_cname_result()

static void handle_gns_cname_result ( struct GNS_ResolverHandle *  rh, const char *  cname  )

static

We encountered a CNAME record during our resolution.

Merge it into our chain.

Parameters

rh	resolution we are performing
cname	value of the cname record we got for the current authority chain tail

Definition at line 1343 of file gnunet-service-gns_resolver.c.

{
  int af;
 
  GNUNET_free (rh->name);
  rh->name = GNUNET_strdup (cname);
  rh->name_resolution_pos = strlen (rh->name);
  switch (rh->record_type)
  {
  case GNUNET_DNSPARSER_TYPE_A:
    af = AF_INET;
    break;
 
  case GNUNET_DNSPARSER_TYPE_AAAA:
    af = AF_INET6;
    break;
 
  default:
    af = AF_UNSPEC;
    break;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Doing standard DNS lookup for `%s'\n",
              rh->name);
 
  rh->std_resolve = GNUNET_RESOLVER_ip_get (rh->name,
                                            af,
                                            DNS_LOOKUP_TIMEOUT,
                                            &handle_dns_result,
                                            rh);
}

References DNS_LOOKUP_TIMEOUT, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_RESOLVER_ip_get(), GNUNET_strdup, handle_dns_result(), GNS_ResolverHandle::name, GNS_ResolverHandle::name_resolution_pos, GNS_ResolverHandle::record_type, and GNS_ResolverHandle::std_resolve.

Referenced by handle_gns_resolution_result(), and recursive_cname_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_gns_resolution_result()

static void handle_gns_resolution_result ( void *  cls, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Process records that were decrypted from a block.

Parameters

cls	closure with the 'struct GNS_ResolverHandle'
rd_count	number of entries in rd array
rd	array of records with data to store

Definition at line 1894 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
  char *cname;
  char scratch[UINT16_MAX];
  size_t scratch_off;
  size_t scratch_start;
  size_t off;
  struct GNUNET_GNSRECORD_Data rd_new[rd_count];
  unsigned int rd_off;
 
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "Resolution succeeded for `%s' in zone %s, got %u records\n",
              rh->ac_tail->label,
              GNUNET_GNSRECORD_z2s (&rh->ac_tail->authority_info.gns_authority),
              rd_count);
  if (0 == rd_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("GNS lookup failed (zero records found for `%s')\n"),
                rh->name);
    fail_resolution (rh);
    return;
  }
 
  if (0 == rh->name_resolution_pos)
  {
    /* top-level match, are we done yet? */
    if ((rd_count > 0) &&
        (GNUNET_DNSPARSER_TYPE_CNAME == rd[0].record_type) &&
        (GNUNET_DNSPARSER_TYPE_CNAME != rh->record_type))
    {
      off = 0;
      cname = GNUNET_DNSPARSER_parse_name (rd[0].data,
                                           rd[0].data_size,
                                           &off);
      if ((NULL == cname) ||
          (off != rd[0].data_size))
      {
        GNUNET_break_op (0);
        GNUNET_free (cname);
        fail_resolution (rh);
        return;
      }
      handle_gns_cname_result (rh,
                               cname);
      GNUNET_free (cname);
      return;
    }
    if ((rd_count > 0) &&
        (GNUNET_GNSRECORD_TYPE_REDIRECT == rd[0].record_type) &&
        (GNUNET_GNSRECORD_TYPE_REDIRECT != rh->record_type))
    {
      handle_gns_redirect_result (rh,
                                  rd[0].data);
      return;
    }
 
 
    /* If A/AAAA was requested,
     * but we got a GNS2DNS record */
    if ((GNUNET_DNSPARSER_TYPE_A == rh->record_type) ||
        (GNUNET_DNSPARSER_TYPE_AAAA == rh->record_type))
    {
      for (unsigned int i = 0; i < rd_count; i++)
      {
        switch (rd[i].record_type)
        {
        case GNUNET_GNSRECORD_TYPE_GNS2DNS:
          {
            /* delegation to DNS */
            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        "Found GNS2DNS record, delegating to DNS!\n");
            if (GNUNET_OK ==
                recursive_gns2dns_resolution (rh,
                                              rd_count,
                                              rd))
              return;
            else
              goto fail;
          }
 
        default:
          break;
        }         /* end: switch */
      }       /* end: for rd */
    }     /* end: name_resolution_pos */
    /* convert relative names in record values to absolute names,
       using 'scratch' array for memory allocations */
    scratch_off = 0;
    rd_off = 0;
    for (unsigned int i = 0; i < rd_count; i++)
    {
      GNUNET_assert (rd_off <= i);
      if ((0 != rh->protocol) &&
          (0 != rh->service) &&
          (GNUNET_GNSRECORD_TYPE_BOX != rd[i].record_type))
        continue;     /* we _only_ care about boxed records */
 
      GNUNET_assert (rd_off < rd_count);
      rd_new[rd_off] = rd[i];
      /* Check if the embedded name(s) end in "+", and if so,
         replace the "+" with the zone at "ac_tail", changing the name
         to a ".ZONEKEY".  The name is allocated on the 'scratch' array,
         so we can free it afterwards. */
      switch (rd[i].record_type)
      {
      case GNUNET_GNSRECORD_TYPE_REDIRECT:
        {
          char *rname;
          rname = GNUNET_strndup (rd[i].data, rd[i].data_size);
          rname = translate_dot_plus (rh, rname);
          GNUNET_break (NULL != rname);
          scratch_start = scratch_off;
          memcpy (&scratch[scratch_start], rname, strlen (rname) + 1);
          scratch_off += strlen (rname) + 1;
          GNUNET_assert (rd_off < rd_count);
          rd_new[rd_off].data = &scratch[scratch_start];
          rd_new[rd_off].data_size = scratch_off - scratch_start;
          rd_off++;
          GNUNET_free (rname);
        }
        break;
 
      case GNUNET_DNSPARSER_TYPE_CNAME:
        {
          char *cname;
 
          off = 0;
          cname = GNUNET_DNSPARSER_parse_name (rd[i].data,
                                               rd[i].data_size,
                                               &off);
          if ((NULL == cname) ||
              (off != rd[i].data_size))
          {
            GNUNET_break_op (0);      /* record not well-formed */
          }
          else
          {
            cname = translate_dot_plus (rh, cname);
            GNUNET_break (NULL != cname);
            scratch_start = scratch_off;
            if (GNUNET_OK !=
                GNUNET_DNSPARSER_builder_add_name (scratch,
                                                   sizeof(scratch),
                                                   &scratch_off,
                                                   cname))
            {
              GNUNET_break (0);
            }
            else
            {
              GNUNET_assert (rd_off < rd_count);
              rd_new[rd_off].data = &scratch[scratch_start];
              rd_new[rd_off].data_size = scratch_off - scratch_start;
              rd_off++;
            }
          }
          GNUNET_free (cname);
        }
        break;
 
      case GNUNET_DNSPARSER_TYPE_SOA:
        {
          struct GNUNET_DNSPARSER_SoaRecord *soa;
 
          off = 0;
          soa = GNUNET_DNSPARSER_parse_soa (rd[i].data,
                                            rd[i].data_size,
                                            &off);
          if ((NULL == soa) ||
              (off != rd[i].data_size))
          {
            GNUNET_break_op (0);      /* record not well-formed */
          }
          else
          {
            soa->mname = translate_dot_plus (rh, soa->mname);
            soa->rname = translate_dot_plus (rh, soa->rname);
            scratch_start = scratch_off;
            if (GNUNET_OK !=
                GNUNET_DNSPARSER_builder_add_soa (scratch,
                                                  sizeof(scratch),
                                                  &scratch_off,
                                                  soa))
            {
              GNUNET_break (0);
            }
            else
            {
              GNUNET_assert (rd_off < rd_count);
              rd_new[rd_off].data = &scratch[scratch_start];
              rd_new[rd_off].data_size = scratch_off - scratch_start;
              rd_off++;
            }
          }
          if (NULL != soa)
            GNUNET_DNSPARSER_free_soa (soa);
        }
        break;
 
      case GNUNET_DNSPARSER_TYPE_MX:
        {
          struct GNUNET_DNSPARSER_MxRecord *mx;
 
          off = 0;
          mx = GNUNET_DNSPARSER_parse_mx (rd[i].data,
                                          rd[i].data_size,
                                          &off);
          if ((NULL == mx) ||
              (off != rd[i].data_size))
          {
            GNUNET_break_op (0);      /* record not well-formed */
          }
          else
          {
            mx->mxhost = translate_dot_plus (rh, mx->mxhost);
            scratch_start = scratch_off;
            if (GNUNET_OK !=
                GNUNET_DNSPARSER_builder_add_mx (scratch,
                                                 sizeof(scratch),
                                                 &scratch_off,
                                                 mx))
            {
              GNUNET_break (0);
            }
            else
            {
              GNUNET_assert (rd_off < rd_count);
              rd_new[rd_off].data = &scratch[scratch_start];
              rd_new[rd_off].data_size = scratch_off - scratch_start;
              rd_off++;
            }
          }
          if (NULL != mx)
            GNUNET_DNSPARSER_free_mx (mx);
        }
        break;
 
      case GNUNET_DNSPARSER_TYPE_SRV:
        {
          struct GNUNET_DNSPARSER_SrvRecord *srv;
 
          off = 0;
          srv = GNUNET_DNSPARSER_parse_srv (rd[i].data,
                                            rd[i].data_size,
                                            &off);
          if ((NULL == srv) ||
              (off != rd[i].data_size))
          {
            GNUNET_break_op (0);      /* record not well-formed */
          }
          else
          {
            srv->target = translate_dot_plus (rh, srv->target);
            scratch_start = scratch_off;
            if (GNUNET_OK !=
                GNUNET_DNSPARSER_builder_add_srv (scratch,
                                                  sizeof(scratch),
                                                  &scratch_off,
                                                  srv))
            {
              GNUNET_break (0);
            }
            else
            {
              GNUNET_assert (rd_off < rd_count);
              rd_new[rd_off].data = &scratch[scratch_start];
              rd_new[rd_off].data_size = scratch_off - scratch_start;
              rd_off++;
            }
          }
          if (NULL != srv)
            GNUNET_DNSPARSER_free_srv (srv);
        }
        break;
 
      case GNUNET_GNSRECORD_TYPE_PKEY:
      case GNUNET_GNSRECORD_TYPE_EDKEY:
        {
          struct GNUNET_IDENTITY_PublicKey pubkey;
          if (rd[i].data_size < sizeof(uint32_t))
          {
            GNUNET_break_op (0);
            break;
          }
          if (GNUNET_OK !=
              GNUNET_GNSRECORD_identity_from_data (rd[i].data,
                                                   rd[i].data_size,
                                                   rd[i].record_type,
                                                   &pubkey))
          {
            GNUNET_break_op (0);
            break;
          }
          rd_off++;
          if (rd[i].record_type != rh->record_type)
          {
            /* try to resolve "@" */
            struct AuthorityChain *ac;
 
            ac = GNUNET_new (struct AuthorityChain);
            ac->rh = rh;
            ac->gns_authority = GNUNET_YES;
            ac->authority_info.gns_authority = pubkey;
            ac->label = GNUNET_strdup (GNUNET_GNS_EMPTY_LABEL_AT);
            GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
                                              rh->ac_tail,
                                              ac);
            rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
                                                    rh);
            return;
          }
        }
        break;
 
      case GNUNET_GNSRECORD_TYPE_GNS2DNS:
        {
          /* delegation to DNS */
          if (GNUNET_GNSRECORD_TYPE_GNS2DNS == rh->record_type)
          {
            rd_off++;
            break;       /* do not follow to DNS, we wanted the GNS2DNS record! */
          }
          GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                      "Found GNS2DNS record, delegating to DNS!\n");
          if (GNUNET_OK ==
              recursive_gns2dns_resolution (rh,
                                            rd_count,
                                            rd))
            return;
          else
            goto fail;
        }
 
      case GNUNET_GNSRECORD_TYPE_BOX:
        {
          /* unbox SRV/TLSA records if a specific one was requested */
          if ((0 != rh->protocol) &&
              (0 != rh->service) &&
              (rd[i].data_size >= sizeof(struct GNUNET_GNSRECORD_BoxRecord)))
          {
            const struct GNUNET_GNSRECORD_BoxRecord *box;
 
            box = rd[i].data;
            GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                        "Got BOX record, checking if parameters match... %u/%u vs %u/%u\n",
                        ntohs (box->protocol), ntohs (box->service),
                        rh->protocol, rh->service);
            if ((ntohs (box->protocol) == rh->protocol) &&
                (ntohs (box->service) == rh->service))
            {
              /* Box matches, unbox! */
              GNUNET_assert (rd_off < rd_count);
              rd_new[rd_off].record_type = ntohl (box->record_type);
              rd_new[rd_off].data_size -= sizeof(struct
                                                 GNUNET_GNSRECORD_BoxRecord);
              rd_new[rd_off].data = &box[1];
              rd_off++;
            }
          }
          else
          {
            /* no specific protocol/service specified, preserve all BOX
               records (for modern, GNS-enabled applications) */
            rd_off++;
          }
          break;
        }
 
      default:
        rd_off++;
        break;
      }       /* end: switch */
    }     /* end: for rd_count */
 
    /* yes, we are done, return result */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Returning GNS response for `%s' with %u answers\n",
                rh->ac_tail->label,
                rd_off);
    rh->proc (rh->proc_cls,
              rd_off,
              rd_new);
    rh->task_id = GNUNET_SCHEDULER_add_now (&GNS_resolver_lookup_cancel_,
                                            rh);
    return;
  }
 
  switch (rd[0].record_type)
  {
  case GNUNET_GNSRECORD_TYPE_REDIRECT:
    GNUNET_break_op (1 == rd_count);  /* REDIRECT should be unique */
    recursive_redirect_resolution (rh,
                                   &rd[0]);
    return;
 
  case GNUNET_DNSPARSER_TYPE_CNAME:
    GNUNET_break_op (1 == rd_count);  /* CNAME should be unique */
    recursive_cname_resolution (rh,
                                &rd[0]);
    return;
 
  case GNUNET_GNSRECORD_TYPE_PKEY:
  case GNUNET_GNSRECORD_TYPE_EDKEY:
    GNUNET_break_op (1 == rd_count);  /* PKEY should be unique */
    recursive_pkey_resolution (rh,
                               &rd[0]);
    return;
 
  case GNUNET_GNSRECORD_TYPE_GNS2DNS:
    if (GNUNET_OK ==
        recursive_gns2dns_resolution (rh,
                                      rd_count,
                                      rd))
      return;
    break;
  default:
    if (GNUNET_YES != GNUNET_GNSRECORD_is_critical (rd[0].record_type))
      return;
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Unable to process critical delegation record\n"));
    break;
  }
fail:
  GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
              _ ("GNS lookup recursion failed (no delegation record found)\n"));
  fail_resolution (rh);
}

References _, ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, AuthorityChain::authority_info, GNUNET_GNSRECORD_Data::data, data, data_size, GNUNET_GNSRECORD_Data::data_size, fail_resolution(), AuthorityChain::gns_authority, GNS_resolver_lookup_cancel_(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_DNSPARSER_builder_add_mx(), GNUNET_DNSPARSER_builder_add_name(), GNUNET_DNSPARSER_builder_add_soa(), GNUNET_DNSPARSER_builder_add_srv(), GNUNET_DNSPARSER_free_mx(), GNUNET_DNSPARSER_free_soa(), GNUNET_DNSPARSER_free_srv(), GNUNET_DNSPARSER_parse_mx(), GNUNET_DNSPARSER_parse_name(), GNUNET_DNSPARSER_parse_soa(), GNUNET_DNSPARSER_parse_srv(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_DNSPARSER_TYPE_MX, GNUNET_DNSPARSER_TYPE_SOA, GNUNET_DNSPARSER_TYPE_SRV, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNS_EMPTY_LABEL_AT, GNUNET_GNSRECORD_identity_from_data(), GNUNET_GNSRECORD_is_critical(), GNUNET_GNSRECORD_TYPE_BOX, GNUNET_GNSRECORD_TYPE_EDKEY, GNUNET_GNSRECORD_TYPE_GNS2DNS, GNUNET_GNSRECORD_TYPE_PKEY, GNUNET_GNSRECORD_TYPE_REDIRECT, GNUNET_GNSRECORD_z2s(), GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_strndup, GNUNET_YES, handle_gns_cname_result(), handle_gns_redirect_result(), AuthorityChain::label, GNUNET_DNSPARSER_SoaRecord::mname, GNUNET_DNSPARSER_MxRecord::mxhost, GNS_ResolverHandle::name, GNS_ResolverHandle::name_resolution_pos, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, GNS_ResolverHandle::protocol, GNUNET_GNSRECORD_BoxRecord::protocol, pubkey, rd, rd_count, GNS_ResolverHandle::record_type, GNUNET_GNSRECORD_Data::record_type, GNUNET_GNSRECORD_BoxRecord::record_type, recursive_cname_resolution(), recursive_gns2dns_resolution(), recursive_pkey_resolution(), recursive_redirect_resolution(), recursive_resolution(), AuthorityChain::rh, GNUNET_DNSPARSER_SoaRecord::rname, GNS_ResolverHandle::service, GNUNET_GNSRECORD_BoxRecord::service, GNUNET_DNSPARSER_SrvRecord::target, GNS_ResolverHandle::task_id, and translate_dot_plus().

Referenced by handle_dht_response(), and handle_gns_namecache_resolution_result().

Here is the call graph for this function:

Here is the caller graph for this function:

continue_with_gns2dns()

static void continue_with_gns2dns ( struct AuthorityChain *  ac )

static

We have resolved one or more of the nameservers for a GNS2DNS lookup.

Once we have some of them, begin using the DNSSTUB resolver.

Parameters

ac	context for GNS2DNS resolution

Definition at line 1398 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = ac->rh;
 
  if ((NULL != ac->authority_info.dns_authority.gp_head) &&
      (GNUNET_NO == ac->authority_info.dns_authority.found))
    return; /* more pending and none found yet */
  if (GNUNET_NO == ac->authority_info.dns_authority.found)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Failed to resolve DNS server for `%s' in GNS2DNS resolution\n",
                ac->authority_info.dns_authority.name);
    fail_resolution (rh);
    return;
  }
  if (GNUNET_NO != ac->authority_info.dns_authority.launched)
    return; /* already running, do not launch again! */
  /* recurse */
  ac->authority_info.dns_authority.launched = GNUNET_YES;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Will continue resolution using DNS to resolve `%s'\n",
              ac->label);
  GNUNET_assert (NULL == rh->task_id);
  rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
                                          rh);
}

References ac, fail_resolution(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_YES, recursive_resolution(), and GNS_ResolverHandle::task_id.

Referenced by handle_gns2dns_ip(), handle_gns2dns_result(), and recursive_gns2dns_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_gns2dns_result()

static void handle_gns2dns_result ( void *  cls, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

We've resolved the IP address for the DNS resolver to use after encountering a GNS2DNS record.

Parameters

cls	the struct Gns2DnsPending used for this request
rd_count	number of records in rd
rd	addresses for the DNS resolver (presumably)

Definition at line 1435 of file gnunet-service-gns_resolver.c.

{
  struct Gns2DnsPending *gp = cls;
  struct AuthorityChain *ac = gp->ac;
 
  GNUNET_CONTAINER_DLL_remove (ac->authority_info.dns_authority.gp_head,
                               ac->authority_info.dns_authority.gp_tail,
                               gp);
  /* enable cleanup of 'rh' handle that automatically comes after we return,
     and which expects 'rh' to be in the #rlh_head DLL. */
  if (NULL != gp->rh)
  {
    GNUNET_CONTAINER_DLL_insert (rlh_head,
                                 rlh_tail,
                                 gp->rh);
    gp->rh = NULL;
  }
  GNUNET_free (gp);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received %u results for IP address of DNS server for GNS2DNS transition\n",
              rd_count);
  /* find suitable A/AAAA record */
  for (unsigned int j = 0; j < rd_count; j++)
  {
    switch (rd[j].record_type)
    {
    case GNUNET_DNSPARSER_TYPE_A:
      {
        struct sockaddr_in v4;
 
        if (sizeof(struct in_addr) != rd[j].data_size)
        {
          GNUNET_break_op (0);
          continue;
        }
        memset (&v4,
                0,
                sizeof(v4));
        v4.sin_family = AF_INET;
        v4.sin_port = htons (53);
#if HAVE_SOCKADDR_IN_SIN_LEN
        v4.sin_len = (u_char) sizeof(v4);
#endif
        GNUNET_memcpy (&v4.sin_addr,
                       rd[j].data,
                       sizeof(struct in_addr));
        if (GNUNET_OK ==
            GNUNET_DNSSTUB_add_dns_sa (
              ac->authority_info.dns_authority.dns_handle,
              (const struct sockaddr *) &v4))
          ac->authority_info.dns_authority.found = GNUNET_YES;
        break;
      }
 
    case GNUNET_DNSPARSER_TYPE_AAAA:
      {
        struct sockaddr_in6 v6;
 
        if (sizeof(struct in6_addr) != rd[j].data_size)
        {
          GNUNET_break_op (0);
          continue;
        }
        /* FIXME: might want to check if we support IPv6 here,
           and otherwise skip this one and hope we find another */
        memset (&v6,
                0,
                sizeof(v6));
        v6.sin6_family = AF_INET6;
        v6.sin6_port = htons (53);
#if HAVE_SOCKADDR_IN_SIN_LEN
        v6.sin6_len = (u_char) sizeof(v6);
#endif
        GNUNET_memcpy (&v6.sin6_addr,
                       rd[j].data,
                       sizeof(struct in6_addr));
        if (GNUNET_OK ==
            GNUNET_DNSSTUB_add_dns_sa (
              ac->authority_info.dns_authority.dns_handle,
              (const struct sockaddr *) &v6))
          ac->authority_info.dns_authority.found = GNUNET_YES;
        break;
      }
 
    default:
      break;
    }
  }
  continue_with_gns2dns (ac);
}

References Gns2DnsPending::ac, ac, continue_with_gns2dns(), GNUNET_GNSRECORD_Data::data, data_size, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSSTUB_add_dns_sa(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_YES, rd, rd_count, Gns2DnsPending::rh, rlh_head, and rlh_tail.

Referenced by recursive_gns2dns_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_gns2dns_ip()

static void handle_gns2dns_ip ( void *  cls, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Function called by the resolver for each address obtained from DNS.

Parameters

cls	closure, a struct Gns2DnsPending *
addr	one of the addresses of the host, NULL for the last address
addrlen	length of addr

Definition at line 1537 of file gnunet-service-gns_resolver.c.

{
  struct Gns2DnsPending *gp = cls;
  struct AuthorityChain *ac = gp->ac;
  struct sockaddr_storage ss;
  struct sockaddr_in *v4;
  struct sockaddr_in6 *v6;
 
  if (NULL == addr)
  {
    /* DNS resolution finished */
    if (0 == gp->num_results)
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Failed to use DNS to resolve name of DNS resolver\n");
    GNUNET_CONTAINER_DLL_remove (ac->authority_info.dns_authority.gp_head,
                                 ac->authority_info.dns_authority.gp_tail,
                                 gp);
    GNUNET_free (gp);
    continue_with_gns2dns (ac);
    return;
  }
  GNUNET_memcpy (&ss,
                 addr,
                 addrlen);
  switch (ss.ss_family)
  {
  case AF_INET:
    v4 = (struct sockaddr_in *) &ss;
    v4->sin_port = htons (53);
    gp->num_results++;
    break;
 
  case AF_INET6:
    v6 = (struct sockaddr_in6 *) &ss;
    v6->sin6_port = htons (53);
    gp->num_results++;
    break;
 
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unsupported AF %d\n",
                ss.ss_family);
    return;
  }
  if (GNUNET_OK ==
      GNUNET_DNSSTUB_add_dns_sa (ac->authority_info.dns_authority.dns_handle,
                                 (struct sockaddr *) &ss))
    ac->authority_info.dns_authority.found = GNUNET_YES;
}

References Gns2DnsPending::ac, ac, continue_with_gns2dns(), GNUNET_CONTAINER_DLL_remove, GNUNET_DNSSTUB_add_dns_sa(), GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_memcpy, GNUNET_OK, GNUNET_YES, and Gns2DnsPending::num_results.

Referenced by recursive_gns2dns_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_redirect_resolution()

static void recursive_redirect_resolution ( struct GNS_ResolverHandle *  rh, const struct GNUNET_GNSRECORD_Data *  rd  )

static

We found a REDIRECT record, perform recursive resolution on it.

Parameters

rh	resolution handle
rd	record with CNAME to resolve recursively

Definition at line 1597 of file gnunet-service-gns_resolver.c.

{
  handle_gns_redirect_result (rh,
                              rd->data);
}

References GNUNET_GNSRECORD_Data::data, handle_gns_redirect_result(), and rd.

Referenced by handle_gns_resolution_result().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_cname_resolution()

static void recursive_cname_resolution ( struct GNS_ResolverHandle *  rh, const struct GNUNET_GNSRECORD_Data *  rd  )

static

We found a CNAME record, perform recursive resolution on it.

Parameters

rh	resolution handle
rd	record with CNAME to resolve recursively

Definition at line 1612 of file gnunet-service-gns_resolver.c.

{
  char *cname;
  size_t off;
 
  off = 0;
  cname = GNUNET_DNSPARSER_parse_name (rd->data,
                                       rd->data_size,
                                       &off);
  if ((NULL == cname) ||
      (off != rd->data_size))
  {
    GNUNET_break_op (0);  /* record not well-formed */
    GNUNET_free (cname);
    fail_resolution (rh);
    return;
  }
  handle_gns_cname_result (rh,
                           cname);
  GNUNET_free (cname);
}

References GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, fail_resolution(), GNUNET_break_op, GNUNET_DNSPARSER_parse_name(), GNUNET_free, handle_gns_cname_result(), and rd.

Referenced by handle_gns_resolution_result().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_pkey_resolution()

static void recursive_pkey_resolution ( struct GNS_ResolverHandle *  rh, const struct GNUNET_GNSRECORD_Data *  rd  )

static

We found a PKEY record, perform recursive resolution on it.

Parameters

rh	resolution handle
rd	record with PKEY to resolve recursively

Definition at line 1643 of file gnunet-service-gns_resolver.c.

{
  struct AuthorityChain *ac;
  struct GNUNET_IDENTITY_PublicKey auth;
 
  /* delegation to another zone */
  if (GNUNET_OK != GNUNET_GNSRECORD_identity_from_data (rd->data,
                                                        rd->data_size,
                                                        rd->record_type,
                                                        &auth))
  {
    GNUNET_break_op (0);
    fail_resolution (rh);
    return;
  }
  /* expand authority chain */
  ac = GNUNET_new (struct AuthorityChain);
  ac->rh = rh;
  ac->gns_authority = GNUNET_YES;
  ac->authority_info.gns_authority = auth;
  ac->label = resolver_lookup_get_next_label (rh);
  /* add AC to tail */
  GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
                                    rh->ac_tail,
                                    ac);
  /* recurse */
  rh->task_id = GNUNET_SCHEDULER_add_now (&recursive_resolution,
                                          rh);
}

References ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, GNUNET_GNSRECORD_Data::data, GNUNET_GNSRECORD_Data::data_size, fail_resolution(), GNUNET_break_op, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_GNSRECORD_identity_from_data(), GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_YES, rd, GNUNET_GNSRECORD_Data::record_type, recursive_resolution(), resolver_lookup_get_next_label(), and GNS_ResolverHandle::task_id.

Referenced by handle_gns_resolution_result().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_gns2dns_resolution()

static int recursive_gns2dns_resolution ( struct GNS_ResolverHandle *  rh, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

We found one or more GNS2DNS records, perform recursive resolution on it.

(to be precise, one or more records in rd is GNS2DNS, there may be others, so this function still needs to check which ones are GNS2DNS).

Parameters

rh	resolution handle
rd_count	length of the rd array
rd	record with PKEY to resolve recursively

Returns

GNUNET_OK if this worked, GNUNET_SYSERR if no GNS2DNS records were in rd

Records other than GNS2DNS not allowed

Definition at line 1686 of file gnunet-service-gns_resolver.c.

{
  struct AuthorityChain *ac;
  const char *tld;
  char *ns;
 
  ns = NULL;
  /* expand authority chain */
  ac = GNUNET_new (struct AuthorityChain);
  ac->rh = rh;
  ac->authority_info.dns_authority.dns_handle = GNUNET_DNSSTUB_start (4);
 
  for (unsigned int i = 0; i < rd_count; i++)
  {
    char *ip;
    char *n;
    size_t off;
    struct Gns2DnsPending *gp;
    struct GNUNET_IDENTITY_PublicKey zone;
    struct sockaddr_in v4;
    struct sockaddr_in6 v6;
 
    if (GNUNET_GNSRECORD_TYPE_GNS2DNS != rd[i].record_type)
    {
      GNUNET_free (ns);
      GNUNET_free (ac);
      return GNUNET_SYSERR;
    }
    off = 0;
    n = GNUNET_DNSPARSER_parse_name (rd[i].data,
                                     rd[i].data_size,
                                     &off);
    ip = GNUNET_strdup (&((const char *) rd[i].data)[off]);
    if ((NULL == n) ||
        (NULL == ip))
    {
      GNUNET_break_op (0);
      GNUNET_free (n);
      GNUNET_free (ip);
      continue;
    }
 
    off += strlen (ip) + 1;
 
    if (off != rd[i].data_size)
    {
      GNUNET_break_op (0);
      GNUNET_free (n);
      GNUNET_free (ip);
      continue;
    }
    /* resolve 'ip' to determine the IP(s) of the DNS
       resolver to use for lookup of 'ns' */
    if (NULL != ns)
    {
      if (0 != strcasecmp (ns,
                           n))
      {
        /* NS values must all be the same for all GNS2DNS records,
           anything else leads to insanity */
        GNUNET_break_op (0);
        GNUNET_free (n);
        GNUNET_free (ip);
        continue;
      }
      GNUNET_free (n);
    }
    else
    {
      ns = n;
    }
 
    /* check if 'ip' is already an IPv4/IPv6 address */
    if ((1 == inet_pton (AF_INET,
                         ip,
                         &v4)) ||
        (1 == inet_pton (AF_INET6,
                         ip,
                         &v6)))
    {
      GNUNET_break (GNUNET_OK ==
                    GNUNET_DNSSTUB_add_dns_ip (
                      ac->authority_info.dns_authority.dns_handle,
                      ip));
      ac->authority_info.dns_authority.found = GNUNET_YES;
      GNUNET_free (ip);
      continue;
    }
    tld = GNS_get_tld (ip);
    if ((0 != strcmp (tld, "+")) &&
        (GNUNET_OK != GNUNET_GNSRECORD_zkey_to_pkey (tld, &zone)))
    {
      /* 'ip' is a DNS name */
      gp = GNUNET_new (struct Gns2DnsPending);
      gp->ac = ac;
      GNUNET_CONTAINER_DLL_insert (ac->authority_info.dns_authority.gp_head,
                                   ac->authority_info.dns_authority.gp_tail,
                                   gp);
      gp->dns_rh = GNUNET_RESOLVER_ip_get (ip,
                                           AF_UNSPEC,
                                           GNUNET_TIME_UNIT_FOREVER_REL,
                                           &handle_gns2dns_ip,
                                           gp);
      GNUNET_free (ip);
      continue;
    }
    /* 'ip' should be a GNS name */
    gp = GNUNET_new (struct Gns2DnsPending);
    gp->ac = ac;
    GNUNET_CONTAINER_DLL_insert (ac->authority_info.dns_authority.gp_head,
                                 ac->authority_info.dns_authority.gp_tail,
                                 gp);
    gp->rh = GNUNET_new (struct GNS_ResolverHandle);
    if (0 == strcmp (tld, "+"))
    {
      ip = translate_dot_plus (rh,
                               ip);
      tld = GNS_get_tld (ip);
      if (GNUNET_OK !=
          GNUNET_GNSRECORD_zkey_to_pkey (tld,
                                         &zone))
      {
        GNUNET_break_op (0);
        GNUNET_free (ip);
        continue;
      }
    }
    gp->rh->authority_zone = zone;
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Resolving `%s' to determine IP address of DNS server for GNS2DNS transition for `%s'\n",
                ip,
                ns);
    gp->rh->name = ip;
    gp->rh->name_resolution_pos = strlen (ip) - strlen (tld) - 1;
    gp->rh->proc = &handle_gns2dns_result;
    gp->rh->proc_cls = gp;
    gp->rh->record_type = GNUNET_GNSRECORD_TYPE_ANY;
    gp->rh->options = GNUNET_GNS_LO_DEFAULT;
    gp->rh->loop_limiter = rh->loop_limiter + 1;
    gp->rh->loop_threshold = rh->loop_threshold;
    gp->rh->task_id
      = GNUNET_SCHEDULER_add_now (&start_resolver_lookup,
                                  gp->rh);
  }   /* end 'for all records' */
 
  if (NULL == ns)
  {
    /* not a single GNS2DNS record found */
    GNUNET_free (ac);
    return GNUNET_SYSERR;
  }
  GNUNET_assert (strlen (ns) <= GNUNET_DNSPARSER_MAX_NAME_LENGTH);
  strcpy (ac->authority_info.dns_authority.name,
          ns);
  /* for DNS recursion, the label is the full DNS name,
     created from the remainder of the GNS name and the
     name in the NS record */
  GNUNET_asprintf (&ac->label,
                   "%.*s%s%s",
                   (int) rh->name_resolution_pos,
                   rh->name,
                   (0 != rh->name_resolution_pos) ? "." : "",
                   ns);
  GNUNET_free (ns);
 
  {
    /* the GNS name is UTF-8 and may include multibyte chars.
     * We have to convert the combined name to a DNS-compatible IDNA.
     */
    char *tmp = ac->label;
 
    if (IDNA_SUCCESS != idna_to_ascii_8z (tmp,
                                          &ac->label,
                                          IDNA_ALLOW_UNASSIGNED))
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ ("Name `%s' cannot be converted to IDNA."),
                  tmp);
      GNUNET_free (tmp);
      GNUNET_free (ac);
      return GNUNET_SYSERR;
    }
    GNUNET_free (tmp);
  }
 
  GNUNET_CONTAINER_DLL_insert_tail (rh->ac_head,
                                    rh->ac_tail,
                                    ac);
  if (strlen (ac->label) > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("GNS lookup resulted in DNS name that is too long (`%s')\n"),
                ac->label);
    GNUNET_free (ac->label);
    GNUNET_free (ac);
    return GNUNET_SYSERR;
  }
  continue_with_gns2dns (ac);
  return GNUNET_OK;
}

References _, Gns2DnsPending::ac, ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, GNS_ResolverHandle::authority_zone, continue_with_gns2dns(), data, data_size, Gns2DnsPending::dns_rh, GNS_get_tld(), GNUNET_asprintf(), GNUNET_assert, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_DNSPARSER_MAX_NAME_LENGTH, GNUNET_DNSPARSER_parse_name(), GNUNET_DNSSTUB_add_dns_ip(), GNUNET_DNSSTUB_start(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNS_LO_DEFAULT, GNUNET_GNSRECORD_TYPE_ANY, GNUNET_GNSRECORD_TYPE_GNS2DNS, GNUNET_GNSRECORD_zkey_to_pkey(), GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_RESOLVER_ip_get(), GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, handle_gns2dns_ip(), handle_gns2dns_result(), GNS_ResolverHandle::loop_limiter, GNS_ResolverHandle::loop_threshold, GNS_ResolverHandle::name, GNS_ResolverHandle::name_resolution_pos, ns, GNS_ResolverHandle::options, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, rd, rd_count, GNS_ResolverHandle::record_type, Gns2DnsPending::rh, AuthorityChain::rh, start_resolver_lookup(), GNS_ResolverHandle::task_id, translate_dot_plus(), and zone.

Referenced by handle_gns_resolution_result().

Here is the call graph for this function:

Here is the caller graph for this function:

namecache_cache_continuation()

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

static

Function called once the namestore has completed the request for caching a block.

Parameters

cls	closure with the struct CacheOps
success	GNUNET_OK on success
emsg	error message

Definition at line 2336 of file gnunet-service-gns_resolver.c.

{
  struct CacheOps *co = cls;
 
  co->namecache_qe_cache = NULL;
  if (GNUNET_OK != success)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to cache GNS resolution: %s\n"),
                emsg);
  GNUNET_CONTAINER_DLL_remove (co_head,
                               co_tail,
                               co);
  GNUNET_free (co);
}

References _, co_head, co_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_OK, and CacheOps::namecache_qe_cache.

Referenced by handle_dht_response().

Here is the caller graph for this function:

handle_dht_response()

static void handle_dht_response ( void *  cls, struct GNUNET_TIME_Absolute  exp, const struct GNUNET_HashCode *  key, const struct GNUNET_PeerIdentity *  trunc_peer, const struct GNUNET_DHT_PathElement *  get_path, unsigned int  get_path_length, const struct GNUNET_DHT_PathElement *  put_path, unsigned int  put_path_length, enum GNUNET_BLOCK_Type  type, size_t  size, const void *  data  )

static

Iterator called on each result obtained for a DHT operation that expects a reply.

Parameters

cls	closure with the struct GNS_ResolverHandle
exp	when will this value expire
key	key of the result
trunc_peer	truncated peer, NULL if not truncated
get_path	peers on reply path (or NULL if not recorded) [0] = datastore's first neighbor, [length - 1] = local peer
get_path_length	number of entries in get_path
put_path	peers on the PUT path (or NULL if not recorded) [0] = origin, [length - 1] = datastore
put_path_length	number of entries in put_path
type	type of the result
size	number of bytes in data
data	pointer to the result data

Definition at line 2373 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
  struct AuthorityChain *ac = rh->ac_tail;
  const struct GNUNET_GNSRECORD_Block *block;
  struct CacheOps *co;
 
  (void) exp;
  (void) key;
  (void) get_path;
  (void) get_path_length;
  (void) put_path;
  (void) put_path_length;
  (void) type;
  GNUNET_DHT_get_stop (rh->get_handle);
  rh->get_handle = NULL;
  GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
  rh->dht_heap_node = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Handling response from the DHT\n");
  if (size < sizeof(struct GNUNET_GNSRECORD_Block))
  {
    /* how did this pass DHT block validation!? */
    GNUNET_break (0);
    fail_resolution (rh);
    return;
  }
  block = data;
  if (size != GNUNET_GNSRECORD_block_get_size (block))
  {
    /* how did this pass DHT block validation!? */
    GNUNET_break (0);
    fail_resolution (rh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Decrypting DHT block of size %lu for `%s', expires %s\n",
              GNUNET_GNSRECORD_block_get_size (block),
              rh->name,
              GNUNET_STRINGS_absolute_time_to_string (exp));
  if (GNUNET_OK !=
      GNUNET_GNSRECORD_block_decrypt (block,
                                      &ac->authority_info.gns_authority,
                                      ac->label,
                                      &handle_gns_resolution_result,
                                      rh))
  {
    GNUNET_break_op (0);  /* block was ill-formed */
    fail_resolution (rh);
    return;
  }
  if (0 == GNUNET_TIME_absolute_get_remaining (
        GNUNET_GNSRECORD_block_get_expiration (block)).
      rel_value_us)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Received expired block from the DHT, will not cache it.\n");
    return;
  }
  if (GNUNET_YES == disable_cache)
    return;
  /* Cache well-formed blocks */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Caching response from the DHT in namecache\n");
  co = GNUNET_new (struct CacheOps);
  co->namecache_qe_cache = GNUNET_NAMECACHE_block_cache (namecache_handle,
                                                         block,
                                                         &
                                                         namecache_cache_continuation,
                                                         co);
  GNUNET_CONTAINER_DLL_insert (co_head,
                               co_tail,
                               co);
}

References ac, GNS_ResolverHandle::ac_tail, co_head, co_tail, data, GNS_ResolverHandle::dht_heap_node, disable_cache, fail_resolution(), GNS_ResolverHandle::get_handle, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_heap_remove_node(), GNUNET_DHT_get_stop(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_block_decrypt(), GNUNET_GNSRECORD_block_get_expiration(), GNUNET_GNSRECORD_block_get_size(), GNUNET_log, GNUNET_NAMECACHE_block_cache(), GNUNET_new, GNUNET_OK, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, handle_gns_resolution_result(), key, GNS_ResolverHandle::name, namecache_cache_continuation(), namecache_handle, CacheOps::namecache_qe_cache, AuthorityChain::rh, size, and type.

Referenced by start_dht_request().

Here is the call graph for this function:

Here is the caller graph for this function:

start_dht_request()

static void start_dht_request ( struct GNS_ResolverHandle *  rh, const struct GNUNET_HashCode *  query  )

static

Initiate a DHT query for a set of GNS records.

Parameters

rh	resolution handle
query	key to use in the DHT lookup

Definition at line 2466 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rx;
 
  GNUNET_assert (NULL == rh->get_handle);
  rh->get_handle = GNUNET_DHT_get_start (dht_handle,
                                         GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
                                         query,
                                         DHT_GNS_REPLICATION_LEVEL,
                                         GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
                                         NULL, 0,
                                         &handle_dht_response, rh);
  rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
                                                    rh,
                                                    GNUNET_TIME_absolute_get ().
                                                    abs_value_us);
  if (GNUNET_CONTAINER_heap_get_size (dht_lookup_heap) >
      max_allowed_background_queries)
  {
    /* fail longest-standing DHT request */
    rx = GNUNET_CONTAINER_heap_remove_root (dht_lookup_heap);
    rx->dht_heap_node = NULL;
    GNUNET_assert (NULL != rx);
    fail_resolution (rx);
  }
}

References DHT_GNS_REPLICATION_LEVEL, dht_handle, GNS_ResolverHandle::dht_heap_node, dht_lookup_heap, fail_resolution(), GNS_ResolverHandle::get_handle, GNUNET_assert, GNUNET_BLOCK_TYPE_GNS_NAMERECORD, GNUNET_CONTAINER_heap_get_size(), GNUNET_CONTAINER_heap_insert(), GNUNET_CONTAINER_heap_remove_root(), GNUNET_DHT_get_start(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_TIME_absolute_get(), handle_dht_response(), and max_allowed_background_queries.

Referenced by handle_namecache_block_response(), and recursive_gns_resolution_namecache().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_gns_namecache_resolution_result()

static void handle_gns_namecache_resolution_result ( void *  cls, unsigned int  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Process a records that were decrypted from a block that we got from the namecache.

Simply calls handle_gns_resolution_result().

Parameters

cls	closure with the struct GNS_ResolverHandle
rd_count	number of entries in rd array
rd	array of records with data to store

Definition at line 2504 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
 
  if (0 == rd_count)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("GNS namecache returned empty result for `%s'\n"),
                rh->name);
  handle_gns_resolution_result (rh,
                                rd_count,
                                rd);
}

References _, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, handle_gns_resolution_result(), GNS_ResolverHandle::name, rd, and rd_count.

Referenced by handle_namecache_block_response().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_namecache_block_response()

static void handle_namecache_block_response ( void *  cls, const struct GNUNET_GNSRECORD_Block *  block  )

static

Process a record that was stored in the namecache.

Parameters

cls	closure with the struct GNS_ResolverHandle
block	block that was stored in the namecache

Definition at line 2527 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
  struct AuthorityChain *ac = rh->ac_tail;
  const char *label = ac->label;
  const struct GNUNET_IDENTITY_PublicKey *auth =
    &ac->authority_info.gns_authority;
  struct GNUNET_HashCode query;
 
  GNUNET_assert (NULL != rh->namecache_qe);
  rh->namecache_qe = NULL;
  if (NULL == block)
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "No block found\n");
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Got block with expiration %s\n",
                GNUNET_STRINGS_absolute_time_to_string (
                  GNUNET_GNSRECORD_block_get_expiration (block)));
  if (((GNUNET_GNS_LO_DEFAULT == rh->options) ||
       ((GNUNET_GNS_LO_LOCAL_MASTER == rh->options) &&
        (ac != rh->ac_head))) &&
      ((NULL == block) ||
       (0 == GNUNET_TIME_absolute_get_remaining (
          GNUNET_GNSRECORD_block_get_expiration (block)).
        rel_value_us)))
  {
    /* namecache knows nothing; try DHT lookup */
    GNUNET_GNSRECORD_query_from_public_key (auth,
                                            label,
                                            &query);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Starting DHT lookup for `%s' in zone `%s' under key `%s'\n",
                ac->label,
                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority),
                GNUNET_h2s (&query));
    start_dht_request (rh, &query);
    return;
  }
 
  if ((NULL == block) ||
      (0 == GNUNET_TIME_absolute_get_remaining (
         GNUNET_GNSRECORD_block_get_expiration (block)).
       rel_value_us))
  {
    /* DHT not permitted and no local result, fail */
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Resolution failed for `%s' in zone %s (DHT lookup not permitted by configuration)\n",
                ac->label,
                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
    fail_resolution (rh);
    return;
  }
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received result from namecache for label `%s'\n",
              ac->label);
 
  if (GNUNET_OK !=
      GNUNET_GNSRECORD_block_decrypt (block,
                                      auth,
                                      label,
                                      &handle_gns_namecache_resolution_result,
                                      rh))
  {
    GNUNET_break_op (0);  /* block was ill-formed */
    /* try DHT instead */
    GNUNET_GNSRECORD_query_from_public_key (auth,
                                            label,
                                            &query);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Starting DHT lookup for `%s' in zone `%s' under key `%s'\n",
                ac->label,
                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority),
                GNUNET_h2s (&query));
    start_dht_request (rh, &query);
    return;
  }
}

References ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, fail_resolution(), GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNS_LO_DEFAULT, GNUNET_GNS_LO_LOCAL_MASTER, GNUNET_GNSRECORD_block_decrypt(), GNUNET_GNSRECORD_block_get_expiration(), GNUNET_GNSRECORD_query_from_public_key(), GNUNET_GNSRECORD_z2s(), GNUNET_h2s(), GNUNET_log, GNUNET_OK, GNUNET_STRINGS_absolute_time_to_string(), GNUNET_TIME_absolute_get_remaining(), handle_gns_namecache_resolution_result(), AuthorityChain::label, GNS_ResolverHandle::namecache_qe, GNS_ResolverHandle::options, AuthorityChain::rh, and start_dht_request().

Referenced by recursive_gns_resolution_namecache().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_gns_resolution_namecache()

static void recursive_gns_resolution_namecache ( struct GNS_ResolverHandle *  rh )

static

Lookup tail of our authority chain in the namecache.

Parameters

rh	query we are processing

Definition at line 2614 of file gnunet-service-gns_resolver.c.

{
  struct AuthorityChain *ac = rh->ac_tail;
  struct GNUNET_HashCode query;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting GNS resolution for `%s' in zone %s\n",
              ac->label,
              GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
  GNUNET_GNSRECORD_query_from_public_key (&ac->authority_info.gns_authority,
                                          ac->label,
                                          &query);
  if (GNUNET_YES != disable_cache)
  {
    rh->namecache_qe
      = GNUNET_NAMECACHE_lookup_block (namecache_handle,
                                       &query,
                                       &handle_namecache_block_response,
                                       rh);
    GNUNET_assert (NULL != rh->namecache_qe);
  }
  else
  {
    start_dht_request (rh,
                       &query);
  }
}

References ac, GNS_ResolverHandle::ac_tail, disable_cache, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_query_from_public_key(), GNUNET_GNSRECORD_z2s(), GNUNET_log, GNUNET_NAMECACHE_lookup_block(), GNUNET_YES, handle_namecache_block_response(), namecache_handle, GNS_ResolverHandle::namecache_qe, AuthorityChain::rh, and start_dht_request().

Referenced by handle_revocation_result().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_revocation_result()

static void handle_revocation_result ( void *  cls, int  is_valid  )

static

Function called with the result from a revocation check.

Parameters

cls	the struct GNS_ResovlerHandle
is_valid	GNUNET_YES if the zone was not yet revoked

Definition at line 2650 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh = cls;
  struct AuthorityChain *ac = rh->ac_tail;
 
  rh->rev_check = NULL;
  if (GNUNET_YES != is_valid)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Zone %s was revoked, resolution fails\n"),
                GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
    fail_resolution (rh);
    return;
  }
  recursive_gns_resolution_namecache (rh);
}

References _, ac, GNS_ResolverHandle::ac_tail, fail_resolution(), GNUNET_ERROR_TYPE_WARNING, GNUNET_GNSRECORD_z2s(), GNUNET_log, GNUNET_YES, recursive_gns_resolution_namecache(), GNS_ResolverHandle::rev_check, and AuthorityChain::rh.

Referenced by recursive_gns_resolution_revocation().

Here is the call graph for this function:

Here is the caller graph for this function:

recursive_gns_resolution_revocation()

static void recursive_gns_resolution_revocation ( struct GNS_ResolverHandle *  rh )

static

Perform revocation check on tail of our authority chain.

Parameters

rh	query we are processing

Definition at line 2675 of file gnunet-service-gns_resolver.c.

{
  struct AuthorityChain *ac = rh->ac_tail;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting revocation check for zone %s\n",
              GNUNET_GNSRECORD_z2s (&ac->authority_info.gns_authority));
  rh->rev_check = GNUNET_REVOCATION_query (cfg,
                                           &ac->authority_info.gns_authority,
                                           &handle_revocation_result,
                                           rh);
  GNUNET_assert (NULL != rh->rev_check);
}

References ac, GNS_ResolverHandle::ac_tail, cfg, GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_GNSRECORD_z2s(), GNUNET_log, GNUNET_REVOCATION_query(), handle_revocation_result(), GNS_ResolverHandle::rev_check, and AuthorityChain::rh.

Referenced by recursive_resolution().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_resolver_lookup()

struct GNS_ResolverHandle* GNS_resolver_lookup	(	const struct GNUNET_IDENTITY_PublicKey *	zone,
		uint32_t	record_type,
		const char *	name,
		enum GNUNET_GNS_LocalOptions	options,
		uint16_t	recursion_depth_limit,
		GNS_ResultProcessor	proc,
		void *	proc_cls
	)

Lookup of a record in a specific zone calls lookup result processor on result.

Lookup of a record in a specific zone calls RecordLookupProcessor on result or timeout.

Parameters

zone	the zone to perform the lookup in
record_type	the record type to look up
name	the name to look up
options	local options to control local lookup
recursion_depth_limit	how many zones to traverse at most
proc	the processor to call on result
proc_cls	the closure to pass to proc

Returns

handle to cancel operation

Definition at line 2793 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Starting lookup for `%s'\n",
              name);
  rh = GNUNET_new (struct GNS_ResolverHandle);
  GNUNET_CONTAINER_DLL_insert (rlh_head,
                               rlh_tail,
                               rh);
  rh->authority_zone = *zone;
  rh->proc = proc;
  rh->proc_cls = proc_cls;
  rh->options = options;
  rh->record_type = record_type;
  rh->name = GNUNET_strdup (name);
  rh->name_resolution_pos = strlen (name);
  rh->loop_threshold = recursion_depth_limit;
  rh->task_id = GNUNET_SCHEDULER_add_now (&start_resolver_lookup,
                                          rh);
  return rh;
}

References GNS_ResolverHandle::authority_zone, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_SCHEDULER_add_now(), GNUNET_strdup, GNS_ResolverHandle::loop_threshold, name, GNS_ResolverHandle::name, GNS_ResolverHandle::name_resolution_pos, options, GNS_ResolverHandle::options, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, GNS_ResolverHandle::record_type, rlh_head, rlh_tail, start_resolver_lookup(), GNS_ResolverHandle::task_id, and zone.

Referenced by handle_dns_request(), and handle_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_resolver_lookup_cancel()

void GNS_resolver_lookup_cancel

(

struct GNS_ResolverHandle *

rh

)

Cancel active resolution (i.e.

client disconnected).

Parameters

rh	resolution to abort

Definition at line 2830 of file gnunet-service-gns_resolver.c.

{
  struct DnsResult *dr;
  struct AuthorityChain *ac;
 
  GNUNET_CONTAINER_DLL_remove (rlh_head,
                               rlh_tail,
                               rh);
  if (NULL != rh->dns_request)
  {
    GNUNET_DNSSTUB_resolve_cancel (rh->dns_request);
    rh->dns_request = NULL;
  }
  while (NULL != (ac = rh->ac_head))
  {
    GNUNET_CONTAINER_DLL_remove (rh->ac_head,
                                 rh->ac_tail,
                                 ac);
    if (GNUNET_NO == ac->gns_authority)
    {
      struct Gns2DnsPending *gp;
 
      while (NULL != (gp = ac->authority_info.dns_authority.gp_head))
      {
        GNUNET_CONTAINER_DLL_remove (ac->authority_info.dns_authority.gp_head,
                                     ac->authority_info.dns_authority.gp_tail,
                                     gp);
        if (NULL != gp->rh)
        {
          /* rh->g2dc->rh is NOT in the DLL yet, so to enable us
             using GNS_resolver_lookup_cancel here, we need to
             add it first... */
          GNUNET_CONTAINER_DLL_insert (rlh_head,
                                       rlh_tail,
                                       gp->rh);
          GNUNET_assert (NULL == gp->rh->task_id);
          gp->rh->task_id = GNUNET_SCHEDULER_add_now (
            &GNS_resolver_lookup_cancel_,
            gp->rh);
          gp->rh = NULL;
        }
        if (NULL != gp->dns_rh)
        {
          GNUNET_RESOLVER_request_cancel (gp->dns_rh);
          gp->dns_rh = NULL;
        }
        GNUNET_free (gp);
      }
      GNUNET_DNSSTUB_stop (ac->authority_info.dns_authority.dns_handle);
    }
    GNUNET_free (ac->label);
    GNUNET_free (ac);
  }
  if (NULL != rh->task_id)
  {
    GNUNET_SCHEDULER_cancel (rh->task_id);
    rh->task_id = NULL;
  }
  if (NULL != rh->get_handle)
  {
    GNUNET_DHT_get_stop (rh->get_handle);
    rh->get_handle = NULL;
  }
  if (NULL != rh->dht_heap_node)
  {
    GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
    rh->dht_heap_node = NULL;
  }
  if (NULL != rh->namecache_qe)
  {
    GNUNET_NAMECACHE_cancel (rh->namecache_qe);
    rh->namecache_qe = NULL;
  }
  if (NULL != rh->rev_check)
  {
    GNUNET_REVOCATION_query_cancel (rh->rev_check);
    rh->rev_check = NULL;
  }
  if (NULL != rh->std_resolve)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Canceling standard DNS resolution\n");
    GNUNET_RESOLVER_request_cancel (rh->std_resolve);
    rh->std_resolve = NULL;
  }
  while (NULL != (dr = rh->dns_result_head))
  {
    GNUNET_CONTAINER_DLL_remove (rh->dns_result_head,
                                 rh->dns_result_tail,
                                 dr);
    GNUNET_free (dr);
  }
  GNUNET_free (rh->leho);
  GNUNET_free (rh->name);
  GNUNET_free (rh);
}

References ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, GNS_ResolverHandle::dht_heap_node, GNS_ResolverHandle::dns_request, GNS_ResolverHandle::dns_result_head, GNS_ResolverHandle::dns_result_tail, Gns2DnsPending::dns_rh, GNS_ResolverHandle::get_handle, GNS_resolver_lookup_cancel_(), GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_remove_node(), GNUNET_DHT_get_stop(), GNUNET_DNSSTUB_resolve_cancel(), GNUNET_DNSSTUB_stop(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAMECACHE_cancel(), GNUNET_NO, GNUNET_RESOLVER_request_cancel(), GNUNET_REVOCATION_query_cancel(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNS_ResolverHandle::leho, GNS_ResolverHandle::name, GNS_ResolverHandle::namecache_qe, GNS_ResolverHandle::rev_check, Gns2DnsPending::rh, AuthorityChain::rh, rlh_head, rlh_tail, GNS_ResolverHandle::std_resolve, and GNS_ResolverHandle::task_id.

Referenced by client_disconnect_cb(), GNS_interceptor_done(), GNS_resolver_done(), GNS_resolver_lookup_cancel_(), and transmit_lookup_dns_result().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_resolver_init()

void GNS_resolver_init	(	struct GNUNET_NAMECACHE_Handle *	nc,
		struct GNUNET_DHT_Handle *	dht,
		const struct GNUNET_CONFIGURATION_Handle *	c,
		unsigned long long	max_bg_queries
	)

Initialize the resolver.

Initialize the resolver subsystem.

Parameters

nc	the namecache handle
dht	the dht handle
c	configuration handle
max_bg_queries	maximum number of parallel background queries in dht

Definition at line 2940 of file gnunet-service-gns_resolver.c.

{
  cfg = c;
  namecache_handle = nc;
  dht_handle = dht;
  dht_lookup_heap =
    GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
  max_allowed_background_queries = max_bg_queries;
  disable_cache = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                        "namecache",
                                                        "DISABLE");
  if (GNUNET_YES == disable_cache)
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Namecache disabled\n");
}

References cfg, dht, dht_handle, dht_lookup_heap, disable_cache, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_YES, max_allowed_background_queries, namecache_handle, and nc.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_resolver_done()

void GNS_resolver_done

(

void

)

Shutdown resolver.

Cleanup resolver: Terminate pending lookups.

Definition at line 2964 of file gnunet-service-gns_resolver.c.

{
  struct GNS_ResolverHandle *rh;
  struct CacheOps *co;
 
  /* abort active resolutions */
  while (NULL != (rh = rlh_head))
  {
    rh->proc (rh->proc_cls,
              0,
              NULL);
    GNS_resolver_lookup_cancel (rh);
  }
  while (NULL != (co = co_head))
  {
    GNUNET_CONTAINER_DLL_remove (co_head,
                                 co_tail,
                                 co);
    GNUNET_NAMECACHE_cancel (co->namecache_qe_cache);
    GNUNET_free (co);
  }
  GNUNET_CONTAINER_heap_destroy (dht_lookup_heap);
  dht_lookup_heap = NULL;
  dht_handle = NULL;
  namecache_handle = NULL;
}

References co_head, co_tail, dht_handle, dht_lookup_heap, GNS_resolver_lookup_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_destroy(), GNUNET_free, GNUNET_NAMECACHE_cancel(), namecache_handle, CacheOps::namecache_qe_cache, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, and rlh_head.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

namecache_handle

struct GNUNET_NAMECACHE_Handle* namecache_handle

static

Our handle to the namecache service.

Definition at line 418 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_done(), GNS_resolver_init(), handle_dht_response(), and recursive_gns_resolution_namecache().

dht_handle

struct GNUNET_DHT_Handle* dht_handle

static

Resolver handle to the dht.

Definition at line 423 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_done(), GNS_resolver_init(), and start_dht_request().

dht_lookup_heap

struct GNUNET_CONTAINER_Heap* dht_lookup_heap

static

Heap for limiting parallel DHT lookups.

Definition at line 428 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_done(), GNS_resolver_init(), and start_dht_request().

max_allowed_background_queries

unsigned long long max_allowed_background_queries

static

Maximum amount of parallel queries to the DHT.

Definition at line 433 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_init(), and start_dht_request().

rlh_head

struct GNS_ResolverHandle* rlh_head

static

Head of resolver lookup list.

Definition at line 438 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_done(), GNS_resolver_lookup(), GNS_resolver_lookup_cancel(), and handle_gns2dns_result().

rlh_tail

struct GNS_ResolverHandle* rlh_tail

static

Tail of resolver lookup list.

Definition at line 443 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_lookup(), GNS_resolver_lookup_cancel(), and handle_gns2dns_result().

co_head

struct CacheOps* co_head

static

Organized in a DLL.

Definition at line 448 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_done(), handle_dht_response(), and namecache_cache_continuation().

co_tail

struct CacheOps* co_tail

static

Organized in a DLL.

Definition at line 453 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_done(), handle_dht_response(), and namecache_cache_continuation().

disable_cache

int disable_cache

static

Use namecache.

Definition at line 458 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_init(), handle_dht_response(), and recursive_gns_resolution_namecache().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Global configuration.

Definition at line 463 of file gnunet-service-gns_resolver.c.

Referenced by GNS_resolver_init(), and recursive_gns_resolution_revocation().