Resolver service

Asynchronous standard DNS lookups. More...

Collaboration diagram for Resolver service:

Typedefs
typedef void(*	GNUNET_RESOLVER_AddressCallback) (void *cls, const struct sockaddr *addr, socklen_t addrlen)
	Function called by the resolver for each address obtained from DNS. More...
typedef void(*	GNUNET_RESOLVER_HostnameCallback) (void *cls, const char *hostname)
	Function called by the resolver for each hostname obtained from DNS. More...

Functions
void	GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Create the connection to the resolver service. More...
void	GNUNET_RESOLVER_disconnect (void)
	Destroy the connection to the resolver service. More...
struct GNUNET_RESOLVER_RequestHandle *	GNUNET_RESOLVER_ip_get (const char *hostname, int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *callback_cls)
	Convert a string to one or more IP addresses. More...
struct GNUNET_RESOLVER_RequestHandle *	GNUNET_RESOLVER_hostname_resolve (int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *cls)
	Resolve our hostname to an IP address. More...
char *	GNUNET_RESOLVER_local_fqdn_get (void)
	Get local fully qualified domain name. More...
struct GNUNET_RESOLVER_RequestHandle *	GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen, int do_resolve, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_HostnameCallback callback, void *cls)
	Perform a reverse DNS lookup. More...
void	GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
	Cancel a request that is still pending with the resolver. More...

Detailed Description

Asynchronous standard DNS lookups.

Typedef Documentation

GNUNET_RESOLVER_AddressCallback

typedef void(* GNUNET_RESOLVER_AddressCallback) (void *cls, const struct sockaddr *addr, socklen_t addrlen)

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

Parameters

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

Definition at line 59 of file gnunet_resolver_service.h.

GNUNET_RESOLVER_HostnameCallback

typedef void(* GNUNET_RESOLVER_HostnameCallback) (void *cls, const char *hostname)

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

Parameters

cls	closure
hostname	one of the names for the host, NULL on the last call to the callback

Definition at line 128 of file gnunet_resolver_service.h.

Function Documentation

GNUNET_RESOLVER_connect()

void GNUNET_RESOLVER_connect

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Create the connection to the resolver service.

Parameters

cfg	configuration to use

Definition at line 258 of file resolver_api.c.

{
  GNUNET_assert (NULL != cfg);
  backoff = GNUNET_TIME_UNIT_MILLISECONDS;
  resolver_cfg = cfg;
}

References backoff, cfg, GNUNET_assert, GNUNET_TIME_UNIT_MILLISECONDS, and resolver_cfg.

Referenced by GNUNET_SERVICE_run_(), program_main(), reversal_test(), and service_task().

Here is the caller graph for this function:

GNUNET_RESOLVER_disconnect()

void GNUNET_RESOLVER_disconnect

(

void

)

Destroy the connection to the resolver service.

Definition at line 270 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh;
 
  while (NULL != (rh = req_head))
  {
    GNUNET_assert (GNUNET_SYSERR == rh->was_transmitted);
    GNUNET_CONTAINER_DLL_remove (req_head,
                                 req_tail,
                                 rh);
    GNUNET_free (rh);
  }
  if (NULL != mq)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Disconnecting from DNS service\n");
    GNUNET_MQ_destroy (mq);
    mq = NULL;
  }
  if (NULL != r_task)
  {
    GNUNET_SCHEDULER_cancel (r_task);
    r_task = NULL;
  }
  if (NULL != s_task)
  {
    GNUNET_SCHEDULER_cancel (s_task);
    s_task = NULL;
  }
}

References GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, LOG, mq, r_task, req_head, req_tail, s_task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RESOLVER_ip_get()

struct GNUNET_RESOLVER_RequestHandle* GNUNET_RESOLVER_ip_get	(	const char *	hostname,
		int	af,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_RESOLVER_AddressCallback	callback,
		void *	callback_cls
	)

Convert a string to one or more IP addresses.

Parameters

hostname	the hostname to resolve
af	AF_INET or AF_INET6; use AF_UNSPEC for "any"
callback	function to call with addresses
callback_cls	closure for callback
timeout	how long to try resolving

Returns

handle that can be used to cancel the request, NULL on error

Definition at line 940 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh;
  size_t slen;
  struct in_addr v4;
  struct in6_addr v6;
 
  slen = strlen (hostname) + 1;
  if (slen + sizeof(struct GNUNET_RESOLVER_GetMessage) >=
      GNUNET_MAX_MESSAGE_SIZE)
  {
    GNUNET_break (0);
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Trying to resolve hostname `%s'.\n",
       hostname);
  rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + slen);
  rh->af = af;
  rh->id = ++last_request_id;
  rh->addr_callback = callback;
  rh->cls = callback_cls;
  GNUNET_memcpy (&rh[1],
                 hostname,
                 slen);
  rh->data_len = slen;
  rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
  rh->direction = GNUNET_NO;
  /* first, check if this is a numeric address */
  if (((1 == inet_pton (AF_INET,
                        hostname,
                        &v4)) &&
       ((af == AF_INET) ||
        (af == AF_UNSPEC))) ||
      ((1 == inet_pton (AF_INET6,
                        hostname,
                        &v6)) &&
       ((af == AF_INET6) ||
        (af == AF_UNSPEC))))
  {
    rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution,
                                         rh);
    return rh;
  }
  /* then, check if this is a loopback address */
  for (unsigned int i = 0;
       NULL != loopback[i];
       i++)
    if (0 == strcasecmp (loopback[i],
                         hostname))
    {
      rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution,
                                           rh);
      return rh;
    }
  if (GNUNET_OK != check_config ())
  {
    GNUNET_free (rh);
    return NULL;
  }
  rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
                                           &handle_lookup_timeout,
                                           rh);
  GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                    req_tail,
                                    rh);
  rh->was_queued = GNUNET_YES;
  if (NULL != s_task)
  {
    GNUNET_SCHEDULER_cancel (s_task);
    s_task = NULL;
  }
  process_requests ();
  return rh;
}

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, check_config(), GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_RESOLVER_RequestHandle::direction, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_malloc, GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, handle_lookup_timeout(), hostname, GNUNET_RESOLVER_RequestHandle::id, last_request_id, LOG, loopback, loopback_resolution(), numeric_resolution(), process_requests(), req_head, req_tail, s_task, GNUNET_RESOLVER_RequestHandle::task, timeout, GNUNET_RESOLVER_RequestHandle::timeout, and GNUNET_RESOLVER_RequestHandle::was_queued.

Referenced by dns_result_parser(), dyndns_lookup(), GNUNET_CONNECTION_create_from_connect(), GNUNET_NAT_stun_make_request(), GNUNET_RESOLVER_hostname_resolve(), handle_gns_cname_result(), handle_gns_redirect_result(), http_common_dns_ip_lookup(), recursive_gns2dns_resolution(), run(), and start_connect().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RESOLVER_hostname_resolve()

struct GNUNET_RESOLVER_RequestHandle* GNUNET_RESOLVER_hostname_resolve	(	int	af,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_RESOLVER_AddressCallback	callback,
		void *	cls
	)

Resolve our hostname to an IP address.

Parameters

af	AF_INET or AF_INET6; use AF_UNSPEC for "any"
callback	function to call with addresses
cls	closure for callback
timeout	how long to try resolving

Returns

handle that can be used to cancel the request, NULL on error

Resolve our hostname to an IP address.

Parameters

af	AF_INET or AF_INET6; use AF_UNSPEC for "any"
timeout	how long to try resolving
callback	function to call with addresses
cls	closure for callback

Returns

handle that can be used to cancel the request, NULL on error

Definition at line 1235 of file resolver_api.c.

{
  char hostname[GNUNET_OS_get_hostname_max_length () + 1];
 
  if (0 != gethostname (hostname, sizeof(hostname) - 1))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                  "gethostname");
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Resolving our hostname `%s'\n",
       hostname);
  return GNUNET_RESOLVER_ip_get (hostname,
                                 af,
                                 timeout,
                                 callback,
                                 cls);
}

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OS_get_hostname_max_length, GNUNET_RESOLVER_ip_get(), hostname, LOG, LOG_STRERROR, and timeout.

Here is the call graph for this function:

GNUNET_RESOLVER_local_fqdn_get()

char* GNUNET_RESOLVER_local_fqdn_get

(

void

)

Get local fully qualified domain name.

Returns

local hostname, caller must free

Get local fully qualified domain name.

Returns

fqdn

Definition at line 1149 of file resolver_api.c.

{
  char hostname[GNUNET_OS_get_hostname_max_length () + 1];
 
  if (0 != gethostname (hostname,
                        sizeof(hostname) - 1))
  {
    LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
                  "gethostname");
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Resolving our FQDN `%s'\n",
       hostname);
#if HAVE_GETADDRINFO
  {
    struct addrinfo *ai;
    int ret;
    char *rval;
 
    if (0 != (ret = getaddrinfo (hostname,
                                 NULL,
                                 NULL,
                                 &ai)))
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Could not resolve our FQDN: %s\n"),
           gai_strerror (ret));
      return NULL;
    }
    if (NULL != ai->ai_canonname)
      rval = GNUNET_strdup (ai->ai_canonname);
    else
      rval = GNUNET_strdup (hostname);
    freeaddrinfo (ai);
    return rval;
  }
#elif HAVE_GETHOSTBYNAME2
  {
    struct hostent *host;
 
    host = gethostbyname2 (hostname,
                           AF_INET);
    if (NULL == host)
      host = gethostbyname2 (hostname,
                             AF_INET6);
    if (NULL == host)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Could not resolve our FQDN: %s\n"),
           hstrerror (h_errno));
      return NULL;
    }
    return GNUNET_strdup (host->h_name);
  }
#elif HAVE_GETHOSTBYNAME
  {
    struct hostent *host;
 
    host = gethostbyname (hostname);
    if (NULL == host)
    {
      LOG (GNUNET_ERROR_TYPE_ERROR,
           _ ("Could not resolve our FQDN: %s\n"),
           hstrerror (h_errno));
      return NULL;
    }
    return GNUNET_strdup (host->h_name);
  }
#else
  /* fallback: just hope name is already FQDN */
  return GNUNET_strdup (hostname);
#endif
}

References _, ai, GNUNET_ERROR_TYPE_BULK, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_OS_get_hostname_max_length, GNUNET_strdup, hostname, LOG, LOG_STRERROR, and ret.

Referenced by GNUNET_HOSTLIST_server_start().

Here is the caller graph for this function:

GNUNET_RESOLVER_hostname_get()

struct GNUNET_RESOLVER_RequestHandle* GNUNET_RESOLVER_hostname_get	(	const struct sockaddr *	sa,
		socklen_t	salen,
		int	do_resolve,
		struct GNUNET_TIME_Relative	timeout,
		GNUNET_RESOLVER_HostnameCallback	callback,
		void *	cls
	)

Perform a reverse DNS lookup.

Parameters

sa	host address
salen	length of sa
do_resolve	use GNUNET_NO to return numeric hostname
timeout	how long to try resolving
callback	function to call with hostnames
cls	closure for callback

Returns

handle that can be used to cancel the request, NULL on error

Perform a reverse DNS lookup.

Parameters

sa	host address
salen	length of host address in sa
do_resolve	use GNUNET_NO to return numeric hostname
timeout	how long to try resolving
callback	function to call with hostnames last callback is NULL when finished
cls	closure for callback

Returns

handle that can be used to cancel the request

Definition at line 1072 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh;
  size_t ip_len;
  const void *ip;
 
  if (GNUNET_OK != check_config ())
  {
    LOG (GNUNET_ERROR_TYPE_ERROR,
         _ ("Resolver not configured correctly.\n"));
    return NULL;
  }
 
  switch (sa->sa_family)
  {
  case AF_INET:
    GNUNET_assert (salen == sizeof(struct sockaddr_in));
    ip_len = sizeof(struct in_addr);
    ip = &((const struct sockaddr_in*) sa)->sin_addr;
    break;
 
  case AF_INET6:
    GNUNET_assert (salen == sizeof(struct sockaddr_in6));
    ip_len = sizeof(struct in6_addr);
    ip = &((const struct sockaddr_in6*) sa)->sin6_addr;
    break;
 
  default:
    GNUNET_break (0);
    return NULL;
  }
  rh = GNUNET_malloc (sizeof(struct GNUNET_RESOLVER_RequestHandle) + salen);
  rh->name_callback = callback;
  rh->cls = cls;
  rh->af = sa->sa_family;
  rh->id = ++last_request_id;
  rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
  GNUNET_memcpy (&rh[1],
                 ip,
                 ip_len);
  rh->data_len = ip_len;
  rh->direction = GNUNET_YES;
  rh->received_response = GNUNET_NO;
  if (GNUNET_NO == do_resolve)
  {
    rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse,
                                         rh);
    return rh;
  }
  rh->task = GNUNET_SCHEDULER_add_delayed (timeout,
                                           &handle_lookup_timeout,
                                           rh);
  GNUNET_CONTAINER_DLL_insert_tail (req_head,
                                    req_tail,
                                    rh);
  rh->was_queued = GNUNET_YES;
  if (NULL != s_task)
  {
    GNUNET_SCHEDULER_cancel (s_task);
    s_task = NULL;
  }
  process_requests ();
  return rh;
}

References _, GNUNET_RESOLVER_RequestHandle::af, check_config(), GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_RESOLVER_RequestHandle::direction, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_ERROR_TYPE_ERROR, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_to_absolute(), GNUNET_YES, handle_lookup_timeout(), GNUNET_RESOLVER_RequestHandle::id, last_request_id, LOG, GNUNET_RESOLVER_RequestHandle::name_callback, numeric_reverse(), process_requests(), GNUNET_RESOLVER_RequestHandle::received_response, req_head, req_tail, s_task, GNUNET_RESOLVER_RequestHandle::task, timeout, GNUNET_RESOLVER_RequestHandle::timeout, and GNUNET_RESOLVER_RequestHandle::was_queued.

Referenced by http_common_dns_reverse_lookup(), run(), tcp_plugin_address_pretty_printer(), and udp_plugin_address_pretty_printer().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_RESOLVER_request_cancel()

void GNUNET_RESOLVER_request_cancel

(

struct GNUNET_RESOLVER_RequestHandle *

rh

)

Cancel a request that is still pending with the resolver.

Note that a client MUST NOT cancel a request that has been completed (i.e, the callback has been called to signal timeout or the final result).

Parameters

rh	handle of request to cancel

Definition at line 1268 of file resolver_api.c.

{
  if (GNUNET_NO == rh->direction)
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Asked to cancel request to resolve hostname `%s'.\n",
         (const char *) &rh[1]);
  if (NULL != rh->task)
  {
    GNUNET_SCHEDULER_cancel (rh->task);
    rh->task = NULL;
  }
  if (GNUNET_NO == rh->was_transmitted)
  {
    if (GNUNET_YES == rh->was_queued)
      GNUNET_CONTAINER_DLL_remove (req_head,
                                   req_tail,
                                   rh);
    GNUNET_free (rh);
    check_disconnect ();
    return;
  }
  GNUNET_assert (GNUNET_YES == rh->was_transmitted);
  rh->was_transmitted = GNUNET_SYSERR;  /* mark as cancelled */
  check_disconnect ();
}

References check_disconnect(), GNUNET_RESOLVER_RequestHandle::direction, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_YES, LOG, req_head, req_tail, GNUNET_RESOLVER_RequestHandle::task, GNUNET_RESOLVER_RequestHandle::was_queued, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by client_disconnect_cb(), connection_client_destroy_impl(), dns_result_parser(), do_shutdown(), GNS_resolver_lookup_cancel(), GNUNET_CONNECTION_destroy(), GNUNET_NAT_stun_make_request_cancel(), handle_gns_redirect_result(), handle_lookup_timeout(), handle_response(), init_socket(), libgnunet_plugin_transport_tcp_done(), and nat_register().

Here is the call graph for this function:

Here is the caller graph for this function: