resolver_api.c File Reference

resolver for writing a tool More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_resolver_service.h"
#include "resolver.h"

Include dependency graph for resolver_api.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_RESOLVER_RequestHandle
	Handle to a request given to the resolver. More...

Macros
#define	LOG(kind, ...)   GNUNET_log_from (kind, "util-resolver-api", __VA_ARGS__)
#define	LOG_STRERROR(kind, syscall)
#define	MAX_HOSTNAME   1024
	Maximum supported length for a hostname.

Functions
static int	check_config ()
	Check that the resolver service runs on localhost (or equivalent).
void	GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Create the connection to the resolver service.
void	GNUNET_RESOLVER_disconnect ()
	Destroy the connection to the resolver service.
static void	shutdown_task (void *cls)
	Task executed on system shutdown.
static void	check_disconnect ()
	Consider disconnecting if we have no further requests pending.
static char *	no_resolve (int af, const void *ip, socklen_t ip_len)
	Convert IP address to string without DNS resolution.
static void	reconnect (void)
	Adjust exponential back-off and reconnect to the service.
static void	mq_error_handler (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.
static void	process_requests ()
	Process pending requests to the resolver.
static int	check_response (void *cls, const struct GNUNET_RESOLVER_ResponseMessage *msg)
	Check validity of response with a hostname for a DNS lookup.
static void	handle_response (void *cls, const struct GNUNET_RESOLVER_ResponseMessage *msg)
	Check validity of response with a hostname for a DNS lookup.
static void	numeric_resolution (void *cls)
	We've been asked to lookup the address for a hostname and were given a valid numeric string.
static void	loopback_resolution (void *cls)
	We've been asked to lookup the address for a hostname and were given a variant of "loopback".
static void	reconnect_task (void *cls)
	Now try to reconnect to the resolver service.
static void	handle_lookup_timeout (void *cls)
	A DNS resolution timed out.
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.
static void	numeric_reverse (void *cls)
	We've been asked to convert an address to a string without a reverse lookup, either because the client asked for it or because the DNS lookup hit a timeout.
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)
	Get an IP address as a string.
char *	GNUNET_RESOLVER_local_fqdn_get ()
	Get local fully qualified af name.
struct GNUNET_RESOLVER_RequestHandle *	GNUNET_RESOLVER_hostname_resolve (int af, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_AddressCallback callback, void *cls)
	Looking our own hostname.
void	GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
	Cancel a request that is still pending with the resolver.

Variables
static const char *	loopback []
	Possible hostnames for "loopback".
static const struct GNUNET_CONFIGURATION_Handle *	resolver_cfg
	Configuration.
static struct GNUNET_MQ_Handle *	mq
	Our connection to the resolver service, created on-demand, but then persists until error or shutdown.
static struct GNUNET_RESOLVER_RequestHandle *	req_head
	Head of DLL of requests.
static struct GNUNET_RESOLVER_RequestHandle *	req_tail
	Tail of DLL of requests.
static uint32_t	last_request_id
	ID of the last request we sent to the service.
static struct GNUNET_TIME_Relative	backoff
	How long should we wait to reconnect?
static struct GNUNET_SCHEDULER_Task *	r_task
	Task for reconnecting.
static struct GNUNET_SCHEDULER_Task *	s_task
	Task ID of shutdown task; only present while we have a connection to the resolver service.

Detailed Description

resolver for writing a tool

Author

Christian Grothoff

Definition in file resolver_api.c.

Macro Definition Documentation

LOG

#define LOG	(		kind,
			...
	)		GNUNET_log_from (kind, "util-resolver-api", __VA_ARGS__)

Definition at line 33 of file resolver_api.c.

LOG_STRERROR

#define LOG_STRERROR	(		kind,
			syscall
	)

Value:

                                                              GNUNET_log_from_strerror (kind, \
                                                              "util-resolver-api", \
                                                              syscall)

Definition at line 35 of file resolver_api.c.

                                {
  "localhost",
  "ip6-localnet",
  NULL
};
 
 
static const struct GNUNET_CONFIGURATION_Handle *resolver_cfg;
 
static struct GNUNET_MQ_Handle *mq;
 
static struct GNUNET_RESOLVER_RequestHandle *req_head;
 
static struct GNUNET_RESOLVER_RequestHandle *req_tail;
 
static uint32_t last_request_id;
 
static struct GNUNET_TIME_Relative backoff;
 
static struct GNUNET_SCHEDULER_Task *r_task;
 
static struct GNUNET_SCHEDULER_Task *s_task;
 
 
struct GNUNET_RESOLVER_RequestHandle
{
  struct GNUNET_RESOLVER_RequestHandle *next;
 
  struct GNUNET_RESOLVER_RequestHandle *prev;
 
  GNUNET_RESOLVER_AddressCallback addr_callback;
 
  GNUNET_RESOLVER_HostnameCallback name_callback;
 
  void *cls;
 
  struct GNUNET_TIME_Absolute timeout;
 
  struct GNUNET_SCHEDULER_Task *task;
 
  int af;
 
  uint32_t id;
 
  int was_transmitted;
 
  int was_queued;
 
  int direction;
 
  int received_response;
 
  size_t data_len;
};
 
 
static int
check_config ()
{
  char *hostname;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_have_value (resolver_cfg,
                                       "resolver",
                                       "UNIXPATH"))
    return GNUNET_OK;
  memset (&v4, 0, sizeof(v4));
  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
  v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v4.sin_len = sizeof(v4);
#endif
  memset (&v6, 0, sizeof(v6));
  v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v6.sin6_len = sizeof(v6);
#endif
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (resolver_cfg,
                                             "resolver",
                                             "HOSTNAME",
                                             &hostname))
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         _ (
           "Missing `%s' for `%s' in configuration, DNS resolution will be unavailable.\n"),
         "HOSTNAME",
         "resolver");
    return GNUNET_SYSERR;
  }
  if ((1 == inet_pton (AF_INET, hostname, &v4)) ||
      (1 == inet_pton (AF_INET6, hostname, &v6)))
  {
    GNUNET_free (hostname);
    return GNUNET_OK;
  }
  for (unsigned int i = 0;
       NULL != loopback[i];
       i++)
    if (0 == strcasecmp (loopback[i],
                         hostname))
    {
      GNUNET_free (hostname);
      return GNUNET_OK;
    }
  LOG (GNUNET_ERROR_TYPE_INFO,
       _ (
         "Missing `%s' or numeric IP address for `%s' of `%s' in configuration, DNS resolution will be unavailable.\n"),
       "localhost",
       "HOSTNAME",
       "resolver");
  GNUNET_free (hostname);
  return GNUNET_SYSERR;
}
 
 
void
GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
  GNUNET_assert (NULL != cfg);
  backoff = GNUNET_TIME_UNIT_MILLISECONDS;
  resolver_cfg = cfg;
}
 
 
void
GNUNET_RESOLVER_disconnect ()
{
  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;
  }
}
 
 
static void
shutdown_task (void *cls)
{
  (void) cls;
  s_task = NULL;
  GNUNET_RESOLVER_disconnect ();
  backoff = GNUNET_TIME_UNIT_MILLISECONDS;
}
 
 
static void
check_disconnect ()
{
  for (struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
       NULL != rh;
       rh = rh->next)
    if (GNUNET_SYSERR != rh->was_transmitted)
      return;
  if (NULL != r_task)
  {
    GNUNET_SCHEDULER_cancel (r_task);
    r_task = NULL;
  }
  if (NULL != s_task)
    return;
  s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
                                         &shutdown_task,
                                         NULL);
}
 
 
static char *
no_resolve (int af,
            const void *ip,
            socklen_t ip_len)
{
  char buf[INET6_ADDRSTRLEN];
 
  switch (af)
  {
  case AF_INET:
    if (ip_len != sizeof(struct in_addr))
      return NULL;
    if (NULL ==
        inet_ntop (AF_INET,
                   ip,
                   buf,
                   sizeof(buf)))
    {
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                    "inet_ntop");
      return NULL;
    }
    break;
 
  case AF_INET6:
    if (ip_len != sizeof(struct in6_addr))
      return NULL;
    if (NULL ==
        inet_ntop (AF_INET6,
                   ip,
                   buf,
                   sizeof(buf)))
    {
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                    "inet_ntop");
      return NULL;
    }
    break;
 
  default:
    GNUNET_break (0);
    return NULL;
  }
  return GNUNET_strdup (buf);
}
 
 
static void
reconnect (void);
 
 
static void
mq_error_handler (void *cls,
                  enum GNUNET_MQ_Error error)
{
  (void) cls;
  GNUNET_MQ_destroy (mq);
  mq = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "MQ error %d, reconnecting\n",
       error);
  reconnect ();
}
 
 
static void
process_requests ()
{
  struct GNUNET_RESOLVER_GetMessage *msg;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
 
  if (NULL == mq)
  {
    reconnect ();
    return;
  }
  if (NULL == rh)
  {
    /* nothing to do, release socket really soon if there is nothing
     * else happening... */
    if (NULL == s_task)
      s_task =
        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
                                      &shutdown_task,
                                      NULL);
    return;
  }
  if (GNUNET_NO != rh->was_transmitted)
    return;                     /* waiting for reply */
  env = GNUNET_MQ_msg_extra (msg,
                             rh->data_len,
                             GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
  msg->direction = htonl (rh->direction);
  msg->af = htonl (rh->af);
  msg->client_id = rh->id;
  GNUNET_memcpy (&msg[1],
                 &rh[1],
                 rh->data_len);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transmitting DNS resolution request (ID %u) to DNS service\n",
       rh->id);
  GNUNET_MQ_send (mq,
                  env);
  rh->was_transmitted = GNUNET_YES;
}
 
 
static int
check_response (void *cls,
                const struct GNUNET_RESOLVER_ResponseMessage *msg)
{
  (void) cls;
  (void) msg;
 
  /* implemented in #handle_response() for now */
  return GNUNET_OK;
}
 
 
static void
handle_response (void *cls,
                 const struct GNUNET_RESOLVER_ResponseMessage *msg)
{
  struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
  uint16_t size;
  char *nret;
  uint32_t client_request_id = msg->client_id;
 
  for (; rh != NULL; rh = rh->next)
  {
    if (rh->id == client_request_id)
      break;
  }
 
  (void) cls;
  if (NULL == rh)
  {
    /* Resolver service sent extra replies to query (after terminator)? Bad! */
    GNUNET_break (0);
    GNUNET_MQ_destroy (mq);
    mq = NULL;
    reconnect ();
    return;
  }
  size = ntohs (msg->header.size);
  if (size == sizeof(struct GNUNET_RESOLVER_ResponseMessage))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received empty response from DNS service\n");
    /* message contains not data, just header; end of replies */
    /* check if request was canceled */
    if (GNUNET_SYSERR != rh->was_transmitted)
    {
      /* no reverse lookup was successful, return IP as string */
      if (NULL != rh->name_callback)
      {
        if (GNUNET_NO == rh->received_response)
        {
          nret = no_resolve (rh->af,
                             &rh[1],
                             rh->data_len);
          rh->name_callback (rh->cls, nret);
          GNUNET_free (nret);
        }
        /* finally, make termination call */
        if (GNUNET_SYSERR != rh->was_transmitted)
          rh->name_callback (rh->cls,
                             NULL);
      }
      if ((NULL != rh->addr_callback) &&
          (GNUNET_SYSERR != rh->was_transmitted))
        rh->addr_callback (rh->cls,
                           NULL,
                           0);
    }
    rh->was_transmitted = GNUNET_NO;
    GNUNET_RESOLVER_request_cancel (rh);
    process_requests ();
    return;
  }
  /* return reverse lookup results to caller */
  if (NULL != rh->name_callback)
  {
    const char *hostname;
 
    hostname = (const char *) &msg[1];
    if (hostname[size - sizeof(struct GNUNET_RESOLVER_ResponseMessage) - 1] !=
        '\0')
    {
      GNUNET_break (0);
      if (GNUNET_SYSERR != rh->was_transmitted)
        rh->name_callback (rh->cls,
                           NULL);
      rh->was_transmitted = GNUNET_NO;
      GNUNET_RESOLVER_request_cancel (rh);
      GNUNET_MQ_destroy (mq);
      mq = NULL;
      reconnect ();
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Resolver returns `%s' for IP `%s'.\n",
         hostname,
         GNUNET_a2s ((const void *) &rh[1],
                     rh->data_len));
    if (rh->was_transmitted != GNUNET_SYSERR)
      rh->name_callback (rh->cls,
                         hostname);
    rh->received_response = GNUNET_YES;
  }
  /* return lookup results to caller */
  if (NULL != rh->addr_callback)
  {
    struct sockaddr_in v4;
    struct sockaddr_in6 v6;
    const struct sockaddr *sa;
    socklen_t salen;
    const void *ip;
    size_t ip_len;
 
    ip = &msg[1];
    ip_len = size - sizeof(struct GNUNET_RESOLVER_ResponseMessage);
    if (ip_len == sizeof(struct in_addr))
    {
      memset (&v4, 0, sizeof(v4));
      v4.sin_family = AF_INET;
      v4.sin_addr = *(struct in_addr*) ip;
#if HAVE_SOCKADDR_IN_SIN_LEN
      v4.sin_len = sizeof(v4);
#endif
      salen = sizeof(v4);
      sa = (const struct sockaddr *) &v4;
    }
    else if (ip_len == sizeof(struct in6_addr))
    {
      memset (&v6, 0, sizeof(v6));
      v6.sin6_family = AF_INET6;
      v6.sin6_addr = *(struct in6_addr*) ip;
#if HAVE_SOCKADDR_IN_SIN_LEN
      v6.sin6_len = sizeof(v6);
#endif
      salen = sizeof(v6);
      sa = (const struct sockaddr *) &v6;
    }
    else
    {
      GNUNET_break (0);
      if (GNUNET_SYSERR != rh->was_transmitted)
        rh->addr_callback (rh->cls,
                           NULL,
                           0);
      rh->was_transmitted = GNUNET_NO;
      GNUNET_RESOLVER_request_cancel (rh);
      GNUNET_MQ_destroy (mq);
      mq = NULL;
      reconnect ();
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received IP from DNS service\n");
    if (GNUNET_SYSERR != rh->was_transmitted)
      rh->addr_callback (rh->cls,
                         sa,
                         salen);
  }
}
 
 
static void
numeric_resolution (void *cls)
{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
  const char *hostname;
 
  rh->task = NULL;
  memset (&v4, 0, sizeof(v4));
  v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v4.sin_len = sizeof(v4);
#endif
  memset (&v6, 0, sizeof(v6));
  v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v6.sin6_len = sizeof(v6);
#endif
  hostname = (const char *) &rh[1];
  if (((rh->af == AF_UNSPEC) ||
       (rh->af == AF_INET)) &&
      (1 == inet_pton (AF_INET,
                       hostname,
                       &v4.sin_addr)))
  {
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v4,
                       sizeof(v4));
    if ((rh->af == AF_UNSPEC) &&
        (GNUNET_SYSERR != rh->was_transmitted) &&
        (1 == inet_pton (AF_INET6,
                         hostname,
                         &v6.sin6_addr)))
    {
      /* this can happen on some systems IF "hostname" is "localhost" */
      rh->addr_callback (rh->cls,
                         (const struct sockaddr *) &v6,
                         sizeof(v6));
    }
    if (GNUNET_SYSERR != rh->was_transmitted)
      rh->addr_callback (rh->cls,
                         NULL,
                         0);
    GNUNET_free (rh);
    return;
  }
  if (((rh->af == AF_UNSPEC) ||
       (rh->af == AF_INET6)) &&
      (1 == inet_pton (AF_INET6,
                       hostname,
                       &v6.sin6_addr)))
  {
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v6,
                       sizeof(v6));
    if (GNUNET_SYSERR != rh->was_transmitted)
      rh->addr_callback (rh->cls,
                         NULL,
                         0);
    GNUNET_free (rh);
    return;
  }
  /* why are we here? this task should not have been scheduled! */
  GNUNET_assert (0);
  GNUNET_free (rh);
}
 
 
static void
loopback_resolution (void *cls)
{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 
  rh->task = NULL;
  memset (&v4, 0, sizeof(v4));
  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
  v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v4.sin_len = sizeof(v4);
#endif
  memset (&v6, 0, sizeof(v6));
  v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v6.sin6_len = sizeof(v6);
#endif
  v6.sin6_addr = in6addr_loopback;
  switch (rh->af)
  {
  case AF_INET:
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v4,
                       sizeof(v4));
    break;
 
  case AF_INET6:
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v6,
                       sizeof(v6));
    break;
 
  case AF_UNSPEC:
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v6,
                       sizeof(v6));
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v4,
                       sizeof(v4));
 
    break;
 
  default:
    GNUNET_break (0);
    break;
  }
  if (GNUNET_SYSERR != rh->was_transmitted)
    rh->addr_callback (rh->cls,
                       NULL,
                       0);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Finished resolving hostname `%s'.\n",
       (const char *) &rh[1]);
  GNUNET_free (rh);
}
 
 
static void
reconnect_task (void *cls)
{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (response,
                           GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE,
                           struct GNUNET_RESOLVER_ResponseMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
 
  (void) cls;
  r_task = NULL;
  if (NULL == req_head)
    return;                     /* no work pending */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Trying to connect to DNS service\n");
  mq = GNUNET_CLIENT_connect (resolver_cfg,
                              "resolver",
                              handlers,
                              &mq_error_handler,
                              NULL);
  if (NULL == mq)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to connect, will try again later\n");
    reconnect ();
    return;
  }
  process_requests ();
}
 
 
static void
reconnect ()
{
  struct GNUNET_RESOLVER_RequestHandle *rh;
 
  if (NULL != r_task)
    return;
  GNUNET_assert (NULL == mq);
  if (NULL != (rh = req_head))
  {
    switch (rh->was_transmitted)
    {
    case GNUNET_NO:
      /* nothing more to do */
      break;
 
    case GNUNET_YES:
      /* disconnected, transmit again! */
      rh->was_transmitted = GNUNET_NO;
      break;
 
    case GNUNET_SYSERR:
      /* request was cancelled, remove entirely */
      GNUNET_CONTAINER_DLL_remove (req_head,
                                   req_tail,
                                   rh);
      GNUNET_free (rh);
      check_disconnect ();
      break;
 
    default:
      GNUNET_assert (0);
      break;
    }
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Will try to connect to DNS service in %s\n",
       GNUNET_STRINGS_relative_time_to_string (backoff,
                                               GNUNET_YES));
  GNUNET_assert (NULL != resolver_cfg);
  r_task = GNUNET_SCHEDULER_add_delayed (backoff,
                                         &reconnect_task,
                                         NULL);
  backoff = GNUNET_TIME_STD_BACKOFF (backoff);
}
 
 
static void
handle_lookup_timeout (void *cls)
{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
 
  rh->task = NULL;
  if (GNUNET_NO == rh->direction)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         _ ("Timeout trying to resolve hostname `%s'.\n"),
         (const char *) &rh[1]);
    if (NULL != rh->addr_callback)
      rh->addr_callback (rh->cls,
                         NULL,
                         0);
  }
  else
  {
#if ! defined(GNUNET_CULL_LOGGING)
    char buf[INET6_ADDRSTRLEN];
 
    LOG (GNUNET_ERROR_TYPE_INFO,
         _ ("Timeout trying to resolve IP address `%s'.\n"),
         inet_ntop (rh->af,
                    (const void *) &rh[1],
                    buf,
                    sizeof(buf)));
#endif
    if (GNUNET_NO == rh->received_response)
    {
      char *nret;
 
      nret = no_resolve (rh->af,
                         &rh[1],
                         rh->data_len);
      if (NULL != rh->name_callback)
        rh->name_callback (rh->cls, nret);
      GNUNET_free (nret);
    }
    /* finally, make termination call */
    if (NULL != rh->name_callback)
      rh->name_callback (rh->cls,
                         NULL);
  }
  rh->was_transmitted = GNUNET_NO;
  GNUNET_RESOLVER_request_cancel (rh);
  process_requests ();
}
 
 
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)
{
  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;
}
 
 
static void
numeric_reverse (void *cls)
{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
  char *result;
 
  rh->task = NULL;
  result = no_resolve (rh->af,
                       &rh[1],
                       rh->data_len);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Resolver returns `%s'.\n",
       result);
  if (NULL != result)
  {
    rh->name_callback (rh->cls,
                       result);
    GNUNET_free (result);
  }
  rh->name_callback (rh->cls,
                     NULL);
  if (NULL != rh->task)
  {
    GNUNET_SCHEDULER_cancel (rh->task);
    rh->task = NULL;
  }
  GNUNET_free (rh);
}
 
 
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)
{
  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;
}
 
 
char *
GNUNET_RESOLVER_local_fqdn_get ()
{
  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
}
 
 
struct GNUNET_RESOLVER_RequestHandle *
GNUNET_RESOLVER_hostname_resolve (int af,
                                  struct GNUNET_TIME_Relative timeout,
                                  GNUNET_RESOLVER_AddressCallback callback,
                                  void *cls)
{
  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);
}
 
 
void
GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *rh)
{
  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 ();
}
 
 
/* end of resolver_api.c */

MAX_HOSTNAME

#define MAX_HOSTNAME   1024

Maximum supported length for a hostname.

Definition at line 42 of file resolver_api.c.

Function Documentation

check_config()

static int check_config ( )

static

Check that the resolver service runs on localhost (or equivalent).

Returns

GNUNET_OK if the resolver is properly configured, GNUNET_SYSERR otherwise.

Definition at line 191 of file resolver_api.c.

{
  char *hostname;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_have_value (resolver_cfg,
                                       "resolver",
                                       "UNIXPATH"))
    return GNUNET_OK;
  memset (&v4, 0, sizeof(v4));
  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
  v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v4.sin_len = sizeof(v4);
#endif
  memset (&v6, 0, sizeof(v6));
  v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v6.sin6_len = sizeof(v6);
#endif
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_string (resolver_cfg,
                                             "resolver",
                                             "HOSTNAME",
                                             &hostname))
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         _ (
           "Missing `%s' for `%s' in configuration, DNS resolution will be unavailable.\n"),
         "HOSTNAME",
         "resolver");
    return GNUNET_SYSERR;
  }
  if ((1 == inet_pton (AF_INET, hostname, &v4)) ||
      (1 == inet_pton (AF_INET6, hostname, &v6)))
  {
    GNUNET_free (hostname);
    return GNUNET_OK;
  }
  for (unsigned int i = 0;
       NULL != loopback[i];
       i++)
    if (0 == strcasecmp (loopback[i],
                         hostname))
    {
      GNUNET_free (hostname);
      return GNUNET_OK;
    }
  LOG (GNUNET_ERROR_TYPE_INFO,
       _ (
         "Missing `%s' or numeric IP address for `%s' of `%s' in configuration, DNS resolution will be unavailable.\n"),
       "localhost",
       "HOSTNAME",
       "resolver");
  GNUNET_free (hostname);
  return GNUNET_SYSERR;
}

References _, GNUNET_CONFIGURATION_get_value_string(), GNUNET_CONFIGURATION_have_value(), GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_OK, GNUNET_SYSERR, LOG, loopback, and resolver_cfg.

Referenced by GNUNET_RESOLVER_hostname_get(), and GNUNET_RESOLVER_ip_get().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task executed on system shutdown.

Definition at line 306 of file resolver_api.c.

{
  (void) cls;
  s_task = NULL;
  GNUNET_RESOLVER_disconnect ();
  backoff = GNUNET_TIME_UNIT_MILLISECONDS;
}

References backoff, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_disconnect(), GNUNET_TIME_UNIT_MILLISECONDS, and s_task.

Here is the call graph for this function:

check_disconnect()

static void check_disconnect ( )

static

Consider disconnecting if we have no further requests pending.

Definition at line 319 of file resolver_api.c.

{
  for (struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
       NULL != rh;
       rh = rh->next)
    if (GNUNET_SYSERR != rh->was_transmitted)
      return;
  if (NULL != r_task)
  {
    GNUNET_SCHEDULER_cancel (r_task);
    r_task = NULL;
  }
  if (NULL != s_task)
    return;
  s_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
                                         &shutdown_task,
                                         NULL);
}

References GNUNET_SCHEDULER_add_delayed(), GNUNET_SCHEDULER_cancel(), GNUNET_SYSERR, GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_RESOLVER_RequestHandle::next, r_task, req_head, s_task, and shutdown_task.

Referenced by GNUNET_RESOLVER_request_cancel(), and reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

no_resolve()

static char * no_resolve ( int  af, const void *  ip, socklen_t  ip_len  )

static

Convert IP address to string without DNS resolution.

Parameters

af	address family
ip	the address
ip_len	number of bytes in ip

Returns

address as a string, NULL on error

Definition at line 348 of file resolver_api.c.

{
  char buf[INET6_ADDRSTRLEN];
 
  switch (af)
  {
  case AF_INET:
    if (ip_len != sizeof(struct in_addr))
      return NULL;
    if (NULL ==
        inet_ntop (AF_INET,
                   ip,
                   buf,
                   sizeof(buf)))
    {
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                    "inet_ntop");
      return NULL;
    }
    break;
 
  case AF_INET6:
    if (ip_len != sizeof(struct in6_addr))
      return NULL;
    if (NULL ==
        inet_ntop (AF_INET6,
                   ip,
                   buf,
                   sizeof(buf)))
    {
      LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
                    "inet_ntop");
      return NULL;
    }
    break;
 
  default:
    GNUNET_break (0);
    return NULL;
  }
  return GNUNET_strdup (buf);
}

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_break, GNUNET_ERROR_TYPE_WARNING, GNUNET_strdup, and LOG_STRERROR.

Referenced by handle_lookup_timeout(), handle_response(), and numeric_reverse().

Here is the caller graph for this function:

reconnect()

static void reconnect ( void  )

static

Adjust exponential back-off and reconnect to the service.

Definition at line 828 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh;
 
  if (NULL != r_task)
    return;
  GNUNET_assert (NULL == mq);
  if (NULL != (rh = req_head))
  {
    switch (rh->was_transmitted)
    {
    case GNUNET_NO:
      /* nothing more to do */
      break;
 
    case GNUNET_YES:
      /* disconnected, transmit again! */
      rh->was_transmitted = GNUNET_NO;
      break;
 
    case GNUNET_SYSERR:
      /* request was cancelled, remove entirely */
      GNUNET_CONTAINER_DLL_remove (req_head,
                                   req_tail,
                                   rh);
      GNUNET_free (rh);
      check_disconnect ();
      break;
 
    default:
      GNUNET_assert (0);
      break;
    }
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Will try to connect to DNS service in %s\n",
       GNUNET_STRINGS_relative_time_to_string (backoff,
                                               GNUNET_YES));
  GNUNET_assert (NULL != resolver_cfg);
  r_task = GNUNET_SCHEDULER_add_delayed (backoff,
                                         &reconnect_task,
                                         NULL);
  backoff = GNUNET_TIME_STD_BACKOFF (backoff);
}

References backoff, check_disconnect(), GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_SYSERR, GNUNET_TIME_STD_BACKOFF, GNUNET_YES, LOG, mq, r_task, reconnect_task(), req_head, req_tail, resolver_cfg, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by callback_reconnect(), disconnect_and_schedule_reconnect(), disconnect_and_schedule_reconnect(), do_connect(), error_handler(), error_handler(), error_handler(), error_handler(), error_handler(), error_handler(), force_reconnect(), GNUNET_ABD_connect(), GNUNET_CADET_connect(), GNUNET_CADET_get_channel(), GNUNET_CADET_get_path(), GNUNET_CADET_list_peers(), GNUNET_CADET_list_tunnels(), GNUNET_CORE_connect(), GNUNET_CORE_monitor_start(), GNUNET_DNS_connect(), GNUNET_GNS_connect(), GNUNET_IDENTITY_connect(), GNUNET_MESSENGER_connect(), GNUNET_NAMECACHE_connect(), GNUNET_NAMESTORE_connect(), GNUNET_NAMESTORE_zone_monitor_start(), GNUNET_NAMESTORE_zone_monitor_start2(), GNUNET_NSE_connect(), GNUNET_PEERSTORE_connect(), GNUNET_PEERSTORE_monitor_start(), GNUNET_PILS_connect(), GNUNET_RECLAIM_connect(), GNUNET_RECLAIM_ticket_consume(), GNUNET_RPS_connect(), GNUNET_TRANSPORT_application_init(), GNUNET_TRANSPORT_communicator_connect(), GNUNET_TRANSPORT_monitor(), handle_address_change_notification(), handle_incoming_ack(), handle_monitor_end(), handle_mq_error(), handle_response(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), mq_error_handler(), process_requests(), reconnect(), reconnect(), reconnect_cbk(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), reconnect_task(), and reschedule_connect().

Here is the call graph for this function:

mq_error_handler()

static void mq_error_handler ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	NULL
error	error code

Definition at line 410 of file resolver_api.c.

{
  (void) cls;
  GNUNET_MQ_destroy (mq);
  mq = NULL;
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "MQ error %d, reconnecting\n",
       error);
  reconnect ();
}

References GNUNET_RESOLVER_RequestHandle::cls, GNUNET_ERROR_TYPE_DEBUG, GNUNET_MQ_destroy(), LOG, mq, and reconnect().

Referenced by reconnect_task().

Here is the call graph for this function:

Here is the caller graph for this function:

process_requests()

static void process_requests ( )

static

Process pending requests to the resolver.

Definition at line 427 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_GetMessage *msg;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
 
  if (NULL == mq)
  {
    reconnect ();
    return;
  }
  if (NULL == rh)
  {
    /* nothing to do, release socket really soon if there is nothing
     * else happening... */
    if (NULL == s_task)
      s_task =
        GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_MILLISECONDS,
                                      &shutdown_task,
                                      NULL);
    return;
  }
  if (GNUNET_NO != rh->was_transmitted)
    return;                     /* waiting for reply */
  env = GNUNET_MQ_msg_extra (msg,
                             rh->data_len,
                             GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST);
  msg->direction = htonl (rh->direction);
  msg->af = htonl (rh->af);
  msg->client_id = rh->id;
  GNUNET_memcpy (&msg[1],
                 &rh[1],
                 rh->data_len);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Transmitting DNS resolution request (ID %u) to DNS service\n",
       rh->id);
  GNUNET_MQ_send (mq,
                  env);
  rh->was_transmitted = GNUNET_YES;
}

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_RESOLVER_RequestHandle::direction, env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_TIME_UNIT_MILLISECONDS, GNUNET_YES, GNUNET_RESOLVER_RequestHandle::id, LOG, mq, msg, reconnect(), req_head, s_task, shutdown_task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), handle_lookup_timeout(), handle_response(), and reconnect_task().

Here is the call graph for this function:

Here is the caller graph for this function:

check_response()

static int check_response ( void *  cls, const struct GNUNET_RESOLVER_ResponseMessage *  msg  )

static

Check validity of response with a hostname for a DNS lookup.

Parameters

cls	NULL
msg	message with the hostname

Definition at line 476 of file resolver_api.c.

{
  (void) cls;
  (void) msg;
 
  /* implemented in #handle_response() for now */
  return GNUNET_OK;
}

References GNUNET_RESOLVER_RequestHandle::cls, GNUNET_OK, and msg.

handle_response()

static void handle_response ( void *  cls, const struct GNUNET_RESOLVER_ResponseMessage *  msg  )

static

Check validity of response with a hostname for a DNS lookup.

NOTE: right now rather messy, might want to use different message types for different response formats in the future.

Parameters

cls	NULL
msg	message with the response

Definition at line 496 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh = req_head;
  uint16_t size;
  char *nret;
  uint32_t client_request_id = msg->client_id;
 
  for (; rh != NULL; rh = rh->next)
  {
    if (rh->id == client_request_id)
      break;
  }
 
  (void) cls;
  if (NULL == rh)
  {
    /* Resolver service sent extra replies to query (after terminator)? Bad! */
    GNUNET_break (0);
    GNUNET_MQ_destroy (mq);
    mq = NULL;
    reconnect ();
    return;
  }
  size = ntohs (msg->header.size);
  if (size == sizeof(struct GNUNET_RESOLVER_ResponseMessage))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received empty response from DNS service\n");
    /* message contains not data, just header; end of replies */
    /* check if request was canceled */
    if (GNUNET_SYSERR != rh->was_transmitted)
    {
      /* no reverse lookup was successful, return IP as string */
      if (NULL != rh->name_callback)
      {
        if (GNUNET_NO == rh->received_response)
        {
          nret = no_resolve (rh->af,
                             &rh[1],
                             rh->data_len);
          rh->name_callback (rh->cls, nret);
          GNUNET_free (nret);
        }
        /* finally, make termination call */
        if (GNUNET_SYSERR != rh->was_transmitted)
          rh->name_callback (rh->cls,
                             NULL);
      }
      if ((NULL != rh->addr_callback) &&
          (GNUNET_SYSERR != rh->was_transmitted))
        rh->addr_callback (rh->cls,
                           NULL,
                           0);
    }
    rh->was_transmitted = GNUNET_NO;
    GNUNET_RESOLVER_request_cancel (rh);
    process_requests ();
    return;
  }
  /* return reverse lookup results to caller */
  if (NULL != rh->name_callback)
  {
    const char *hostname;
 
    hostname = (const char *) &msg[1];
    if (hostname[size - sizeof(struct GNUNET_RESOLVER_ResponseMessage) - 1] !=
        '\0')
    {
      GNUNET_break (0);
      if (GNUNET_SYSERR != rh->was_transmitted)
        rh->name_callback (rh->cls,
                           NULL);
      rh->was_transmitted = GNUNET_NO;
      GNUNET_RESOLVER_request_cancel (rh);
      GNUNET_MQ_destroy (mq);
      mq = NULL;
      reconnect ();
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Resolver returns `%s' for IP `%s'.\n",
         hostname,
         GNUNET_a2s ((const void *) &rh[1],
                     rh->data_len));
    if (rh->was_transmitted != GNUNET_SYSERR)
      rh->name_callback (rh->cls,
                         hostname);
    rh->received_response = GNUNET_YES;
  }
  /* return lookup results to caller */
  if (NULL != rh->addr_callback)
  {
    struct sockaddr_in v4;
    struct sockaddr_in6 v6;
    const struct sockaddr *sa;
    socklen_t salen;
    const void *ip;
    size_t ip_len;
 
    ip = &msg[1];
    ip_len = size - sizeof(struct GNUNET_RESOLVER_ResponseMessage);
    if (ip_len == sizeof(struct in_addr))
    {
      memset (&v4, 0, sizeof(v4));
      v4.sin_family = AF_INET;
      v4.sin_addr = *(struct in_addr*) ip;
#if HAVE_SOCKADDR_IN_SIN_LEN
      v4.sin_len = sizeof(v4);
#endif
      salen = sizeof(v4);
      sa = (const struct sockaddr *) &v4;
    }
    else if (ip_len == sizeof(struct in6_addr))
    {
      memset (&v6, 0, sizeof(v6));
      v6.sin6_family = AF_INET6;
      v6.sin6_addr = *(struct in6_addr*) ip;
#if HAVE_SOCKADDR_IN_SIN_LEN
      v6.sin6_len = sizeof(v6);
#endif
      salen = sizeof(v6);
      sa = (const struct sockaddr *) &v6;
    }
    else
    {
      GNUNET_break (0);
      if (GNUNET_SYSERR != rh->was_transmitted)
        rh->addr_callback (rh->cls,
                           NULL,
                           0);
      rh->was_transmitted = GNUNET_NO;
      GNUNET_RESOLVER_request_cancel (rh);
      GNUNET_MQ_destroy (mq);
      mq = NULL;
      reconnect ();
      return;
    }
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Received IP from DNS service\n");
    if (GNUNET_SYSERR != rh->was_transmitted)
      rh->addr_callback (rh->cls,
                         sa,
                         salen);
  }
}

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_a2s(), GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_NO, GNUNET_RESOLVER_request_cancel(), GNUNET_SYSERR, GNUNET_YES, GNUNET_RESOLVER_RequestHandle::id, LOG, mq, msg, GNUNET_RESOLVER_RequestHandle::name_callback, GNUNET_RESOLVER_RequestHandle::next, no_resolve(), process_requests(), GNUNET_RESOLVER_RequestHandle::received_response, reconnect(), req_head, GNUNET_MessageHeader::size, size, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Here is the call graph for this function:

numeric_resolution()

static void numeric_resolution ( void *  cls )

static

We've been asked to lookup the address for a hostname and were given a valid numeric string.

Perform the callbacks for the numeric addresses.

Parameters

cls	struct GNUNET_RESOLVER_RequestHandle for the request

Definition at line 652 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
  const char *hostname;
 
  rh->task = NULL;
  memset (&v4, 0, sizeof(v4));
  v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v4.sin_len = sizeof(v4);
#endif
  memset (&v6, 0, sizeof(v6));
  v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v6.sin6_len = sizeof(v6);
#endif
  hostname = (const char *) &rh[1];
  if (((rh->af == AF_UNSPEC) ||
       (rh->af == AF_INET)) &&
      (1 == inet_pton (AF_INET,
                       hostname,
                       &v4.sin_addr)))
  {
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v4,
                       sizeof(v4));
    if ((rh->af == AF_UNSPEC) &&
        (GNUNET_SYSERR != rh->was_transmitted) &&
        (1 == inet_pton (AF_INET6,
                         hostname,
                         &v6.sin6_addr)))
    {
      /* this can happen on some systems IF "hostname" is "localhost" */
      rh->addr_callback (rh->cls,
                         (const struct sockaddr *) &v6,
                         sizeof(v6));
    }
    if (GNUNET_SYSERR != rh->was_transmitted)
      rh->addr_callback (rh->cls,
                         NULL,
                         0);
    GNUNET_free (rh);
    return;
  }
  if (((rh->af == AF_UNSPEC) ||
       (rh->af == AF_INET6)) &&
      (1 == inet_pton (AF_INET6,
                       hostname,
                       &v6.sin6_addr)))
  {
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v6,
                       sizeof(v6));
    if (GNUNET_SYSERR != rh->was_transmitted)
      rh->addr_callback (rh->cls,
                         NULL,
                         0);
    GNUNET_free (rh);
    return;
  }
  /* why are we here? this task should not have been scheduled! */
  GNUNET_assert (0);
  GNUNET_free (rh);
}

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_assert, GNUNET_free, GNUNET_SYSERR, GNUNET_RESOLVER_RequestHandle::task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_ip_get().

Here is the caller graph for this function:

loopback_resolution()

static void loopback_resolution ( void *  cls )

static

We've been asked to lookup the address for a hostname and were given a variant of "loopback".

Perform the callbacks for the respective loopback numeric addresses.

Parameters

cls	struct GNUNET_RESOLVER_RequestHandle for the request

Definition at line 728 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
  struct sockaddr_in v4;
  struct sockaddr_in6 v6;
 
  rh->task = NULL;
  memset (&v4, 0, sizeof(v4));
  v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
  v4.sin_family = AF_INET;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v4.sin_len = sizeof(v4);
#endif
  memset (&v6, 0, sizeof(v6));
  v6.sin6_family = AF_INET6;
#if HAVE_SOCKADDR_IN_SIN_LEN
  v6.sin6_len = sizeof(v6);
#endif
  v6.sin6_addr = in6addr_loopback;
  switch (rh->af)
  {
  case AF_INET:
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v4,
                       sizeof(v4));
    break;
 
  case AF_INET6:
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v6,
                       sizeof(v6));
    break;
 
  case AF_UNSPEC:
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v6,
                       sizeof(v6));
    rh->addr_callback (rh->cls,
                       (const struct sockaddr *) &v4,
                       sizeof(v4));
 
    break;
 
  default:
    GNUNET_break (0);
    break;
  }
  if (GNUNET_SYSERR != rh->was_transmitted)
    rh->addr_callback (rh->cls,
                       NULL,
                       0);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Finished resolving hostname `%s'.\n",
       (const char *) &rh[1]);
  GNUNET_free (rh);
}

References GNUNET_RESOLVER_RequestHandle::addr_callback, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_break, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SYSERR, LOG, GNUNET_RESOLVER_RequestHandle::task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_ip_get().

Here is the caller graph for this function:

reconnect_task()

static void reconnect_task ( void *  cls )

static

Now try to reconnect to the resolver service.

Parameters

cls

NULL

Definition at line 792 of file resolver_api.c.

{
  struct GNUNET_MQ_MessageHandler handlers[] = {
    GNUNET_MQ_hd_var_size (response,
                           GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE,
                           struct GNUNET_RESOLVER_ResponseMessage,
                           NULL),
    GNUNET_MQ_handler_end ()
  };
 
  (void) cls;
  r_task = NULL;
  if (NULL == req_head)
    return;                     /* no work pending */
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Trying to connect to DNS service\n");
  mq = GNUNET_CLIENT_connect (resolver_cfg,
                              "resolver",
                              handlers,
                              &mq_error_handler,
                              NULL);
  if (NULL == mq)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Failed to connect, will try again later\n");
    reconnect ();
    return;
  }
  process_requests ();
}

References GNUNET_MQ_MessageHandler::cls, GNUNET_CLIENT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, handlers, LOG, mq, mq_error_handler(), process_requests(), r_task, reconnect(), req_head, resolver_cfg, and response.

Referenced by reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_lookup_timeout()

static void handle_lookup_timeout ( void *  cls )

static

A DNS resolution timed out.

Notify the application.

Parameters

cls	the struct GNUNET_RESOLVER_RequestHandle *

Definition at line 880 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
 
  rh->task = NULL;
  if (GNUNET_NO == rh->direction)
  {
    LOG (GNUNET_ERROR_TYPE_INFO,
         _ ("Timeout trying to resolve hostname `%s'.\n"),
         (const char *) &rh[1]);
    if (NULL != rh->addr_callback)
      rh->addr_callback (rh->cls,
                         NULL,
                         0);
  }
  else
  {
#if ! defined(GNUNET_CULL_LOGGING)
    char buf[INET6_ADDRSTRLEN];
 
    LOG (GNUNET_ERROR_TYPE_INFO,
         _ ("Timeout trying to resolve IP address `%s'.\n"),
         inet_ntop (rh->af,
                    (const void *) &rh[1],
                    buf,
                    sizeof(buf)));
#endif
    if (GNUNET_NO == rh->received_response)
    {
      char *nret;
 
      nret = no_resolve (rh->af,
                         &rh[1],
                         rh->data_len);
      if (NULL != rh->name_callback)
        rh->name_callback (rh->cls, nret);
      GNUNET_free (nret);
    }
    /* finally, make termination call */
    if (NULL != rh->name_callback)
      rh->name_callback (rh->cls,
                         NULL);
  }
  rh->was_transmitted = GNUNET_NO;
  GNUNET_RESOLVER_request_cancel (rh);
  process_requests ();
}

References _, GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::direction, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_NO, GNUNET_RESOLVER_request_cancel(), LOG, no_resolve(), process_requests(), GNUNET_RESOLVER_RequestHandle::task, and GNUNET_RESOLVER_RequestHandle::was_transmitted.

Referenced by GNUNET_RESOLVER_hostname_get(), and GNUNET_RESOLVER_ip_get().

Here is the call graph for this function:

Here is the caller graph for this function:

numeric_reverse()

static void numeric_reverse ( void *  cls )

static

We've been asked to convert an address to a string without a reverse lookup, either because the client asked for it or because the DNS lookup hit a timeout.

Do the numeric conversion and invoke the callback.

Parameters

cls	struct GNUNET_RESOLVER_RequestHandle for the request

Definition at line 1030 of file resolver_api.c.

{
  struct GNUNET_RESOLVER_RequestHandle *rh = cls;
  char *result;
 
  rh->task = NULL;
  result = no_resolve (rh->af,
                       &rh[1],
                       rh->data_len);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Resolver returns `%s'.\n",
       result);
  if (NULL != result)
  {
    rh->name_callback (rh->cls,
                       result);
    GNUNET_free (result);
  }
  rh->name_callback (rh->cls,
                     NULL);
  if (NULL != rh->task)
  {
    GNUNET_SCHEDULER_cancel (rh->task);
    rh->task = NULL;
  }
  GNUNET_free (rh);
}

References GNUNET_RESOLVER_RequestHandle::af, GNUNET_RESOLVER_RequestHandle::cls, GNUNET_RESOLVER_RequestHandle::data_len, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_SCHEDULER_cancel(), LOG, GNUNET_RESOLVER_RequestHandle::name_callback, no_resolve(), result, and GNUNET_RESOLVER_RequestHandle::task.

Referenced by GNUNET_RESOLVER_hostname_get().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

loopback

const char* loopback[]

static

Initial value:

= {
  "localhost",
  "ip6-localnet",
  NULL
}

Possible hostnames for "loopback".

Definition at line 48 of file resolver_api.c.

                                {
  "localhost",
  "ip6-localnet",
  NULL
};

Referenced by check_config(), and GNUNET_RESOLVER_ip_get().

resolver_cfg

const struct GNUNET_CONFIGURATION_Handle* resolver_cfg

static

Configuration.

Definition at line 58 of file resolver_api.c.

Referenced by check_config(), GNUNET_RESOLVER_connect(), reconnect(), and reconnect_task().

mq

struct GNUNET_MQ_Handle* mq

static

Our connection to the resolver service, created on-demand, but then persists until error or shutdown.

Definition at line 64 of file resolver_api.c.

Referenced by add_service_handle(), adv_transmit(), cadet_mq_cancel_impl(), cadet_mq_destroy_impl(), cadet_mq_send_impl(), callback_client_connect(), check_peer_online(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), client_connect_cb(), connect_cb(), connect_cb(), connect_cb(), connect_handler(), connect_handler(), connect_notify(), connection_client_cancel_impl(), connection_client_destroy_impl(), connection_client_send_impl(), connects(), continue_writing(), core_connect_cb(), core_connect_cb(), core_connects(), core_mq_cancel_impl(), core_mq_destroy_impl(), core_mq_send_impl(), create_srv_handle(), do_send(), GCP_set_mq(), GNUNET_CADET_drop_message(), GNUNET_FS_indexing_send_list(), GNUNET_MQ_assoc_add(), GNUNET_MQ_assoc_get(), GNUNET_MQ_assoc_remove(), GNUNET_MQ_destroy(), GNUNET_MQ_destroy_notify(), GNUNET_MQ_destroy_notify_cancel(), GNUNET_MQ_env_get_options(), GNUNET_MQ_get_current_envelope(), GNUNET_MQ_get_last_envelope(), GNUNET_MQ_get_length(), GNUNET_MQ_impl_current(), GNUNET_MQ_impl_send_continue(), GNUNET_MQ_impl_send_in_flight(), GNUNET_MQ_impl_state(), GNUNET_MQ_inject_error(), GNUNET_MQ_inject_message(), GNUNET_MQ_queue_for_callbacks(), GNUNET_MQ_send(), GNUNET_MQ_send_cancel(), GNUNET_MQ_send_copy(), GNUNET_MQ_set_handlers_closure(), GNUNET_MQ_set_options(), GNUNET_MQ_unsent_head(), GNUNET_notification_context_add(), GNUNET_RESOLVER_disconnect(), GNUNET_TRANSPORT_communicator_mq_add(), GSC_KX_handle_client_monitor_peers(), GSF_peer_connect_handler(), handle_core_connect(), handle_core_connect(), handle_response(), handle_start(), handle_transport_notify_connect(), impl_send_continue(), mq_destroy(), mq_destroy(), mq_destroy(), mq_destroy_d(), mq_destroy_d(), mq_destroy_d(), mq_destroy_impl(), mq_destroy_kx(), mq_error_handler(), mq_send(), mq_send(), mq_send(), mq_send_d(), mq_send_d(), mq_send_d(), mq_send_impl(), mq_send_kx(), notify_connect(), notify_connect(), notify_connect(), path_info_iterator(), process_requests(), queue_destroy(), reconnect(), reconnect_task(), return_agpl(), return_agpl(), send_message(), send_msg_with_kx(), send_simple_cb(), send_simple_cb(), send_simple_cb(), send_to_channel(), send_tunnel_envelope(), service_mq_cancel(), service_mq_send(), set_mq(), and transmit_pending().

req_head

struct GNUNET_RESOLVER_RequestHandle* req_head

static

Head of DLL of requests.

Definition at line 69 of file resolver_api.c.

Referenced by check_disconnect(), GNUNET_RESOLVER_disconnect(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_request_cancel(), handle_response(), process_requests(), reconnect(), and reconnect_task().

req_tail

struct GNUNET_RESOLVER_RequestHandle* req_tail

static

Tail of DLL of requests.

Definition at line 74 of file resolver_api.c.

Referenced by GNUNET_RESOLVER_disconnect(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), GNUNET_RESOLVER_request_cancel(), and reconnect().

last_request_id

uint32_t last_request_id

static

ID of the last request we sent to the service.

Definition at line 79 of file resolver_api.c.

Referenced by GNUNET_RESOLVER_hostname_get(), and GNUNET_RESOLVER_ip_get().

backoff

struct GNUNET_TIME_Relative backoff

static

How long should we wait to reconnect?

Definition at line 84 of file resolver_api.c.

Referenced by GNUNET_RESOLVER_connect(), reconnect(), and shutdown_task().

r_task

struct GNUNET_SCHEDULER_Task* r_task

static

Task for reconnecting.

Definition at line 89 of file resolver_api.c.

Referenced by check_disconnect(), GNUNET_RESOLVER_disconnect(), reconnect(), and reconnect_task().

s_task

struct GNUNET_SCHEDULER_Task* s_task

static

Task ID of shutdown task; only present while we have a connection to the resolver service.

Definition at line 95 of file resolver_api.c.

Referenced by check_disconnect(), GNUNET_RESOLVER_disconnect(), GNUNET_RESOLVER_hostname_get(), GNUNET_RESOLVER_ip_get(), process_requests(), and shutdown_task().