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_CRYPTO_EcdsaPublicKey *zone, uint32_t record_type, const char *name, enum GNUNET_GNS_LocalOptions options, 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 69 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 2886 of file gnunet-service-gns_resolver.c.

References dht, disable_cache, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONTAINER_heap_create(), GNUNET_CONTAINER_HEAP_ORDER_MIN, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_VPN_connect(), GNUNET_YES, max_allowed_background_queries, and nc.

Referenced by run().

{
  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");
  vpn_handle = GNUNET_VPN_connect(cfg);
}

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 2911 of file gnunet-service-gns_resolver.c.

References GNS_resolver_lookup_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_CONTAINER_heap_destroy(), GNUNET_free, GNUNET_NAMECACHE_cancel(), GNUNET_VPN_disconnect(), CacheOps::namecache_qe_cache, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, and Gns2DnsPending::rh.

Referenced by shutdown_task().

{
  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;
  GNUNET_VPN_disconnect(vpn_handle);
  vpn_handle = NULL;
  dht_handle = NULL;
  namecache_handle = NULL;
}

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_CRYPTO_EcdsaPublicKey *	zone,
		uint32_t	record_type,
		const char *	name,
		enum GNUNET_GNS_LocalOptions	options,
		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
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
proc	the processor to call on result
proc_cls	the closure to pass to proc

Returns

handle to cancel operation

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

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::name, GNS_ResolverHandle::name_resolution_pos, options, GNS_ResolverHandle::options, GNS_ResolverHandle::proc, GNS_ResolverHandle::proc_cls, GNS_ResolverHandle::record_type, Gns2DnsPending::rh, start_resolver_lookup(), GNS_ResolverHandle::task_id, and zone.

Referenced by handle_dns_request(), and handle_lookup().

{
  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->task_id = GNUNET_SCHEDULER_add_now(&start_resolver_lookup,
                                         rh);
  return rh;
}

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 2770 of file gnunet-service-gns_resolver.c.

References Gns2DnsPending::ac, GNS_ResolverHandle::ac_head, GNS_ResolverHandle::ac_tail, AuthorityChain::authority_info, GNS_ResolverHandle::dht_heap_node, AuthorityChain::dns_authority, GNS_ResolverHandle::dns_request, GNS_ResolverHandle::dns_result_head, GNS_ResolverHandle::dns_result_tail, Gns2DnsPending::dns_rh, GNS_ResolverHandle::get_handle, AuthorityChain::gns_authority, 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_free_non_null, GNUNET_log, GNUNET_NAMECACHE_cancel(), GNUNET_NO, GNUNET_RESOLVER_request_cancel(), GNUNET_REVOCATION_query_cancel(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_VPN_cancel_request(), AuthorityChain::label, GNS_ResolverHandle::leho, GNS_ResolverHandle::name, GNS_ResolverHandle::namecache_qe, VpnContext::rd_data, GNS_ResolverHandle::rev_check, Gns2DnsPending::rh, GNS_ResolverHandle::std_resolve, GNS_ResolverHandle::task_id, GNS_ResolverHandle::vpn_ctx, and VpnContext::vpn_request.

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

{
  struct DnsResult *dr;
  struct AuthorityChain *ac;
  struct VpnContext *vpn_ctx;

  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 != (vpn_ctx = rh->vpn_ctx))
    {
      GNUNET_VPN_cancel_request(vpn_ctx->vpn_request);
      GNUNET_free(vpn_ctx->rd_data);
      GNUNET_free(vpn_ctx);
    }
  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_non_null(rh->leho);
  GNUNET_free(rh->name);
  GNUNET_free(rh);
}

Here is the call graph for this function:

Here is the caller graph for this function: