gnunet-service-gns_interceptor.c File Reference

GNUnet GNS interceptor logic. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dns_service.h"
#include "gnunet-service-gns.h"
#include "gnunet-service-gns_resolver.h"
#include "gnunet-service-gns_interceptor.h"
#include "gns.h"

Include dependency graph for gnunet-service-gns_interceptor.c:

Go to the source code of this file.

Data Structures
struct	InterceptLookupHandle
	Handle to a DNS intercepted resolution request. More...

Macros
#define	MAX_RECURSION   256
	How deep do we allow recursions to go before we abort?

Functions
static void	reply_to_dns (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Reply to dns request with the result from our lookup.
static void	handle_dns_request (void *cls, struct GNUNET_DNS_RequestHandle *rh, size_t request_length, const char *request)
	The DNS request handler.
int	GNS_interceptor_init (const struct GNUNET_CONFIGURATION_Handle *c)
	Initialize DNS interceptor.
void	GNS_interceptor_done ()
	Disconnect from interceptor.

Variables
static struct GNUNET_DNS_Handle *	dns_handle
	Our handle to the DNS handler library.
static struct InterceptLookupHandle *	ilh_head
	Head of the DLL.
static struct InterceptLookupHandle *	ilh_tail
	Tail of the DLL.

Detailed Description

GNUnet GNS interceptor logic.

Author

Martin Schanzenbach

Christian Grothoff

Definition in file gnunet-service-gns_interceptor.c.

Macro Definition Documentation

MAX_RECURSION

#define MAX_RECURSION   256

How deep do we allow recursions to go before we abort?

Definition at line 38 of file gnunet-service-gns_interceptor.c.

Function Documentation

reply_to_dns()

static void reply_to_dns ( void *  cls, uint32_t  rd_count, const struct GNUNET_GNSRECORD_Data *  rd  )

static

Reply to dns request with the result from our lookup.

Parameters

cls	the closure to the request (an InterceptLookupHandle)
rd_count	the number of records to return
rd	the record data

Definition at line 98 of file gnunet-service-gns_interceptor.c.

{
  struct InterceptLookupHandle *ilh = cls;
  struct GNUNET_DNSPARSER_Packet *packet = ilh->packet;
  struct GNUNET_DNSPARSER_Query *query = &packet->queries[0];
  uint32_t i;
  size_t len;
  int ret;
  char *buf;
  unsigned int num_answers;
  unsigned int skipped_answers;
  unsigned int skipped_additional;
  size_t off = 0;
 
  /* Put records in the DNS packet */
  num_answers = 0;
  for (i = 0; i < rd_count; i++)
    if (rd[i].record_type == query->type)
      num_answers++;
  skipped_answers = 0;
  skipped_additional = 0;
 
  {
    struct GNUNET_DNSPARSER_Record answer_records[num_answers];
    struct GNUNET_DNSPARSER_Record additional_records[rd_count - num_answers];
 
    packet->answers = answer_records;
    packet->additional_records = additional_records;
    /* FIXME: need to handle #GNUNET_GNSRECORD_RF_SHADOW_RECORD option
       (by ignoring records where this flag is set if there is any
       other record of that type in the result set) */
    for (i = 0; i < rd_count; i++)
    {
      if (rd[i].record_type == query->type)
      {
        answer_records[i - skipped_answers].name = query->name;
        answer_records[i - skipped_answers].type = rd[i].record_type;
        switch (rd[i].record_type)
        {
        case GNUNET_DNSPARSER_TYPE_NS:
        case GNUNET_DNSPARSER_TYPE_CNAME:
        case GNUNET_DNSPARSER_TYPE_PTR:
          answer_records[i - skipped_answers].data.hostname
            = GNUNET_DNSPARSER_parse_name (rd[i].data,
                                           rd[i].data_size,
                                           &off);
          if ((off != rd[i].data_size) ||
              (NULL == answer_records[i].data.hostname))
          {
            GNUNET_break_op (0);
            skipped_answers++;
            continue;
          }
          break;
 
        case GNUNET_DNSPARSER_TYPE_SOA:
          answer_records[i - skipped_answers].data.soa
            = GNUNET_DNSPARSER_parse_soa (rd[i].data,
                                          rd[i].data_size,
                                          &off);
          if ((off != rd[i].data_size) ||
              (NULL == answer_records[i].data.soa))
          {
            GNUNET_break_op (0);
            skipped_answers++;
            continue;
          }
          break;
 
        case GNUNET_DNSPARSER_TYPE_SRV:
          /* FIXME: SRV is not yet supported */
          skipped_answers++;
          continue;
 
        case GNUNET_DNSPARSER_TYPE_URI:
          /* FIXME: URI is not yet supported */
          skipped_answers++;
          continue;
 
        case GNUNET_DNSPARSER_TYPE_MX:
          answer_records[i - skipped_answers].data.mx
            = GNUNET_DNSPARSER_parse_mx (rd[i].data,
                                         rd[i].data_size,
                                         &off);
          if ((off != rd[i].data_size) ||
              (NULL == answer_records[i].data.hostname))
          {
            GNUNET_break_op (0);
            skipped_answers++;
            continue;
          }
          break;
 
        default:
          answer_records[i - skipped_answers].data.raw.data_len = rd[i].
                                                                  data_size;
          answer_records[i - skipped_answers].data.raw.data = (char *) rd[i].
                                                              data;
          break;
        }
        GNUNET_break (0 == (rd[i - skipped_answers].flags
                            & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
        answer_records[i - skipped_answers].expiration_time.abs_value_us =
          rd[i].expiration_time;
        answer_records[i - skipped_answers].dns_traffic_class =
          GNUNET_TUN_DNS_CLASS_INTERNET;
      }
      else
      {
        additional_records[i - skipped_additional].name = query->name;
        additional_records[i - skipped_additional].type = rd[i].record_type;
        switch (rd[i].record_type)
        {
        case GNUNET_DNSPARSER_TYPE_NS:
        case GNUNET_DNSPARSER_TYPE_CNAME:
        case GNUNET_DNSPARSER_TYPE_PTR:
          additional_records[i - skipped_additional].data.hostname
            = GNUNET_DNSPARSER_parse_name (rd[i].data,
                                           rd[i].data_size,
                                           &off);
          if ((off != rd[i].data_size) ||
              (NULL == additional_records[i].data.hostname))
          {
            GNUNET_break_op (0);
            skipped_additional++;
            continue;
          }
          break;
 
        case GNUNET_DNSPARSER_TYPE_SOA:
          additional_records[i - skipped_additional].data.soa
            = GNUNET_DNSPARSER_parse_soa (rd[i].data,
                                          rd[i].data_size,
                                          &off);
          if ((off != rd[i].data_size) ||
              (NULL == additional_records[i].data.hostname))
          {
            GNUNET_break_op (0);
            skipped_additional++;
            continue;
          }
          break;
 
        case GNUNET_DNSPARSER_TYPE_MX:
          additional_records[i - skipped_additional].data.mx
            = GNUNET_DNSPARSER_parse_mx (rd[i].data,
                                         rd[i].data_size,
                                         &off);
          if ((off != rd[i].data_size) ||
              (NULL == additional_records[i].data.hostname))
          {
            GNUNET_break_op (0);
            skipped_additional++;
            continue;
          }
          break;
 
        case GNUNET_DNSPARSER_TYPE_SRV:
          /* FIXME: SRV is not yet supported */
          skipped_additional++;
          continue;
 
        case GNUNET_DNSPARSER_TYPE_URI:
          additional_records[i - skipped_additional].data.uri
            = GNUNET_DNSPARSER_parse_uri (rd[i].data,
                                          rd[i].data_size,
                                          &off);
          if ((off != rd[i].data_size) ||
              (NULL == additional_records[i].data.uri))
          {
            GNUNET_break_op (0);
            skipped_additional++;
            continue;
          }
          break;
 
        default:
          additional_records[i - skipped_additional].data.raw.data_len =
            rd[i].data_size;
          additional_records[i - skipped_additional].data.raw.data =
            (char *) rd[i].data;
          break;
        }
        GNUNET_break (0 == (rd[i - skipped_additional].flags
                            & GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION));
        additional_records[i - skipped_additional].expiration_time.abs_value_us
          =
            rd[i].expiration_time;
        additional_records[i - skipped_additional].dns_traffic_class =
          GNUNET_TUN_DNS_CLASS_INTERNET;
      }
    }
    packet->num_answers = num_answers - skipped_answers;
    packet->num_additional_records = rd_count - num_answers - skipped_additional
    ;
    packet->flags.authoritative_answer = 1;
    if (NULL == rd)
      packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NAME_ERROR;
    else
      packet->flags.return_code = GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR;
    packet->flags.query_or_response = 1;
    ret = GNUNET_DNSPARSER_pack (packet,
                                 1024, /* maximum allowed size for DNS reply */
                                 &buf,
                                 &len);
    if (GNUNET_OK != ret)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  _ ("Error converting GNS response to DNS response!\n"));
      if (GNUNET_NO == ret)
        GNUNET_free (buf);
    }
    else
    {
      GNUNET_DNS_request_answer (ilh->request_handle,
                                 len,
                                 buf);
      GNUNET_free (buf);
    }
    packet->num_answers = 0;
    packet->answers = NULL;
    packet->num_additional_records = 0;
    packet->additional_records = NULL;
    GNUNET_DNSPARSER_free_packet (packet);
  }
  GNUNET_CONTAINER_DLL_remove (ilh_head, ilh_tail, ilh);
  GNUNET_free (ilh);
}

References _, GNUNET_TIME_Absolute::abs_value_us, GNUNET_DNSPARSER_Packet::additional_records, GNUNET_DNSPARSER_Packet::answers, GNUNET_TUN_DnsFlags::authoritative_answer, data, GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, GNUNET_DNSPARSER_RawRecord::data_len, data_size, GNUNET_GNSRECORD_Data::data_size, GNUNET_DNSPARSER_Record::dns_traffic_class, GNUNET_DNSPARSER_Record::expiration_time, GNUNET_GNSRECORD_Data::expiration_time, GNUNET_DNSPARSER_Packet::flags, GNUNET_break, GNUNET_break_op, GNUNET_CONTAINER_DLL_remove, GNUNET_DNS_request_answer(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_pack(), GNUNET_DNSPARSER_parse_mx(), GNUNET_DNSPARSER_parse_name(), GNUNET_DNSPARSER_parse_soa(), GNUNET_DNSPARSER_parse_uri(), GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_DNSPARSER_TYPE_MX, GNUNET_DNSPARSER_TYPE_NS, GNUNET_DNSPARSER_TYPE_PTR, GNUNET_DNSPARSER_TYPE_SOA, GNUNET_DNSPARSER_TYPE_SRV, GNUNET_DNSPARSER_TYPE_URI, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_GNSRECORD_RF_RELATIVE_EXPIRATION, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_TUN_DNS_CLASS_INTERNET, GNUNET_TUN_DNS_RETURN_CODE_NAME_ERROR, GNUNET_TUN_DNS_RETURN_CODE_NO_ERROR, GNUNET_DNSPARSER_Record::hostname, ilh_head, ilh_tail, GNUNET_DNSPARSER_Record::mx, GNUNET_DNSPARSER_Query::name, GNUNET_DNSPARSER_Record::name, GNUNET_DNSPARSER_Packet::num_additional_records, GNUNET_DNSPARSER_Packet::num_answers, InterceptLookupHandle::packet, GNUNET_DNSPARSER_Packet::queries, GNUNET_TUN_DnsFlags::query_or_response, GNUNET_DNSPARSER_Record::raw, rd, rd_count, GNUNET_GNSRECORD_Data::record_type, InterceptLookupHandle::request_handle, ret, GNUNET_TUN_DnsFlags::return_code, GNUNET_DNSPARSER_Record::soa, GNUNET_DNSPARSER_Query::type, GNUNET_DNSPARSER_Record::type, and GNUNET_DNSPARSER_Record::uri.

Referenced by handle_dns_request().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_dns_request()

static void handle_dns_request ( void *  cls, struct GNUNET_DNS_RequestHandle *  rh, size_t  request_length, const char *  request  )

static

The DNS request handler.

Called for every incoming DNS request.

Parameters

cls	closure, unused
rh	request handle to user for reply
request_length	number of bytes in request
request	UDP payload of the DNS request

Definition at line 338 of file gnunet-service-gns_interceptor.c.

{
  struct GNUNET_DNSPARSER_Packet *p;
  struct InterceptLookupHandle *ilh;
  struct GNUNET_CRYPTO_PublicKey zone;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Hijacked a DNS request. Processing.\n");
  if (NULL == (p = GNUNET_DNSPARSER_parse (request, request_length)))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "Received malformed DNS packet, leaving it untouched.\n");
    GNUNET_DNS_request_forward (rh);
    return;
  }
 
  /* Check TLD and decide if we or legacy dns is responsible */
  if (1 != p->num_queries)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Not exactly one query in DNS packet. Forwarding untouched.\n");
    GNUNET_DNS_request_forward (rh);
    GNUNET_DNSPARSER_free_packet (p);
    return;
  }
 
  /* Check for GNS TLDs. */
  if (GNUNET_YES ==
      GNS_find_tld (GNS_get_tld (p->queries[0].name),
                    &zone))
  {
    /* Start resolution in GNS */
    ilh = GNUNET_new (struct InterceptLookupHandle);
    GNUNET_CONTAINER_DLL_insert (ilh_head,
                                 ilh_tail,
                                 ilh);
    ilh->packet = p;
    ilh->request_handle = rh;
    ilh->lookup = GNS_resolver_lookup (&zone,
                                       p->queries[0].type,
                                       p->queries[0].name,
                                       GNUNET_GNS_LO_DEFAULT,
                                       MAX_RECURSION,
                                       &reply_to_dns, ilh);
    return;
  }
  /* This request does not concern us. Forward to real DNS. */
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Request for `%s' is forwarded to DNS untouched.\n",
              p->queries[0].name);
  GNUNET_DNS_request_forward (rh);
  GNUNET_DNSPARSER_free_packet (p);
}

References GNS_find_tld(), GNS_get_tld(), GNS_resolver_lookup(), GNUNET_CONTAINER_DLL_insert, GNUNET_DNS_request_forward(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_parse(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_WARNING, GNUNET_GNS_LO_DEFAULT, GNUNET_log, GNUNET_new, GNUNET_YES, ilh_head, ilh_tail, InterceptLookupHandle::lookup, MAX_RECURSION, p, InterceptLookupHandle::packet, reply_to_dns(), request, and InterceptLookupHandle::request_handle.

Referenced by GNS_interceptor_init().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_interceptor_init()

int GNS_interceptor_init

(

const struct GNUNET_CONFIGURATION_Handle *

c

)

Initialize DNS interceptor.

Parameters

c	the configuration

Returns

GNUNET_YES on success GNUNET_SYSERR on error

Definition at line 397 of file gnunet-service-gns_interceptor.c.

{
  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
              "DNS hijacking enabled. Connecting to DNS service.\n");
  dns_handle = GNUNET_DNS_connect (c,
                                   GNUNET_DNS_FLAG_PRE_RESOLUTION,
                                   &handle_dns_request,
                                   NULL);
  if (NULL == dns_handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to the DNS service!\n"));
    return GNUNET_SYSERR;
  }
  return GNUNET_YES;
}

References _, dns_handle, GNUNET_DNS_connect(), GNUNET_DNS_FLAG_PRE_RESOLUTION, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_SYSERR, GNUNET_YES, and handle_dns_request().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_interceptor_done()

void GNS_interceptor_done

(

void

)

Disconnect from interceptor.

Stops the interceptor.

Definition at line 419 of file gnunet-service-gns_interceptor.c.

{
  struct InterceptLookupHandle *ilh;
 
  while (NULL != (ilh = ilh_head))
  {
    GNUNET_CONTAINER_DLL_remove (ilh_head,
                                 ilh_tail,
                                 ilh);
    GNS_resolver_lookup_cancel (ilh->lookup);
    GNUNET_DNS_request_drop (ilh->request_handle);
    GNUNET_DNSPARSER_free_packet (ilh->packet);
    GNUNET_free (ilh);
  }
  if (NULL != dns_handle)
  {
    GNUNET_DNS_disconnect (dns_handle);
    dns_handle = NULL;
  }
}

References dns_handle, GNS_resolver_lookup_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_DNS_disconnect(), GNUNET_DNS_request_drop(), GNUNET_DNSPARSER_free_packet(), GNUNET_free, ilh_head, ilh_tail, InterceptLookupHandle::lookup, InterceptLookupHandle::packet, and InterceptLookupHandle::request_handle.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

dns_handle

struct GNUNET_DNS_Handle* dns_handle

static

Our handle to the DNS handler library.

Definition at line 77 of file gnunet-service-gns_interceptor.c.

Referenced by GNS_interceptor_done(), and GNS_interceptor_init().

ilh_head

struct InterceptLookupHandle* ilh_head

static

Head of the DLL.

Definition at line 82 of file gnunet-service-gns_interceptor.c.

Referenced by GNS_interceptor_done(), handle_dns_request(), and reply_to_dns().

ilh_tail

struct InterceptLookupHandle* ilh_tail

static

Tail of the DLL.

Definition at line 87 of file gnunet-service-gns_interceptor.c.

Referenced by GNS_interceptor_done(), handle_dns_request(), and reply_to_dns().