gnunet-daemon-pt.c File Reference

tool to manipulate DNS and VPN services to perform protocol translation (IPvX over GNUnet) More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dns_service.h"
#include "gnunet_cadet_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_vpn_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_applications.h"
#include "block_dns.h"

Include dependency graph for gnunet-daemon-pt.c:

Go to the source code of this file.

Data Structures
struct	ReplyContext
	Information tracked per DNS reply that we are processing. More...
struct	CadetExit
	Handle to a peer that advertised that it is willing to serve as a DNS exit. More...
struct	RequestContext
	State we keep for a request that is going out via CADET. More...
struct	DnsResponseMessage
	Message with a DNS response. More...

Macros
#define	TIMEOUT   GNUNET_TIME_UNIT_MINUTES
	After how long do we time out if we could not get an IP from VPN or CADET? More...
#define	MAX_DNS_SIZE   (8 * 1024)
	How many bytes of payload do we allow at most for a DNS reply? Given that this is pretty much limited to loopback, we can be pretty high (Linux loopback defaults to 16k, most local UDP packets should survive up to 9k (NFS), so 8k should be pretty safe in general). More...
#define	MAX_OPEN_TUNNELS   4
	How many channels do we open at most at the same time? More...

Enumerations
enum	RequestGroup { ANSWERS = 0 , AUTHORITY_RECORDS = 1 , ADDITIONAL_RECORDS = 2 , END = 3 }
	Which group of DNS records are we currently processing? More...

Functions
static void	try_open_exit (void)
	We are short on cadet exits, try to open another one. More...
static uint32_t	get_channel_weight (struct CadetExit *exit)
	Compute the weight of the given exit. More...
static struct CadetExit *	choose_exit ()
	Choose a cadet exit for a DNS request. More...
static void	finish_request (struct ReplyContext *rc)
	We're done modifying all records in the response. More...
static void	submit_request (struct ReplyContext *rc)
	Process the next record of the given request context. More...
static void	vpn_allocation_callback (void *cls, int af, const void *address)
	Callback invoked from the VPN service once a redirection is available. More...
static void	modify_address (struct ReplyContext *rc, struct GNUNET_DNSPARSER_Record *rec)
	Modify the given DNS record by asking VPN to create a channel to the given address. More...
static int	work_test (const struct GNUNET_DNSPARSER_Record *ra, unsigned int ra_len)
	Test if any of the given records need protocol-translation work. More...
static void	dns_post_request_handler (void *cls, struct GNUNET_DNS_RequestHandle *rh, size_t request_length, const char *request)
	This function is called AFTER we got an IP address for a DNS request. More...
static void	timeout_request (void *cls)
	Task run if the time to answer a DNS request via CADET is over. More...
static void	dns_pre_request_handler (void *cls, struct GNUNET_DNS_RequestHandle *rh, size_t request_length, const char *request)
	This function is called before the DNS request has been given to a "local" DNS resolver. More...
static GNUNET_NETWORK_STRUCT_END int	check_dns_response (void *cls, const struct DnsResponseMessage *msg)
	Process a request via cadet to perform a DNS query. More...
static void	handle_dns_response (void *cls, const struct DnsResponseMessage *msg)
	Process a request via cadet to perform a DNS query. More...
static void	abort_all_requests (struct CadetExit *exit)
	Abort all pending DNS requests with the given cadet exit. More...
static void	cleanup (void *cls)
	Function scheduled as very last function, cleans up after us. More...
static void	cadet_channel_end_cb (void *cls, const struct GNUNET_CADET_Channel *channel)
	Function called whenever a channel is destroyed. More...
static void	channel_idle_notify_cb (void *cls, const struct GNUNET_CADET_Channel *channel, int window_size)
	Function called whenever a channel has excess capacity. More...
static void	handle_dht_result (void *cls, struct GNUNET_TIME_Absolute exp, const struct GNUNET_HashCode *key, const struct GNUNET_PeerIdentity *trunc_peer, const struct GNUNET_DHT_PathElement *get_path, unsigned int get_path_length, const struct GNUNET_DHT_PathElement *put_path, unsigned int put_path_length, enum GNUNET_BLOCK_Type type, size_t size, const void *data)
	Function called whenever we find an advertisement for a DNS exit in the DHT. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg_)
	Main function that will be run by the scheduler. More...
int	main (int argc, char *const *argv)
	The main function. More...

Variables
static struct CadetExit *	exit_head
	Head of DLL of cadet exits. More...
static struct CadetExit *	exit_tail
	Tail of DLL of cadet exits. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	The handle to the configuration used throughout the process. More...
static struct GNUNET_VPN_Handle *	vpn_handle
	The handle to the VPN. More...
static struct GNUNET_CADET_Handle *	cadet_handle
	The handle to the CADET service. More...
static struct GNUNET_STATISTICS_Handle *	stats
	Statistics. More...
static struct GNUNET_DNS_Handle *	dns_post_handle
	The handle to DNS post-resolution modifications. More...
static struct GNUNET_DNS_Handle *	dns_pre_handle
	The handle to DNS pre-resolution modifications. More...
static struct GNUNET_DHT_Handle *	dht
	Handle to access the DHT. More...
static struct GNUNET_DHT_GetHandle *	dht_get
	Our DHT GET operation to find DNS exits. More...
static int	ipv4_pt
	Are we doing IPv4-pt? More...
static int	ipv6_pt
	Are we doing IPv6-pt? More...
static int	dns_channel
	Are we channeling DNS queries? More...
static unsigned int	dns_exit_available
	Number of DNS exit peers we currently have in the cadet channel. More...

Detailed Description

tool to manipulate DNS and VPN services to perform protocol translation (IPvX over GNUnet)

Author

Christian Grothoff

Definition in file gnunet-daemon-pt.c.

Macro Definition Documentation

TIMEOUT

#define TIMEOUT   GNUNET_TIME_UNIT_MINUTES

After how long do we time out if we could not get an IP from VPN or CADET?

Definition at line 39 of file gnunet-daemon-pt.c.

MAX_DNS_SIZE

#define MAX_DNS_SIZE   (8 * 1024)

How many bytes of payload do we allow at most for a DNS reply? Given that this is pretty much limited to loopback, we can be pretty high (Linux loopback defaults to 16k, most local UDP packets should survive up to 9k (NFS), so 8k should be pretty safe in general).

Definition at line 48 of file gnunet-daemon-pt.c.

MAX_OPEN_TUNNELS

#define MAX_OPEN_TUNNELS   4

How many channels do we open at most at the same time?

Definition at line 53 of file gnunet-daemon-pt.c.

Enumeration Type Documentation

RequestGroup

enum RequestGroup

Which group of DNS records are we currently processing?

Enumerator
ANSWERS	DNS answers.
AUTHORITY_RECORDS	DNS authority records.
ADDITIONAL_RECORDS	DNS additional records.
END	We're done processing.

Definition at line 59 of file gnunet-daemon-pt.c.

{
  ANSWERS = 0,
 
  AUTHORITY_RECORDS = 1,
 
  ADDITIONAL_RECORDS = 2,
 
  END = 3
};

Function Documentation

try_open_exit()

static void try_open_exit ( void  )

static

We are short on cadet exits, try to open another one.

Definition at line 1052 of file gnunet-daemon-pt.c.

{
  struct CadetExit *pos;
  uint32_t candidate_count;
  uint32_t candidate_selected;
  struct GNUNET_HashCode port;
 
  GNUNET_CRYPTO_hash (GNUNET_APPLICATION_PORT_INTERNET_RESOLVER,
                      strlen (GNUNET_APPLICATION_PORT_INTERNET_RESOLVER),
                      &port);
  candidate_count = 0;
  for (pos = exit_head; NULL != pos; pos = pos->next)
    if (NULL == pos->cadet_channel)
      candidate_count++;
  if (0 == candidate_count)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                "No DNS exits available yet.\n");
    return;
  }
  candidate_selected = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                                                 candidate_count);
  candidate_count = 0;
  for (pos = exit_head; NULL != pos; pos = pos->next)
    if (NULL == pos->cadet_channel)
    {
      candidate_count++;
      if (candidate_selected < candidate_count)
      {
        struct GNUNET_MQ_MessageHandler cadet_handlers[] = {
          GNUNET_MQ_hd_var_size (dns_response,
                                 GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET,
                                 struct DnsResponseMessage,
                                 pos),
          GNUNET_MQ_handler_end ()
        };
 
 
        /* move to the head of the DLL */
        pos->cadet_channel
          = GNUNET_CADET_channel_create (cadet_handle,
                                         pos,
                                         &pos->peer,
                                         &port,
                                         &channel_idle_notify_cb,
                                         &cadet_channel_end_cb,
                                         cadet_handlers);
        if (NULL == pos->cadet_channel)
        {
          GNUNET_break (0);
          continue;
        }
        GNUNET_CONTAINER_DLL_remove (exit_head,
                                     exit_tail,
                                     pos);
        GNUNET_CONTAINER_DLL_insert (exit_head,
                                     exit_tail,
                                     pos);
        dns_exit_available++;
        return;
      }
    }
  GNUNET_assert (NULL == exit_head);
}

References CadetExit::cadet_channel, cadet_channel_end_cb(), cadet_handle, channel_idle_notify_cb(), dns_exit_available, exit_head, exit_tail, GNUNET_APPLICATION_PORT_INTERNET_RESOLVER, GNUNET_assert, GNUNET_break, GNUNET_CADET_channel_create(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_CRYPTO_hash(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_MESSAGE_TYPE_VPN_DNS_FROM_INTERNET, GNUNET_MQ_handler_end, GNUNET_MQ_hd_var_size, CadetExit::next, CadetExit::peer, and port.

Referenced by cadet_channel_end_cb(), handle_dht_result(), and timeout_request().

Here is the call graph for this function:

Here is the caller graph for this function:

get_channel_weight()

static uint32_t get_channel_weight ( struct CadetExit *  exit )

static

Compute the weight of the given exit.

The higher the weight, the more likely it will be that the channel will be chosen. A weigt of zero means that we should close the channel as it is so bad, that we should not use it.

Parameters

exit	exit to calculate the weight for

Returns

weight of the channel

Definition at line 319 of file gnunet-daemon-pt.c.

{
  uint32_t dropped;
  uint32_t drop_percent;
  uint32_t good_percent;
 
  GNUNET_assert (exit->num_transmitted >= exit->num_answered);
  dropped = exit->num_transmitted - exit->num_answered;
  if (exit->num_transmitted > 0)
    drop_percent = (uint32_t) ((100LL * dropped) / exit->num_transmitted);
  else
    drop_percent = 50; /* no data */
  if ((exit->num_transmitted > 20) &&
      (drop_percent > 25))
    return 0; /* statistically significant, and > 25% loss, die */
  good_percent = 100 - drop_percent;
  GNUNET_assert (0 != good_percent);
  if (UINT32_MAX / good_percent / good_percent < exit->num_transmitted)
    return UINT32_MAX; /* formula below would overflow */
  return 1 + good_percent * good_percent * exit->num_transmitted;
}

References drop_percent, GNUNET_assert, CadetExit::num_answered, and CadetExit::num_transmitted.

Referenced by choose_exit(), and timeout_request().

Here is the caller graph for this function:

choose_exit()

static struct CadetExit* choose_exit ( )

static

Choose a cadet exit for a DNS request.

We try to use a channel that is reliable and currently available. All existing channels are given a base weight of 1, plus a score relating to the total number of queries answered in relation to the total number of queries we sent to that channel. That score is doubled if the channel is currently idle.

Returns

NULL if no exit is known, otherwise the exit that we should use to queue a message with

Definition at line 354 of file gnunet-daemon-pt.c.

{
  struct CadetExit *pos;
  uint64_t total_transmitted;
  uint64_t selected_offset;
  uint32_t channel_weight;
 
  total_transmitted = 0;
  for (pos = exit_head; NULL != pos; pos = pos->next)
  {
    if (NULL == pos->cadet_channel)
      break;
    channel_weight = get_channel_weight (pos);
    total_transmitted += channel_weight;
    /* double weight for idle channels */
    if (0 != pos->idle)
      total_transmitted += channel_weight;
  }
  if (0 == total_transmitted)
  {
    /* no channels available, or only a very bad one... */
    return exit_head;
  }
  selected_offset = GNUNET_CRYPTO_random_u64 (GNUNET_CRYPTO_QUALITY_WEAK,
                                              total_transmitted);
  total_transmitted = 0;
  for (pos = exit_head; NULL != pos; pos = pos->next)
  {
    if (NULL == pos->cadet_channel)
      break;
    channel_weight = get_channel_weight (pos);
    total_transmitted += channel_weight;
    /* double weight for idle channels */
    if (0 != pos->idle)
      total_transmitted += channel_weight;
    if (total_transmitted > selected_offset)
      return pos;
  }
  GNUNET_break (0);
  return NULL;
}

References CadetExit::cadet_channel, exit_head, get_channel_weight(), GNUNET_break, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), CadetExit::idle, and CadetExit::next.

Referenced by cadet_channel_end_cb(), and dns_pre_request_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

finish_request()

static void finish_request ( struct ReplyContext *  rc )

static

We're done modifying all records in the response.

Submit the reply and free the resources of the rc.

Parameters

rc	context to process

Definition at line 404 of file gnunet-daemon-pt.c.

{
  char *buf;
  size_t buf_len;
 
  if (GNUNET_SYSERR ==
      GNUNET_DNSPARSER_pack (rc->dns,
                             MAX_DNS_SIZE,
                             &buf,
                             &buf_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to pack DNS request.  Dropping.\n"));
    GNUNET_DNS_request_drop (rc->rh);
  }
  else
  {
    GNUNET_STATISTICS_update (stats,
                              gettext_noop ("# DNS requests mapped to VPN"),
                              1, GNUNET_NO);
    GNUNET_DNS_request_answer (rc->rh,
                               buf_len,
                               buf);
    GNUNET_free (buf);
  }
  GNUNET_DNSPARSER_free_packet (rc->dns);
  GNUNET_free (rc);
}

References _, buf, ReplyContext::dns, gettext_noop, GNUNET_DNS_request_answer(), GNUNET_DNS_request_drop(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_pack(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_SYSERR, MAX_DNS_SIZE, ReplyContext::rh, and stats.

Referenced by submit_request().

Here is the call graph for this function:

Here is the caller graph for this function:

submit_request()

static void submit_request ( struct ReplyContext *  rc )

static

Process the next record of the given request context.

When done, submit the reply and free the resources of the rc.

Parameters

rc	context to process

Definition at line 555 of file gnunet-daemon-pt.c.

{
  struct GNUNET_DNSPARSER_Record *ra;
  unsigned int ra_len;
  unsigned int i;
 
  while (1)
  {
    switch (rc->group)
    {
    case ANSWERS:
      ra = rc->dns->answers;
      ra_len = rc->dns->num_answers;
      break;
 
    case AUTHORITY_RECORDS:
      ra = rc->dns->authority_records;
      ra_len = rc->dns->num_authority_records;
      break;
 
    case ADDITIONAL_RECORDS:
      ra = rc->dns->additional_records;
      ra_len = rc->dns->num_additional_records;
      break;
 
    case END:
      finish_request (rc);
      return;
 
    default:
      GNUNET_assert (0);
    }
    for (i = rc->offset; i < ra_len; i++)
    {
      switch (ra[i].type)
      {
      case GNUNET_DNSPARSER_TYPE_A:
        if (ipv4_pt)
        {
          rc->offset = i + 1;
          modify_address (rc,
                          &ra[i]);
          return;
        }
        break;
 
      case GNUNET_DNSPARSER_TYPE_AAAA:
        if (ipv6_pt)
        {
          rc->offset = i + 1;
          modify_address (rc,
                          &ra[i]);
          return;
        }
        break;
      }
    }
    rc->group++;
  }
}

References GNUNET_DNSPARSER_Packet::additional_records, ADDITIONAL_RECORDS, GNUNET_DNSPARSER_Packet::answers, ANSWERS, GNUNET_DNSPARSER_Packet::authority_records, AUTHORITY_RECORDS, ReplyContext::dns, END, finish_request(), GNUNET_assert, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, ReplyContext::group, ipv4_pt, ipv6_pt, modify_address(), GNUNET_DNSPARSER_Packet::num_additional_records, GNUNET_DNSPARSER_Packet::num_answers, GNUNET_DNSPARSER_Packet::num_authority_records, ReplyContext::offset, and type.

Referenced by dns_post_request_handler(), and vpn_allocation_callback().

Here is the call graph for this function:

Here is the caller graph for this function:

vpn_allocation_callback()

static void vpn_allocation_callback ( void *  cls, int  af, const void *  address  )

static

Callback invoked from the VPN service once a redirection is available.

Provides the IP address that can now be used to reach the requested destination. We substitute the active record and then continue with 'submit_request' to look at the other records.

Parameters

cls	our struct ReplyContext
af	address family, AF_INET or AF_INET6; AF_UNSPEC on error; will match 'result_af' from the request
address	IP address (struct in_addr or struct in_addr6, depending on 'af') that the VPN allocated for the redirection; traffic to this IP will now be redirected to the specified target peer; NULL on error

Definition at line 461 of file gnunet-daemon-pt.c.

{
  struct ReplyContext *rc = cls;
 
  rc->rr = NULL;
  if (af == AF_UNSPEC)
  {
    GNUNET_DNS_request_drop (rc->rh);
    GNUNET_DNSPARSER_free_packet (rc->dns);
    GNUNET_free (rc);
    return;
  }
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# DNS records modified"),
                            1,
                            GNUNET_NO);
  switch (rc->rec->type)
  {
  case GNUNET_DNSPARSER_TYPE_A:
    GNUNET_assert (AF_INET == af);
    GNUNET_memcpy (rc->rec->data.raw.data,
                   address,
                   sizeof(struct in_addr));
    break;
 
  case GNUNET_DNSPARSER_TYPE_AAAA:
    GNUNET_assert (AF_INET6 == af);
    GNUNET_memcpy (rc->rec->data.raw.data,
                   address,
                   sizeof(struct in6_addr));
    break;
 
  default:
    GNUNET_assert (0);
    return;
  }
  rc->rec = NULL;
  submit_request (rc);
}

References address, GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, ReplyContext::dns, gettext_noop, GNUNET_assert, GNUNET_DNS_request_drop(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_free, GNUNET_memcpy, GNUNET_NO, GNUNET_STATISTICS_update(), GNUNET_DNSPARSER_Record::raw, ReplyContext::rec, ReplyContext::rh, ReplyContext::rr, stats, submit_request(), and GNUNET_DNSPARSER_Record::type.

Referenced by modify_address().

Here is the call graph for this function:

Here is the caller graph for this function:

modify_address()

static void modify_address ( struct ReplyContext *  rc, struct GNUNET_DNSPARSER_Record *  rec  )

static

Modify the given DNS record by asking VPN to create a channel to the given address.

When done, continue with submitting other records from the request context ('submit_request' is our continuation).

Parameters

rc	context to process
rec	record to modify

Definition at line 514 of file gnunet-daemon-pt.c.

{
  int af;
 
  switch (rec->type)
  {
  case GNUNET_DNSPARSER_TYPE_A:
    af = AF_INET;
    GNUNET_assert (rec->data.raw.data_len == sizeof(struct in_addr));
    break;
 
  case GNUNET_DNSPARSER_TYPE_AAAA:
    af = AF_INET6;
    GNUNET_assert (rec->data.raw.data_len == sizeof(struct in6_addr));
    break;
 
  default:
    GNUNET_assert (0);
    return;
  }
  rc->rec = rec;
  rc->rr = GNUNET_VPN_redirect_to_ip (vpn_handle,
                                      af,
                                      af,
                                      rec->data.raw.data,
                                      GNUNET_TIME_relative_to_absolute (
                                        TIMEOUT),
                                      &vpn_allocation_callback,
                                      rc);
}

References GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, GNUNET_DNSPARSER_RawRecord::data_len, GNUNET_assert, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_TIME_relative_to_absolute(), GNUNET_VPN_redirect_to_ip(), GNUNET_DNSPARSER_Record::raw, ReplyContext::rec, ReplyContext::rr, TIMEOUT, GNUNET_DNSPARSER_Record::type, vpn_allocation_callback(), and vpn_handle.

Referenced by submit_request().

Here is the call graph for this function:

Here is the caller graph for this function:

work_test()

static int work_test ( const struct GNUNET_DNSPARSER_Record *  ra, unsigned int  ra_len  )

static

Test if any of the given records need protocol-translation work.

Parameters

ra	array of records
ra_len	number of entries in ra

Returns

GNUNET_YES if any of the given records require protocol-translation

Definition at line 625 of file gnunet-daemon-pt.c.

{
  unsigned int i;
 
  for (i = 0; i < ra_len; i++)
  {
    switch (ra[i].type)
    {
    case GNUNET_DNSPARSER_TYPE_A:
      if (ipv4_pt)
        return GNUNET_YES;
      break;
 
    case GNUNET_DNSPARSER_TYPE_AAAA:
      if (ipv6_pt)
        return GNUNET_YES;
      break;
    }
  }
  return GNUNET_NO;
}

References GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_NO, GNUNET_YES, ipv4_pt, ipv6_pt, and type.

Referenced by dns_post_request_handler().

Here is the caller graph for this function:

dns_post_request_handler()

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

static

This function is called AFTER we got an IP address for a DNS request.

Now, the PT daemon has the chance to substitute the IP address with one from the VPN range to channel requests destined for this IP address via VPN and CADET.

Parameters

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

Definition at line 661 of file gnunet-daemon-pt.c.

{
  struct GNUNET_DNSPARSER_Packet *dns;
  struct ReplyContext *rc;
  int work;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# DNS replies intercepted"),
                            1, GNUNET_NO);
  dns = GNUNET_DNSPARSER_parse (request,
                                request_length);
  if (NULL == dns)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to parse DNS request.  Dropping.\n"));
    GNUNET_DNS_request_drop (rh);
    return;
  }
  work = GNUNET_NO;
  work |= work_test (dns->answers,
                     dns->num_answers);
  work |= work_test (dns->authority_records,
                     dns->num_authority_records);
  work |= work_test (dns->additional_records,
                     dns->num_additional_records);
  if (! work)
  {
    GNUNET_DNS_request_forward (rh);
    GNUNET_DNSPARSER_free_packet (dns);
    return;
  }
  rc = GNUNET_new (struct ReplyContext);
  rc->rh = rh;
  rc->dns = dns;
  rc->offset = 0;
  rc->group = ANSWERS;
  submit_request (rc);
}

References _, GNUNET_DNSPARSER_Packet::additional_records, GNUNET_DNSPARSER_Packet::answers, ANSWERS, GNUNET_DNSPARSER_Packet::authority_records, ReplyContext::dns, gettext_noop, GNUNET_DNS_request_drop(), GNUNET_DNS_request_forward(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_parse(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_STATISTICS_update(), ReplyContext::group, GNUNET_DNSPARSER_Packet::num_additional_records, GNUNET_DNSPARSER_Packet::num_answers, GNUNET_DNSPARSER_Packet::num_authority_records, ReplyContext::offset, request, ReplyContext::rh, stats, submit_request(), work(), and work_test().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

timeout_request()

static void timeout_request ( void *  cls )

static

Task run if the time to answer a DNS request via CADET is over.

Parameters

cls	the struct RequestContext to abort

Definition at line 710 of file gnunet-daemon-pt.c.

{
  struct RequestContext *rc = cls;
  struct CadetExit *exit = rc->exit;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# DNS requests dropped (timeout)"),
                            1,
                            GNUNET_NO);
  GNUNET_DNS_request_drop (rc->rh);
  GNUNET_free (rc);
  if ((0 == get_channel_weight (exit)) &&
      (NULL == exit->receive_queue_head))
  {
    /* this straw broke the camel's back: this channel now has
       such a low score that it will not be used; close it! */
    GNUNET_CADET_channel_destroy (exit->cadet_channel);
    exit->cadet_channel = NULL;
    GNUNET_CONTAINER_DLL_remove (exit_head,
                                 exit_tail,
                                 exit);
    GNUNET_CONTAINER_DLL_insert_tail (exit_head,
                                      exit_tail,
                                      exit);
    /* go back to semi-innocent: mark as not great, but
       avoid a prohibitively negative score (see
     #get_channel_weight(), which checks for a certain
       minimum number of transmissions before making
       up an opinion) */exit->num_transmitted = 5;
    exit->num_answered = 0;
    dns_exit_available--;
    /* now try to open an alternative exit */
    try_open_exit ();
  }
}

References CadetExit::cadet_channel, dns_exit_available, RequestContext::exit, exit_head, exit_tail, get_channel_weight(), gettext_noop, GNUNET_CADET_channel_destroy(), GNUNET_CONTAINER_DLL_insert_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_DNS_request_drop(), GNUNET_free, GNUNET_NO, GNUNET_STATISTICS_update(), CadetExit::num_answered, CadetExit::num_transmitted, CadetExit::receive_queue_head, RequestContext::rh, stats, and try_open_exit().

Referenced by dns_pre_request_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

dns_pre_request_handler()

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

static

This function is called before the DNS request has been given to a "local" DNS resolver.

Channeling for DNS requests was enabled, so we now need to send the request via some CADET channel to a DNS EXIT for resolution.

Parameters

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

Definition at line 759 of file gnunet-daemon-pt.c.

{
  struct RequestContext *rc;
  struct GNUNET_MQ_Envelope *env;
  struct GNUNET_MessageHeader *hdr;
  struct GNUNET_TUN_DnsHeader dns;
  struct CadetExit *exit;
 
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# DNS requests intercepted"),
                            1, GNUNET_NO);
  if (0 == dns_exit_available)
  {
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "# DNS requests dropped (DNS cadet channel down)"),
                              1, GNUNET_NO);
    GNUNET_DNS_request_drop (rh);
    return;
  }
  if (request_length < sizeof(dns))
  {
    GNUNET_STATISTICS_update (stats,
                              gettext_noop (
                                "# DNS requests dropped (malformed)"),
                              1, GNUNET_NO);
    GNUNET_DNS_request_drop (rh);
    return;
  }
  exit = choose_exit ();
  GNUNET_assert (NULL != exit);
  GNUNET_assert (NULL != exit->cadet_channel);
 
  env = GNUNET_MQ_msg_extra (hdr,
                             request_length,
                             GNUNET_MESSAGE_TYPE_VPN_DNS_TO_INTERNET);
  GNUNET_memcpy (&hdr[1],
                 request,
                 request_length);
  rc = GNUNET_new (struct RequestContext);
  rc->exit = exit;
  rc->rh = rh;
  rc->timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                                                   &timeout_request,
                                                   rc);
  GNUNET_memcpy (&dns,
                 request,
                 sizeof(dns));
  rc->dns_id = dns.id;
  rc->env = env;
  GNUNET_CONTAINER_DLL_remove (exit->receive_queue_head,
                               exit->receive_queue_tail,
                               rc);
  if (0 < exit->idle)
    exit->idle--;
  exit->num_transmitted++;
  GNUNET_MQ_send (GNUNET_CADET_get_mq (exit->cadet_channel),
                  GNUNET_MQ_env_copy (env));
}

References CadetExit::cadet_channel, choose_exit(), dns_exit_available, RequestContext::dns_id, env, RequestContext::env, RequestContext::exit, gettext_noop, GNUNET_assert, GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_remove, GNUNET_DNS_request_drop(), GNUNET_memcpy, GNUNET_MESSAGE_TYPE_VPN_DNS_TO_INTERNET, GNUNET_MQ_env_copy(), GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_new, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_TUN_DnsHeader::id, CadetExit::idle, CadetExit::num_transmitted, CadetExit::receive_queue_head, CadetExit::receive_queue_tail, request, RequestContext::rh, stats, TIMEOUT, timeout_request(), and RequestContext::timeout_task.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

check_dns_response()

static GNUNET_NETWORK_STRUCT_END int check_dns_response ( void *  cls, const struct DnsResponseMessage *  msg  )

static

Process a request via cadet to perform a DNS query.

Parameters

cls	the struct CadetExit which got the message
msg	the actual message

Returns

GNUNET_OK to keep the connection open, GNUNET_SYSERR to close it (signal serious error)

Definition at line 854 of file gnunet-daemon-pt.c.

{
  return GNUNET_OK; /* all OK */
}

References GNUNET_OK.

handle_dns_response()

static void handle_dns_response ( void *  cls, const struct DnsResponseMessage *  msg  )

static

Process a request via cadet to perform a DNS query.

Parameters

cls	the struct CadetExit which got the message
msg	the actual message

Definition at line 868 of file gnunet-daemon-pt.c.

{
  struct CadetExit *exit = cls;
  size_t mlen;
  struct RequestContext *rc;
 
  mlen = ntohs (msg->header.size) - sizeof(*msg);
  for (rc = exit->receive_queue_head; NULL != rc; rc = rc->next)
  {
    if (msg->dns.id == rc->dns_id)
    {
      GNUNET_STATISTICS_update (stats,
                                gettext_noop ("# DNS replies received"),
                                1,
                                GNUNET_NO);
      GNUNET_DNS_request_answer (rc->rh,
                                 mlen + sizeof(struct GNUNET_TUN_DnsHeader),
                                 (const void *) &msg->dns);
      GNUNET_CONTAINER_DLL_remove (exit->receive_queue_head,
                                   exit->receive_queue_tail,
                                   rc);
      GNUNET_SCHEDULER_cancel (rc->timeout_task);
      GNUNET_MQ_discard (rc->env);
      GNUNET_free (rc);
      exit->num_answered++;
      return;
    }
  }
  GNUNET_STATISTICS_update (stats,
                            gettext_noop ("# DNS replies dropped (too late?)"),
                            1, GNUNET_NO);
}

References RequestContext::dns_id, RequestContext::env, RequestContext::exit, gettext_noop, GNUNET_CONTAINER_DLL_remove, GNUNET_DNS_request_answer(), GNUNET_free, GNUNET_MQ_discard(), GNUNET_NO, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), RequestContext::mlen, msg, RequestContext::next, CadetExit::num_answered, CadetExit::receive_queue_head, CadetExit::receive_queue_tail, RequestContext::rh, GNUNET_MessageHeader::size, stats, and RequestContext::timeout_task.

Here is the call graph for this function:

abort_all_requests()

static void abort_all_requests ( struct CadetExit *  exit )

static

Abort all pending DNS requests with the given cadet exit.

Parameters

exit	cadet exit to abort requests for

Definition at line 909 of file gnunet-daemon-pt.c.

{
  struct RequestContext *rc;
 
  while (NULL != (rc = exit->receive_queue_head))
  {
    GNUNET_CONTAINER_DLL_remove (exit->receive_queue_head,
                                 exit->receive_queue_tail,
                                 rc);
    GNUNET_DNS_request_drop (rc->rh);
    GNUNET_SCHEDULER_cancel (rc->timeout_task);
    GNUNET_MQ_discard (rc->env);
    GNUNET_free (rc);
  }
}

References RequestContext::env, RequestContext::exit, GNUNET_CONTAINER_DLL_remove, GNUNET_DNS_request_drop(), GNUNET_free, GNUNET_MQ_discard(), GNUNET_SCHEDULER_cancel(), CadetExit::receive_queue_head, CadetExit::receive_queue_tail, RequestContext::rh, and RequestContext::timeout_task.

Referenced by cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup()

static void cleanup ( void *  cls )

static

Function scheduled as very last function, cleans up after us.

Parameters

cls	closure, NULL

Definition at line 932 of file gnunet-daemon-pt.c.

{
  struct CadetExit *exit;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Protocol translation daemon is shutting down now\n");
  if (NULL != vpn_handle)
  {
    GNUNET_VPN_disconnect (vpn_handle);
    vpn_handle = NULL;
  }
  while (NULL != (exit = exit_head))
  {
    GNUNET_CONTAINER_DLL_remove (exit_head,
                                 exit_tail,
                                 exit);
    if (NULL != exit->cadet_channel)
    {
      GNUNET_CADET_channel_destroy (exit->cadet_channel);
      exit->cadet_channel = NULL;
    }
    abort_all_requests (exit);
    GNUNET_free (exit);
  }
  if (NULL != cadet_handle)
  {
    GNUNET_CADET_disconnect (cadet_handle);
    cadet_handle = NULL;
  }
  if (NULL != dns_post_handle)
  {
    GNUNET_DNS_disconnect (dns_post_handle);
    dns_post_handle = NULL;
  }
  if (NULL != dns_pre_handle)
  {
    GNUNET_DNS_disconnect (dns_pre_handle);
    dns_pre_handle = NULL;
  }
  if (NULL != stats)
  {
    GNUNET_STATISTICS_destroy (stats, GNUNET_YES);
    stats = NULL;
  }
  if (NULL != dht_get)
  {
    GNUNET_DHT_get_stop (dht_get);
    dht_get = NULL;
  }
  if (NULL != dht)
  {
    GNUNET_DHT_disconnect (dht);
    dht = NULL;
  }
}

References abort_all_requests(), CadetExit::cadet_channel, cadet_handle, dht, dht_get, dns_post_handle, dns_pre_handle, exit_head, exit_tail, GNUNET_CADET_channel_destroy(), GNUNET_CADET_disconnect(), GNUNET_CONTAINER_DLL_remove, GNUNET_DHT_disconnect(), GNUNET_DHT_get_stop(), GNUNET_DNS_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_STATISTICS_destroy(), GNUNET_VPN_disconnect(), GNUNET_YES, stats, and vpn_handle.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

cadet_channel_end_cb()

static void cadet_channel_end_cb ( void *  cls, const struct GNUNET_CADET_Channel *  channel  )

static

Function called whenever a channel is destroyed.

Should clean up the associated state and attempt to build a new one.

It must NOT call GNUNET_CADET_channel_destroy on the channel.

Parameters

cls	closure (the struct CadetExit set from GNUNET_CADET_connect)
channel	connection to the other end (henceforth invalid)
channel_ctx	place where local state associated with the channel is stored

Definition at line 1001 of file gnunet-daemon-pt.c.

{
  struct CadetExit *exit = cls;
  struct CadetExit *alt;
  struct RequestContext *rc;
 
  exit->cadet_channel = NULL;
  dns_exit_available--;
  /* open alternative channels */
  /* our channel is now closed, move our requests to an alternative
     channel */
  alt = choose_exit ();
  while (NULL != (rc = exit->receive_queue_head))
  {
    GNUNET_CONTAINER_DLL_remove (exit->receive_queue_head,
                                 exit->receive_queue_tail,
                                 rc);
    rc->exit = alt;
    GNUNET_CONTAINER_DLL_insert (alt->receive_queue_head,
                                 alt->receive_queue_tail,
                                 rc);
    GNUNET_MQ_send (GNUNET_CADET_get_mq (alt->cadet_channel),
                    GNUNET_MQ_env_copy (rc->env));
  }
  try_open_exit ();
}

References CadetExit::cadet_channel, choose_exit(), dns_exit_available, RequestContext::env, RequestContext::exit, GNUNET_CADET_get_mq(), GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_MQ_env_copy(), GNUNET_MQ_send(), CadetExit::receive_queue_head, CadetExit::receive_queue_tail, and try_open_exit().

Referenced by try_open_exit().

Here is the call graph for this function:

Here is the caller graph for this function:

channel_idle_notify_cb()

static void channel_idle_notify_cb ( void *  cls, const struct GNUNET_CADET_Channel *  channel, int  window_size  )

static

Function called whenever a channel has excess capacity.

Parameters

cls	the struct CadetExit
channel	connection to the other end
window_size	how much capacity do we have

Definition at line 1038 of file gnunet-daemon-pt.c.

{
  struct CadetExit *pos = cls;
 
  pos->idle = window_size;
}

References CadetExit::idle.

Referenced by try_open_exit().

Here is the caller graph for this function:

handle_dht_result()

static void handle_dht_result ( void *  cls, struct GNUNET_TIME_Absolute  exp, const struct GNUNET_HashCode *  key, const struct GNUNET_PeerIdentity *  trunc_peer, const struct GNUNET_DHT_PathElement *  get_path, unsigned int  get_path_length, const struct GNUNET_DHT_PathElement *  put_path, unsigned int  put_path_length, enum GNUNET_BLOCK_Type  type, size_t  size, const void *  data  )

static

Function called whenever we find an advertisement for a DNS exit in the DHT.

If we don't have a cadet channel, we should build one; otherwise, we should save the advertisement for later use.

Parameters

cls	closure
exp	when will this value expire
key	key of the result
trunc_peer	peer that was truncated (or NULL if not truncated)
get_path	peers on reply path (or NULL if not recorded) [0] = datastore's first neighbor, [length - 1] = local peer
get_path_length	number of entries in get_path
put_path	peers on the PUT path (or NULL if not recorded) [0] = origin, [length - 1] = datastore
put_path_length	number of entries in put_path
type	type of the result
size	number of bytes in data
data	pointer to the result data

Definition at line 1139 of file gnunet-daemon-pt.c.

{
  const struct GNUNET_DNS_Advertisement *ad;
  struct CadetExit *exit;
 
  if (sizeof(struct GNUNET_DNS_Advertisement) != size)
  {
    GNUNET_break (0);
    return;
  }
  ad = data;
  for (exit = exit_head; NULL != exit; exit = exit->next)
    if (0 == GNUNET_memcmp (&ad->peer,
                            &exit->peer))
      break;
  if (NULL == exit)
  {
    exit = GNUNET_new (struct CadetExit);
    exit->peer = ad->peer;
    /* channel is closed, so insert at the end */
    GNUNET_CONTAINER_DLL_insert_tail (exit_head,
                                      exit_tail,
                                      exit);
  }
  exit->expiration = GNUNET_TIME_absolute_max (exit->expiration,
                                               GNUNET_TIME_absolute_ntoh (
                                                 ad->expiration_time));
  if (dns_exit_available < MAX_OPEN_TUNNELS)
    try_open_exit ();
}

References data, dns_exit_available, exit_head, exit_tail, CadetExit::expiration, GNUNET_DNS_Advertisement::expiration_time, GNUNET_break, GNUNET_CONTAINER_DLL_insert_tail, GNUNET_memcmp, GNUNET_new, GNUNET_TIME_absolute_max(), GNUNET_TIME_absolute_ntoh(), MAX_OPEN_TUNNELS, CadetExit::next, GNUNET_DNS_Advertisement::peer, CadetExit::peer, size, and try_open_exit().

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  cfg_  )

static

Main function that will be run by the scheduler.

Parameters

cls	closure
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
cfg_	configuration

Definition at line 1189 of file gnunet-daemon-pt.c.

{
  struct GNUNET_HashCode dns_key;
 
  cfg = cfg_;
  stats = GNUNET_STATISTICS_create ("pt",
                                    cfg);
  ipv4_pt = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                  "pt",
                                                  "TUNNEL_IPV4");
  ipv6_pt = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                  "pt",
                                                  "TUNNEL_IPV6");
  dns_channel = GNUNET_CONFIGURATION_get_value_yesno (cfg,
                                                      "pt",
                                                      "TUNNEL_DNS");
  if (! (ipv4_pt || ipv6_pt || dns_channel))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("No useful service enabled.  Exiting.\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  GNUNET_SCHEDULER_add_shutdown (&cleanup, cls);
  if (ipv4_pt || ipv6_pt)
  {
    dns_post_handle
      = GNUNET_DNS_connect (cfg,
                            GNUNET_DNS_FLAG_POST_RESOLUTION,
                            &dns_post_request_handler,
                            NULL);
    if (NULL == dns_post_handle)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to connect to %s service.  Exiting.\n"),
                  "DNS");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    vpn_handle = GNUNET_VPN_connect (cfg);
    if (NULL == vpn_handle)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to connect to %s service.  Exiting.\n"),
                  "VPN");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
  }
  if (dns_channel)
  {
    dns_pre_handle
      = GNUNET_DNS_connect (cfg,
                            GNUNET_DNS_FLAG_PRE_RESOLUTION,
                            &dns_pre_request_handler,
                            NULL);
    if (NULL == dns_pre_handle)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to connect to %s service.  Exiting.\n"),
                  "DNS");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    cadet_handle = GNUNET_CADET_connect (cfg);
    if (NULL == cadet_handle)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to connect to %s service.  Exiting.\n"),
                  "CADET");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    dht = GNUNET_DHT_connect (cfg, 1);
    if (NULL == dht)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                  _ ("Failed to connect to %s service.  Exiting.\n"),
                  "DHT");
      GNUNET_SCHEDULER_shutdown ();
      return;
    }
    GNUNET_CRYPTO_hash ("dns",
                        strlen ("dns"),
                        &dns_key);
    dht_get = GNUNET_DHT_get_start (dht,
                                    GNUNET_BLOCK_TYPE_DNS,
                                    &dns_key,
                                    1,
                                    GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
                                    NULL, 0,
                                    &handle_dht_result,
                                    NULL);
  }
}

References _, cadet_handle, cfg, cleanup(), dht, dht_get, dns_channel, dns_post_handle, dns_post_request_handler(), dns_pre_handle, dns_pre_request_handler(), GNUNET_BLOCK_TYPE_DNS, GNUNET_CADET_connect(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CRYPTO_hash(), GNUNET_DHT_connect(), GNUNET_DHT_get_start(), GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE, GNUNET_DNS_connect(), GNUNET_DNS_FLAG_POST_RESOLUTION, GNUNET_DNS_FLAG_PRE_RESOLUTION, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_VPN_connect(), handle_dht_result(), ipv4_pt, ipv6_pt, stats, and vpn_handle.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 1296 of file gnunet-daemon-pt.c.

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  int ret;
 
  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args (argc,
                                                 argv,
                                                 &argc,
                                                 &argv))
    return 2;
  ret = (GNUNET_OK ==
         GNUNET_PROGRAM_run (argc,
                             argv,
                             "gnunet-daemon-pt",
                             gettext_noop (
                               "Daemon to run to perform IP protocol translation to GNUnet"),
                             options,
                             &run,
                             NULL))
        ? 0
        : 1;
  GNUNET_free_nz ((void *) argv);
  return ret;
}

References gettext_noop, GNUNET_free_nz, GNUNET_GETOPT_OPTION_END, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), options, ret, and run().

Here is the call graph for this function:

Variable Documentation

exit_head

struct CadetExit* exit_head

static

Head of DLL of cadet exits.

Cadet exits with an open channel are always at the beginning (so we do not have to traverse the entire list to find them).

Definition at line 232 of file gnunet-daemon-pt.c.

Referenced by choose_exit(), cleanup(), handle_dht_result(), timeout_request(), and try_open_exit().

exit_tail

struct CadetExit* exit_tail

static

Tail of DLL of cadet exits.

Definition at line 237 of file gnunet-daemon-pt.c.

Referenced by cleanup(), handle_dht_result(), timeout_request(), and try_open_exit().

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

The handle to the configuration used throughout the process.

Definition at line 242 of file gnunet-daemon-pt.c.

Referenced by run().

vpn_handle

struct GNUNET_VPN_Handle* vpn_handle

static

The handle to the VPN.

Definition at line 247 of file gnunet-daemon-pt.c.

Referenced by cleanup(), modify_address(), and run().

cadet_handle

struct GNUNET_CADET_Handle* cadet_handle

static

The handle to the CADET service.

Definition at line 252 of file gnunet-daemon-pt.c.

Referenced by cleanup(), run(), and try_open_exit().

stats

struct GNUNET_STATISTICS_Handle* stats

static

Statistics.

Definition at line 257 of file gnunet-daemon-pt.c.

Referenced by cleanup(), dns_post_request_handler(), dns_pre_request_handler(), finish_request(), handle_dns_response(), run(), timeout_request(), and vpn_allocation_callback().

dns_post_handle

struct GNUNET_DNS_Handle* dns_post_handle

static

The handle to DNS post-resolution modifications.

Definition at line 262 of file gnunet-daemon-pt.c.

Referenced by cleanup(), and run().

dns_pre_handle

struct GNUNET_DNS_Handle* dns_pre_handle

static

The handle to DNS pre-resolution modifications.

Definition at line 267 of file gnunet-daemon-pt.c.

Referenced by cleanup(), and run().

dht

struct GNUNET_DHT_Handle* dht

static

Handle to access the DHT.

Definition at line 272 of file gnunet-daemon-pt.c.

Referenced by cleanup(), and run().

dht_get

struct GNUNET_DHT_GetHandle* dht_get

static

Our DHT GET operation to find DNS exits.

Definition at line 277 of file gnunet-daemon-pt.c.

Referenced by cleanup(), and run().

ipv4_pt

int ipv4_pt

static

Are we doing IPv4-pt?

Definition at line 282 of file gnunet-daemon-pt.c.

Referenced by run(), submit_request(), and work_test().

ipv6_pt

int ipv6_pt

static

Are we doing IPv6-pt?

Definition at line 287 of file gnunet-daemon-pt.c.

Referenced by run(), submit_request(), and work_test().

dns_channel

int dns_channel

static

Are we channeling DNS queries?

Definition at line 292 of file gnunet-daemon-pt.c.

Referenced by run().

dns_exit_available

unsigned int dns_exit_available

static

Number of DNS exit peers we currently have in the cadet channel.

Used to see if using the cadet channel makes any sense right now, as well as to decide if we should open new channels.

Definition at line 299 of file gnunet-daemon-pt.c.

Referenced by cadet_channel_end_cb(), dns_pre_request_handler(), handle_dht_result(), timeout_request(), and try_open_exit().