dnsstub.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for dnsstub.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_DNSSTUB_RequestSocket
	UDP socket we are using for sending DNS requests to the Internet. More...
struct	DnsServer
	DNS Server used for resolution. More...
struct	GNUNET_DNSSTUB_Context
	Handle to the stub resolver. More...

Macros
#define	DNS_RETRANSMIT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)
	Timeout for retrying DNS queries. More...

Functions
static void	cleanup_rs (struct GNUNET_DNSSTUB_RequestSocket *rs)
	We're done with a struct GNUNET_DNSSTUB_RequestSocket, close it for now. More...
static struct GNUNET_NETWORK_Handle *	open_socket (int af)
	Open source port for sending DNS requests. More...
static struct GNUNET_DNSSTUB_RequestSocket *	get_request_socket (struct GNUNET_DNSSTUB_Context *ctx)
	Get a socket of the specified address family to send out a UDP DNS request to the Internet. More...
static int	do_dns_read (struct GNUNET_DNSSTUB_RequestSocket *rs, struct GNUNET_NETWORK_Handle *dnsout)
	Actually do the reading of a DNS packet from our UDP socket and see if we have a valid, matching, pending request. More...
static void	read_response (void *cls)
	Read a DNS response from the (unhindered) UDP-Socket. More...
static void	schedule_read (struct GNUNET_DNSSTUB_RequestSocket *rs)
	Schedule read_response() task for rs. More...
static void	transmit_query (void *cls)
	Task to (re)transmit the DNS query, possibly repeatedly until we succeed. More...
struct GNUNET_DNSSTUB_RequestSocket *	GNUNET_DNSSTUB_resolve (struct GNUNET_DNSSTUB_Context *ctx, const void *request, size_t request_len, GNUNET_DNSSTUB_ResultCallback rc, void *rc_cls)
	Perform DNS resolution using our default IP from init. More...
void	GNUNET_DNSSTUB_resolve_cancel (struct GNUNET_DNSSTUB_RequestSocket *rs)
	Cancel DNS resolution. More...
struct GNUNET_DNSSTUB_Context *	GNUNET_DNSSTUB_start (unsigned int num_sockets)
	Start a DNS stub resolver. More...
int	GNUNET_DNSSTUB_add_dns_ip (struct GNUNET_DNSSTUB_Context *ctx, const char *dns_ip)
	Add nameserver for use by the DNSSTUB. More...
int	GNUNET_DNSSTUB_add_dns_sa (struct GNUNET_DNSSTUB_Context *ctx, const struct sockaddr *sa)
	Add nameserver for use by the DNSSTUB. More...
void	GNUNET_DNSSTUB_set_retry (struct GNUNET_DNSSTUB_Context *ctx, struct GNUNET_TIME_Relative retry_freq)
	How long should we try requests before timing out? Only effective for requests issued after this call. More...
void	GNUNET_DNSSTUB_stop (struct GNUNET_DNSSTUB_Context *ctx)
	Cleanup DNSSTUB resolver. More...

Macro Definition Documentation

DNS_RETRANSMIT_DELAY

#define DNS_RETRANSMIT_DELAY    GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 250)

Timeout for retrying DNS queries.

Definition at line 32 of file dnsstub.c.

Function Documentation

cleanup_rs()

static void cleanup_rs ( struct GNUNET_DNSSTUB_RequestSocket *  rs )

static

We're done with a struct GNUNET_DNSSTUB_RequestSocket, close it for now.

Parameters

rs	request socket to clean up

Definition at line 159 of file dnsstub.c.

{
  if (NULL != rs->dnsout4)
  {
    GNUNET_NETWORK_socket_close (rs->dnsout4);
    rs->dnsout4 = NULL;
  }
  if (NULL != rs->dnsout6)
  {
    GNUNET_NETWORK_socket_close (rs->dnsout6);
    rs->dnsout6 = NULL;
  }
  if (NULL != rs->read_task)
  {
    GNUNET_SCHEDULER_cancel (rs->read_task);
    rs->read_task = NULL;
  }
  if (NULL != rs->retry_task)
  {
    GNUNET_SCHEDULER_cancel (rs->retry_task);
    rs->retry_task = NULL;
  }
  if (NULL != rs->request)
  {
    GNUNET_free (rs->request);
    rs->request = NULL;
  }
}

References GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, GNUNET_free, GNUNET_NETWORK_socket_close(), GNUNET_SCHEDULER_cancel(), GNUNET_DNSSTUB_RequestSocket::read_task, GNUNET_DNSSTUB_RequestSocket::request, and GNUNET_DNSSTUB_RequestSocket::retry_task.

Referenced by GNUNET_DNSSTUB_stop().

Here is the call graph for this function:

Here is the caller graph for this function:

open_socket()

static struct GNUNET_NETWORK_Handle* open_socket ( int  af )

static

Open source port for sending DNS requests.

Parameters

af	AF_INET or AF_INET6

Returns

GNUNET_OK on success

Definition at line 196 of file dnsstub.c.

{
  struct sockaddr_in a4;
  struct sockaddr_in6 a6;
  struct sockaddr *sa;
  socklen_t alen;
  struct GNUNET_NETWORK_Handle *ret;
 
  ret = GNUNET_NETWORK_socket_create (af, SOCK_DGRAM, 0);
  if (NULL == ret)
    return NULL;
  switch (af)
  {
  case AF_INET:
    memset (&a4, 0, alen = sizeof(struct sockaddr_in));
    sa = (struct sockaddr *) &a4;
    break;
 
  case AF_INET6:
    memset (&a6, 0, alen = sizeof(struct sockaddr_in6));
    sa = (struct sockaddr *) &a6;
    break;
 
  default:
    GNUNET_break (0);
    GNUNET_NETWORK_socket_close (ret);
    return NULL;
  }
  sa->sa_family = af;
  if (GNUNET_OK != GNUNET_NETWORK_socket_bind (ret, sa, alen))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not bind to any port: %s\n"),
                strerror (errno));
    GNUNET_NETWORK_socket_close (ret);
    return NULL;
  }
  return ret;
}

References _, GNUNET_NETWORK_Handle::af, GNUNET_break, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_OK, and ret.

Referenced by transmit_query().

Here is the call graph for this function:

Here is the caller graph for this function:

get_request_socket()

static struct GNUNET_DNSSTUB_RequestSocket* get_request_socket ( struct GNUNET_DNSSTUB_Context *  ctx )

static

Get a socket of the specified address family to send out a UDP DNS request to the Internet.

Parameters

ctx	the DNSSTUB context

Returns

NULL on error

Definition at line 245 of file dnsstub.c.

{
  struct GNUNET_DNSSTUB_RequestSocket *rs;
 
  for (unsigned int i = 0; i < 256; i++)
  {
    rs = &ctx->sockets[GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                                 ctx->num_sockets)];
    if (NULL == rs->rc)
      break;
  }
  if (NULL != rs->rc)
  {
    /* signal "failure" */
    rs->rc (rs->rc_cls, NULL, 0);
    rs->rc = NULL;
  }
  if (NULL != rs->read_task)
  {
    GNUNET_SCHEDULER_cancel (rs->read_task);
    rs->read_task = NULL;
  }
  if (NULL != rs->retry_task)
  {
    GNUNET_SCHEDULER_cancel (rs->retry_task);
    rs->retry_task = NULL;
  }
  if (NULL != rs->request)
  {
    GNUNET_free (rs->request);
    rs->request = NULL;
  }
  rs->ctx = ctx;
  return rs;
}

References ctx, GNUNET_DNSSTUB_RequestSocket::ctx, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_DNSSTUB_Context::num_sockets, GNUNET_DNSSTUB_RequestSocket::rc, GNUNET_DNSSTUB_RequestSocket::rc_cls, GNUNET_DNSSTUB_RequestSocket::read_task, GNUNET_DNSSTUB_RequestSocket::request, GNUNET_DNSSTUB_RequestSocket::retry_task, and GNUNET_DNSSTUB_Context::sockets.

Referenced by GNUNET_DNSSTUB_resolve().

Here is the call graph for this function:

Here is the caller graph for this function:

do_dns_read()

static int do_dns_read ( struct GNUNET_DNSSTUB_RequestSocket *  rs, struct GNUNET_NETWORK_Handle *  dnsout  )

static

Actually do the reading of a DNS packet from our UDP socket and see if we have a valid, matching, pending request.

Parameters

rs	request socket with callback details
dnsout	socket to read from

Returns

GNUNET_OK on success, GNUNET_NO on drop, GNUNET_SYSERR on IO-errors (closed socket)

Definition at line 291 of file dnsstub.c.

{
  struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
  ssize_t r;
  int len;
 
  if (0 != ioctl (GNUNET_NETWORK_get_fd (dnsout), FIONREAD, &len))
  {
    /* conservative choice: */
    len = UINT16_MAX;
  }
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving %d byte DNS reply\n", len);
  {
    unsigned char buf[len] GNUNET_ALIGN;
    int found;
    struct sockaddr_storage addr;
    socklen_t addrlen;
    struct GNUNET_TUN_DnsHeader *dns;
 
    addrlen = sizeof(addr);
    memset (&addr, 0, sizeof(addr));
    r = GNUNET_NETWORK_socket_recvfrom (dnsout,
                                        buf,
                                        sizeof(buf),
                                        (struct sockaddr *) &addr,
                                        &addrlen);
    if (-1 == r)
    {
      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom");
      GNUNET_NETWORK_socket_close (dnsout);
      return GNUNET_SYSERR;
    }
    found = GNUNET_NO;
    for (struct DnsServer *ds = ctx->dns_head; NULL != ds; ds = ds->next)
    {
      if (ds->ss.ss_family != addr.ss_family)
        continue;
      if (addr.ss_family == AF_INET)
      {
        struct sockaddr_in *v4 = (struct sockaddr_in *) &addr;
        struct sockaddr_in *ds_v4 = (struct sockaddr_in *) &ds->ss;
 
 
        if ((0 == memcmp (&v4->sin_addr,
                         &ds_v4->sin_addr,
                         sizeof(struct sockaddr_in))) &&
            (v4->sin_port == ds_v4->sin_port))
        {
          found = GNUNET_YES;
          break;
        }
      }
      else
      {
        struct sockaddr_in6 *v6 = (struct sockaddr_in6 *) &addr;
        struct sockaddr_in6 *ds_v6 = (struct sockaddr_in6 *) &ds->ss;
 
        if (0 == memcmp (&v6->sin6_addr,
                         &ds_v6->sin6_addr,
                         sizeof (v6->sin6_addr)) &&
            (v6->sin6_port == ds_v6->sin6_port))
        {
          found = GNUNET_YES;
          break;
        }
 
      }
    }
    if (GNUNET_NO == found)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Received DNS response from server we never asked (ignored)\n");
 
      return GNUNET_NO;
    }
    if (sizeof(struct GNUNET_TUN_DnsHeader) > (size_t) r)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Received DNS response that is too small (%u bytes)\n"),
                  (unsigned int) r);
      return GNUNET_NO;
    }
    dns = (struct GNUNET_TUN_DnsHeader *) buf;
    if (NULL == rs->rc)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Request timeout or cancelled; ignoring reply\n");
      return GNUNET_NO;
    }
    rs->rc (rs->rc_cls, dns, r);
  }
  return GNUNET_OK;
}

References _, buf, ctx, GNUNET_DNSSTUB_RequestSocket::ctx, GNUNET_DNSSTUB_Context::dns_head, ds, GNUNET_ALIGN, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_get_fd(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_recvfrom(), GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, GNUNET_YES, len, GNUNET_DNSSTUB_RequestSocket::rc, and GNUNET_DNSSTUB_RequestSocket::rc_cls.

Referenced by read_response().

Here is the call graph for this function:

Here is the caller graph for this function:

read_response()

static void read_response ( void *  cls )

static

Read a DNS response from the (unhindered) UDP-Socket.

Parameters

cls	struct GNUNET_DNSSTUB_RequestSocket to read from

Definition at line 426 of file dnsstub.c.

{
  struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
  const struct GNUNET_SCHEDULER_TaskContext *tc;
 
  rs->read_task = NULL;
  tc = GNUNET_SCHEDULER_get_task_context ();
  /* read and process ready sockets */
  if ((NULL != rs->dnsout4) &&
      (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout4)) &&
      (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout4)))
    rs->dnsout4 = NULL;
  if ((NULL != rs->dnsout6) &&
      (GNUNET_NETWORK_fdset_isset (tc->read_ready, rs->dnsout6)) &&
      (GNUNET_SYSERR == do_dns_read (rs, rs->dnsout6)))
    rs->dnsout6 = NULL;
  /* re-schedule read task */
  schedule_read (rs);
}

References GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, do_dns_read(), GNUNET_NETWORK_fdset_isset(), GNUNET_SCHEDULER_get_task_context(), GNUNET_SYSERR, GNUNET_SCHEDULER_TaskContext::read_ready, GNUNET_DNSSTUB_RequestSocket::read_task, schedule_read(), and tc.

Referenced by schedule_read().

Here is the call graph for this function:

Here is the caller graph for this function:

schedule_read()

static void schedule_read ( struct GNUNET_DNSSTUB_RequestSocket *  rs )

static

Schedule read_response() task for rs.

Parameters

rs	request to schedule read operation for

Definition at line 403 of file dnsstub.c.

{
  struct GNUNET_NETWORK_FDSet *rset;
 
  if (NULL != rs->read_task)
    GNUNET_SCHEDULER_cancel (rs->read_task);
  rset = GNUNET_NETWORK_fdset_create ();
  if (NULL != rs->dnsout4)
    GNUNET_NETWORK_fdset_set (rset, rs->dnsout4);
  if (NULL != rs->dnsout6)
    GNUNET_NETWORK_fdset_set (rset, rs->dnsout6);
  rs->read_task =
    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                 GNUNET_TIME_UNIT_FOREVER_REL,
                                 rset,
                                 NULL,
                                 &read_response,
                                 rs);
  GNUNET_NETWORK_fdset_destroy (rset);
}

References GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, GNUNET_NETWORK_fdset_create(), GNUNET_NETWORK_fdset_destroy(), GNUNET_NETWORK_fdset_set(), GNUNET_SCHEDULER_add_select(), GNUNET_SCHEDULER_cancel(), GNUNET_SCHEDULER_PRIORITY_DEFAULT, GNUNET_TIME_UNIT_FOREVER_REL, read_response(), and GNUNET_DNSSTUB_RequestSocket::read_task.

Referenced by read_response(), and transmit_query().

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_query()

static void transmit_query ( void *  cls )

static

Task to (re)transmit the DNS query, possibly repeatedly until we succeed.

Parameters

cls	our struct GNUNET_DNSSTUB_RequestSocket *

Definition at line 454 of file dnsstub.c.

{
  struct GNUNET_DNSSTUB_RequestSocket *rs = cls;
  struct GNUNET_DNSSTUB_Context *ctx = rs->ctx;
  const struct sockaddr *sa;
  socklen_t salen;
  struct DnsServer *ds;
  struct GNUNET_NETWORK_Handle *dnsout;
 
  rs->retry_task =
    GNUNET_SCHEDULER_add_delayed (ctx->retry_freq, &transmit_query, rs);
  ds = rs->ds_pos;
  rs->ds_pos = ds->next;
  if (NULL == rs->ds_pos)
    rs->ds_pos = ctx->dns_head;
  GNUNET_assert (NULL != ds);
  dnsout = NULL;
  switch (ds->ss.ss_family)
  {
  case AF_INET:
    if (NULL == rs->dnsout4)
      rs->dnsout4 = open_socket (AF_INET);
    dnsout = rs->dnsout4;
    sa = (const struct sockaddr *) &ds->ss;
    salen = sizeof(struct sockaddr_in);
    break;
 
  case AF_INET6:
    if (NULL == rs->dnsout6)
      rs->dnsout6 = open_socket (AF_INET6);
    dnsout = rs->dnsout6;
    sa = (const struct sockaddr *) &ds->ss;
    salen = sizeof(struct sockaddr_in6);
    break;
 
  default:
    return;
  }
  if (NULL == dnsout)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Unable to use configure DNS server, skipping\n");
    return;
  }
  if (GNUNET_SYSERR == GNUNET_NETWORK_socket_sendto (dnsout,
                                                     rs->request,
                                                     rs->request_len,
                                                     sa,
                                                     salen))
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                _ ("Failed to send DNS request to %s: %s\n"),
                GNUNET_a2s (sa, salen),
                strerror (errno));
  else
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                _ ("Sent DNS request to %s\n"),
                GNUNET_a2s (sa, salen));
  schedule_read (rs);
}

References _, ctx, GNUNET_DNSSTUB_RequestSocket::ctx, GNUNET_DNSSTUB_Context::dns_head, GNUNET_DNSSTUB_RequestSocket::dnsout4, GNUNET_DNSSTUB_RequestSocket::dnsout6, ds, GNUNET_DNSSTUB_RequestSocket::ds_pos, GNUNET_a2s(), GNUNET_assert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_NETWORK_socket_sendto(), GNUNET_SCHEDULER_add_delayed(), GNUNET_SYSERR, open_socket(), GNUNET_DNSSTUB_RequestSocket::request, GNUNET_DNSSTUB_RequestSocket::request_len, GNUNET_DNSSTUB_Context::retry_freq, GNUNET_DNSSTUB_RequestSocket::retry_task, and schedule_read().

Referenced by GNUNET_DNSSTUB_resolve().

Here is the call graph for this function:

Here is the caller graph for this function: