gnunet-service-gns_resolver.h File Reference

GNUnet GNS service. More...

#include "gns.h"
#include "gnunet_dht_service.h"
#include "gnunet_gns_service.h"
#include "gnunet_namecache_service.h"

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

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef void(*	GNS_ResultProcessor) (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Function called with results for a GNS resolution. More...

Functions
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 subsystem. More...
void	GNS_resolver_done (void)
	Cleanup resolver: Terminate pending lookups. 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 RecordLookupProcessor on result or timeout. More...
void	GNS_resolver_lookup_cancel (struct GNS_ResolverHandle *rh)
	Cancel active resolution (i.e. More...

Detailed Description

GNUnet GNS service.

Author

Martin Schanzenbach

Definition in file gnunet-service-gns_resolver.h.

Typedef Documentation

GNS_ResultProcessor

typedef void(* GNS_ResultProcessor) (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)

Function called with results for a GNS resolution.

Parameters

cls	closure
rd_count	number of records in rd
rd	records returned for the lookup

Definition at line 68 of file gnunet-service-gns_resolver.h.

Function Documentation

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

MUST be called before GNS_resolver_lookup.

Parameters

nc	the namecache handle
dht	handle to the dht
c	configuration handle
max_bg_queries	maximum amount of background queries

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

)

Cleanup resolver: Terminate pending lookups.

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:

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 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	options set to control local lookup
recursion_depth_limit	how many zones to traverse at most
proc	the processor to call
proc_cls	the closure to pass to proc

Returns

handle to cancel operation

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: