gnunet-service-resolver.c File Reference

code to do DNS resolution More...

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

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

Go to the source code of this file.

Data Structures
struct	RecordListEntry
	Entry in list of cached DNS records for a hostname. More...
struct	ResolveCache
	A cached DNS lookup result. More...
struct	ActiveLookup
	Information about pending lookups. More...

Macros
#define	DNS_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
	How long do we wait for DNS answers? More...
#define	MAX_CACHE   1024
	Maximum number of hostnames we cache results for. More...

Functions
static void	free_cache_entry (struct ResolveCache *rc)
	Remove entry from cache. More...
static void	free_hosts_entry (struct ResolveCache *rc)
	Remove entry from cache. More...
static void	free_active_lookup (struct ActiveLookup *al)
	Release resources associated with al. More...
static char *	extract_dns_server (const char *line, size_t line_len)
	Find out if the configuration file line contains a string starting with "nameserver ", and if so, return a copy of the nameserver's IP. More...
static char *	extract_search_domain (const char *line, size_t line_len)
	Find out if the configuration file line contains a string starting with "search ", and if so, return a copy of the machine's search domain. More...
static int	lookup_dns_servers (char ***server_addrs)
	Reads the list of nameservers from /etc/resolve.conf. More...
static char *	make_reverse_hostname (const void *ip, int af)
	Compute name to use for DNS reverse lookups from ip. More...
static int	send_reply (struct GNUNET_DNSPARSER_Record *record, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
	Send DNS record back to our client. More...
static void	send_end_msg (uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
	Send message to client that we transmitted all responses for client_request_id. More...
static int	remove_expired (struct ResolveCache *rc)
	Remove expired entries from rc. More...
static void	process_get (const char *hostname, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
	Process DNS request for hostname with request ID request_id from client demanding records of type record_type. More...
static int	try_cache (const char *hostname, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
	Get an IP address as a string (works for both IPv4 and IPv6). More...
static int	pack (const char *hostname, uint16_t type, uint16_t dns_id, char **packet_buf, size_t *packet_size)
	Create DNS query for hostname of type type with DNS request ID dns_id. More...
static void	cache_answers (const char *name, struct GNUNET_DNSPARSER_Record *records, unsigned int num_records)
static void	handle_resolve_result (void *cls, const struct GNUNET_TUN_DnsHeader *dns, size_t dns_len)
	We got a result from DNS. More...
static void	handle_resolve_timeout (void *cls)
	We encountered a timeout trying to perform a DNS lookup. More...
static int	resolve_and_cache (const char *hostname, uint16_t record_type, uint32_t client_request_id, struct GNUNET_SERVICE_Client *client)
	Initiate an active lookup, then cache the result and try to then complete the resolution. More...
static int	check_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *get)
	Verify well-formedness of GET-message. More...
static void	handle_get (void *cls, const struct GNUNET_RESOLVER_GetMessage *msg)
	Handle GET-message. More...
static void	shutdown_task (void *cls)
	Service is shutting down, clean up. More...
static void	add_host (const char *hostname, uint16_t rec_type, const void *data, size_t data_size)
	Add information about a host from /etc/hosts to our cache. More...
static void	extract_hosts (const char *line, size_t line_len)
	Extract host information from a line in /etc/hosts. More...
static void	load_etc_hosts (void)
	Reads the list of hosts from /etc/hosts. More...
static void	init_cb (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg, struct GNUNET_SERVICE_Handle *sh)
	Service is starting, initialize everything. More...
static void *	connect_cb (void *cls, struct GNUNET_SERVICE_Client *c, struct GNUNET_MQ_Handle *mq)
	Callback called when a client connects to the service. More...
static void	disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *c, void *internal_cls)
	Callback called when a client disconnected from the service. More...
	GNUNET_SERVICE_MAIN ("resolver", GNUNET_SERVICE_OPTION_NONE, &init_cb, &connect_cb, &disconnect_cb, NULL, GNUNET_MQ_hd_var_size(get, GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST, struct GNUNET_RESOLVER_GetMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct ResolveCache *	cache_head
	Start of the linked list of cached DNS lookup results. More...
static struct ResolveCache *	cache_tail
	Tail of the linked list of cached DNS lookup results. More...
static struct ResolveCache *	hosts_head
	Head of the linked list of DNS lookup results from /etc/hosts. More...
static struct ResolveCache *	hosts_tail
	Tail of the linked list of DNS lookup results from /etc/hosts. More...
static struct ActiveLookup *	lookup_head
	Start of the linked list of active DNS lookups. More...
static struct ActiveLookup *	lookup_tail
	Tail of the linked list of active DNS lookups. More...
static struct GNUNET_DNSSTUB_Context *	dnsstub_ctx
	context of dnsstub library More...
static char *	my_domain
	My domain, to be appended to the hostname to get a FQDN. More...
static unsigned int	cache_size
	How many entries do we have in cache_head DLL? More...

Detailed Description

code to do DNS resolution

Author

Christian Grothoff

Definition in file gnunet-service-resolver.c.

Macro Definition Documentation

DNS_TIMEOUT

#define DNS_TIMEOUT   GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)

How long do we wait for DNS answers?

Definition at line 37 of file gnunet-service-resolver.c.

MAX_CACHE

#define MAX_CACHE   1024

Maximum number of hostnames we cache results for.

Definition at line 42 of file gnunet-service-resolver.c.

Function Documentation

free_cache_entry()

static void free_cache_entry ( struct ResolveCache *  rc )

static

Remove entry from cache.

Parameters

rc	entry to free

Definition at line 210 of file gnunet-service-resolver.c.

{
  struct RecordListEntry *pos;
 
  while (NULL != (pos = rc->records_head))
  {
    GNUNET_CONTAINER_DLL_remove (rc->records_head, rc->records_tail, pos);
    GNUNET_DNSPARSER_free_record (pos->record);
    GNUNET_free (pos->record);
    GNUNET_free (pos);
  }
  GNUNET_free (rc->hostname);
  GNUNET_CONTAINER_DLL_remove (cache_head, cache_tail, rc);
  cache_size--;
  GNUNET_free (rc);
}

References cache_head, cache_size, cache_tail, GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_free_record(), GNUNET_free, ResolveCache::hostname, RecordListEntry::record, ResolveCache::records_head, and ResolveCache::records_tail.

Referenced by handle_resolve_result(), remove_expired(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

free_hosts_entry()

static void free_hosts_entry ( struct ResolveCache *  rc )

static

Remove entry from cache.

Parameters

rc	entry to free

Definition at line 234 of file gnunet-service-resolver.c.

{
  struct RecordListEntry *pos;
 
  while (NULL != (pos = rc->records_head))
  {
    GNUNET_CONTAINER_DLL_remove (rc->records_head, rc->records_tail, pos);
    GNUNET_DNSPARSER_free_record (pos->record);
    GNUNET_free (pos->record);
    GNUNET_free (pos);
  }
  GNUNET_free (rc->hostname);
  GNUNET_CONTAINER_DLL_remove (hosts_head, hosts_tail, rc);
  cache_size--;
  GNUNET_free (rc);
}

References cache_size, GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_free_record(), GNUNET_free, ResolveCache::hostname, hosts_head, hosts_tail, RecordListEntry::record, ResolveCache::records_head, and ResolveCache::records_tail.

Referenced by shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

free_active_lookup()

static void free_active_lookup ( struct ActiveLookup *  al )

static

Release resources associated with al.

Parameters

al	an active lookup

Definition at line 258 of file gnunet-service-resolver.c.

{
  GNUNET_CONTAINER_DLL_remove (lookup_head, lookup_tail, al);
  if (NULL != al->resolve_handle)
  {
    GNUNET_DNSSTUB_resolve_cancel (al->resolve_handle);
    al->resolve_handle = NULL;
  }
  if (NULL != al->timeout_task)
  {
    GNUNET_SCHEDULER_cancel (al->timeout_task);
    al->timeout_task = NULL;
  }
  GNUNET_free (al->hostname);
  GNUNET_free (al);
}

References GNUNET_CONTAINER_DLL_remove, GNUNET_DNSSTUB_resolve_cancel(), GNUNET_free, GNUNET_SCHEDULER_cancel(), ActiveLookup::hostname, lookup_head, lookup_tail, ActiveLookup::resolve_handle, and ActiveLookup::timeout_task.

Referenced by disconnect_cb(), handle_resolve_result(), handle_resolve_timeout(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

extract_dns_server()

static char* extract_dns_server ( const char *  line, size_t  line_len  )

static

Find out if the configuration file line contains a string starting with "nameserver ", and if so, return a copy of the nameserver's IP.

Parameters

line	line to parse
line_len	number of characters in line

Returns

NULL if no nameserver is configured in this line

Definition at line 286 of file gnunet-service-resolver.c.

{
  if (0 == strncmp (line, "nameserver ", strlen ("nameserver ")))
    return GNUNET_strndup (line + strlen ("nameserver "),
                           line_len - strlen ("nameserver "));
  return NULL;
}

References GNUNET_strndup, and line.

Referenced by lookup_dns_servers().

Here is the caller graph for this function:

extract_search_domain()

static char* extract_search_domain ( const char *  line, size_t  line_len  )

static

Find out if the configuration file line contains a string starting with "search ", and if so, return a copy of the machine's search domain.

Parameters

line	line to parse
line_len	number of characters in line

Returns

NULL if no nameserver is configured in this line

Definition at line 305 of file gnunet-service-resolver.c.

{
  if (0 == strncmp (line, "search ", strlen ("search ")))
    return GNUNET_strndup (line + strlen ("search "),
                           line_len - strlen ("search "));
  return NULL;
}

References GNUNET_strndup, and line.

Referenced by lookup_dns_servers().

Here is the caller graph for this function:

lookup_dns_servers()

static int lookup_dns_servers ( char ***  server_addrs )

static

Reads the list of nameservers from /etc/resolve.conf.

Parameters

[out]

server_addrs

a list of null-terminated server address strings

Returns

the number of server addresses in server_addrs, -1 on error

Definition at line 321 of file gnunet-service-resolver.c.

{
  struct GNUNET_DISK_FileHandle *fh;
  struct GNUNET_DISK_MapHandle *mh;
  off_t bytes_read;
  const char *buf;
  size_t read_offset;
  unsigned int num_dns_servers;
 
  fh = GNUNET_DISK_file_open ("/etc/resolv.conf",
                              GNUNET_DISK_OPEN_READ,
                              GNUNET_DISK_PERM_NONE);
  if (NULL == fh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not open /etc/resolv.conf. "
                "DNS resolution will not be possible.\n");
    return -1;
  }
  if (GNUNET_OK != GNUNET_DISK_file_handle_size (fh, &bytes_read))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not determine size of /etc/resolv.conf. "
                "DNS resolution will not be possible.\n");
    GNUNET_DISK_file_close (fh);
    return -1;
  }
  if (((unsigned long long) bytes_read) > (unsigned long long) SIZE_MAX)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "/etc/resolv.conf file too large to mmap. "
                "DNS resolution will not be possible.\n");
    GNUNET_DISK_file_close (fh);
    return -1;
  }
  buf = GNUNET_DISK_file_map (fh,
                              &mh,
                              GNUNET_DISK_MAP_TYPE_READ,
                              (size_t) bytes_read);
  *server_addrs = NULL;
  read_offset = 0;
  num_dns_servers = 0;
  while (read_offset < (size_t) bytes_read)
  {
    const char *newline;
    size_t line_len;
    char *dns_server;
 
    newline = strchr (buf + read_offset, '\n');
    if (NULL == newline)
      break;
    line_len = newline - buf - read_offset;
    dns_server = extract_dns_server (buf + read_offset, line_len);
    if (NULL != dns_server)
    {
      GNUNET_array_append (*server_addrs, num_dns_servers, dns_server);
    }
    else if (NULL == my_domain)
    {
      my_domain = extract_search_domain (buf + read_offset, line_len);
    }
    read_offset += line_len + 1;
  }
  GNUNET_DISK_file_unmap (mh);
  GNUNET_DISK_file_close (fh);
  return (int) num_dns_servers;
}

References buf, extract_dns_server(), extract_search_domain(), fh, GNUNET_array_append, GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_map(), GNUNET_DISK_file_open(), GNUNET_DISK_file_unmap(), GNUNET_DISK_MAP_TYPE_READ, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, mh, my_domain, and SIZE_MAX.

Referenced by init_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

make_reverse_hostname()

static char* make_reverse_hostname ( const void *  ip, int  af  )

static

Compute name to use for DNS reverse lookups from ip.

Parameters

ip	IP address to resolve, in binary format, network byte order
af	address family of ip, AF_INET or AF_INET6

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

{
  char *buf = GNUNET_new_array (80, char);
  int pos = 0;
 
  if (AF_INET == af)
  {
    struct in_addr *addr = (struct in_addr *) ip;
    uint32_t ip_int = addr->s_addr;
 
    for (int i = 3; i >= 0; i--)
    {
      int n =
        GNUNET_snprintf (buf + pos, 80 - pos, "%u.", ((uint8_t *) &ip_int)[i]);
      if (n < 0)
      {
        GNUNET_free (buf);
        return NULL;
      }
      pos += n;
    }
    pos += GNUNET_snprintf (buf + pos, 80 - pos, "in-addr.arpa");
  }
  else if (AF_INET6 == af)
  {
    struct in6_addr *addr = (struct in6_addr *) ip;
    for (int i = 15; i >= 0; i--)
    {
      int n =
        GNUNET_snprintf (buf + pos, 80 - pos, "%x.", addr->s6_addr[i] & 0xf);
      if (n < 0)
      {
        GNUNET_free (buf);
        return NULL;
      }
      pos += n;
      n = GNUNET_snprintf (buf + pos, 80 - pos, "%x.", addr->s6_addr[i] >> 4);
      if (n < 0)
      {
        GNUNET_free (buf);
        return NULL;
      }
      pos += n;
    }
    pos += GNUNET_snprintf (buf + pos, 80 - pos, "ip6.arpa");
  }
  buf[pos] = '\0';
  return buf;
}

References buf, GNUNET_free, GNUNET_new_array, and GNUNET_snprintf().

Referenced by handle_get().

Here is the call graph for this function:

Here is the caller graph for this function:

send_reply()

static int send_reply ( struct GNUNET_DNSPARSER_Record *  record, uint16_t  record_type, uint32_t  client_request_id, struct GNUNET_SERVICE_Client *  client  )

static

Send DNS record back to our client.

Parameters

record	information to transmit
record_type	requested record type from client
client_request_id	to which request are we responding
client	where to send record

Returns

GNUNET_YES if we sent a reply, GNUNET_NO if the record type is not understood or does not match record_type

Definition at line 460 of file gnunet-service-resolver.c.

{
  struct GNUNET_RESOLVER_ResponseMessage *msg;
  struct GNUNET_MQ_Envelope *env;
  const void *payload;
  size_t payload_len;
 
  switch (record->type)
  {
  case GNUNET_DNSPARSER_TYPE_CNAME:
    if (GNUNET_DNSPARSER_TYPE_CNAME != record_type)
      return GNUNET_NO;
    payload = record->data.hostname;
    payload_len = strlen (record->data.hostname) + 1;
    break;
 
  case GNUNET_DNSPARSER_TYPE_PTR:
    if (GNUNET_DNSPARSER_TYPE_PTR != record_type)
      return GNUNET_NO;
    payload = record->data.hostname;
    payload_len = strlen (record->data.hostname) + 1;
    break;
 
  case GNUNET_DNSPARSER_TYPE_A:
    if ((GNUNET_DNSPARSER_TYPE_A != record_type) &&
        (GNUNET_DNSPARSER_TYPE_ALL != record_type))
      return GNUNET_NO;
    payload = record->data.raw.data;
    payload_len = record->data.raw.data_len;
    break;
 
  case GNUNET_DNSPARSER_TYPE_AAAA:
    if ((GNUNET_DNSPARSER_TYPE_AAAA != record_type) &&
        (GNUNET_DNSPARSER_TYPE_ALL != record_type))
      return GNUNET_NO;
    payload = record->data.raw.data;
    payload_len = record->data.raw.data_len;
    break;
 
  default:
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Cannot handle DNS response type %u: not supported here\n",
                record->type);
    return GNUNET_NO;
  }
  env = GNUNET_MQ_msg_extra (msg,
                             payload_len,
                             GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
  msg->client_id = client_request_id;
  GNUNET_memcpy (&msg[1], payload, payload_len);
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
  return GNUNET_YES;
}

References env, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_ALL, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_DNSPARSER_TYPE_PTR, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_get_mq(), GNUNET_YES, msg, payload, and record().

Referenced by try_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

send_end_msg()

static void send_end_msg ( uint32_t  client_request_id, struct GNUNET_SERVICE_Client *  client  )

static

Send message to client that we transmitted all responses for client_request_id.

Parameters

client_request_id	to which request are we responding
client	where to send record

Definition at line 526 of file gnunet-service-resolver.c.

{
  struct GNUNET_RESOLVER_ResponseMessage *msg;
  struct GNUNET_MQ_Envelope *env;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Sending END message\n");
  env = GNUNET_MQ_msg (msg, GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE);
  msg->client_id = client_request_id;
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client), env);
}

References env, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_MESSAGE_TYPE_RESOLVER_RESPONSE, GNUNET_MQ_msg, GNUNET_MQ_send(), GNUNET_SERVICE_client_get_mq(), and msg.

Referenced by handle_resolve_result(), handle_resolve_timeout(), process_get(), and try_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

remove_expired()

static int remove_expired ( struct ResolveCache *  rc )

static

Remove expired entries from rc.

Parameters

rc	entry in resolver cache

Returns

GNUNET_YES if rc was completely expired GNUNET_NO if some entries are left

Definition at line 546 of file gnunet-service-resolver.c.

{
  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get ();
  struct RecordListEntry *n;
 
  for (struct RecordListEntry *pos = rc->records_head; NULL != pos; pos = n)
  {
    n = pos->next;
    if (now.abs_value_us > pos->record->expiration_time.abs_value_us)
    {
      GNUNET_CONTAINER_DLL_remove (rc->records_head, rc->records_tail, pos);
      GNUNET_DNSPARSER_free_record (pos->record);
      GNUNET_free (pos->record);
      GNUNET_free (pos);
    }
  }
  if (NULL == rc->records_head)
  {
    free_cache_entry (rc);
    return GNUNET_YES;
  }
  return GNUNET_NO;
}

References GNUNET_TIME_Absolute::abs_value_us, free_cache_entry(), GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_free_record(), GNUNET_free, GNUNET_NO, GNUNET_TIME_absolute_get(), GNUNET_YES, RecordListEntry::next, ResolveCache::records_head, and ResolveCache::records_tail.

Referenced by try_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

process_get()

static void process_get ( const char *  hostname, uint16_t  record_type, uint32_t  client_request_id, struct GNUNET_SERVICE_Client *  client  )

static

Process DNS request for hostname with request ID request_id from client demanding records of type record_type.

Process DNS request for hostname with request ID client_request_id from client demanding records of type record_type.

Parameters

hostname	DNS name to resolve
record_type	desired record type
client_request_id	client's request ID
client	who should get the result?

Definition at line 947 of file gnunet-service-resolver.c.

{
  char fqdn[255];
 
  if (GNUNET_NO != try_cache (hostname, record_type, client_request_id, client))
    return;
  if ((NULL != my_domain) && (NULL == strchr (hostname, (unsigned char) '.')) &&
      (strlen (hostname) + strlen (my_domain) <= 253))
  {
    GNUNET_snprintf (fqdn, sizeof(fqdn), "%s.%s", hostname, my_domain);
  }
  else if (strlen (hostname) < 255)
  {
    GNUNET_snprintf (fqdn, sizeof(fqdn), "%s", hostname);
  }
  else
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (client);
    return;
  }
  if (GNUNET_NO == try_cache (fqdn, record_type, client_request_id, client))
  {
    if (GNUNET_OK !=
        resolve_and_cache (fqdn, record_type, client_request_id, client))
    {
      send_end_msg (client_request_id, client);
    }
  }
}

References ActiveLookup::client, ActiveLookup::client_request_id, GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_drop(), GNUNET_snprintf(), hostname, my_domain, ActiveLookup::record_type, resolve_and_cache(), send_end_msg(), and try_cache().

Referenced by handle_get(), and try_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

try_cache()

static int try_cache ( const char *  hostname, uint16_t  record_type, uint32_t  client_request_id, struct GNUNET_SERVICE_Client *  client  )

static

Get an IP address as a string (works for both IPv4 and IPv6).

Note that the resolution happens asynchronously and that the first call may not immediately result in the FQN (but instead in a human-readable IP address).

Parameters

hostname	what hostname was to be resolved
record_type	what type of record was requested
client_request_id	unique identification of the client's request
client	handle to the client making the request (for sending the reply)

Definition at line 599 of file gnunet-service-resolver.c.

{
  struct ResolveCache *pos;
  struct ResolveCache *next;
  int found;
  int in_hosts;
 
  in_hosts = GNUNET_NO;
  for (pos = hosts_head; NULL != pos; pos = pos->next)
    if (0 == strcmp (pos->hostname, hostname))
    {
      in_hosts = GNUNET_YES;
      break;
    }
  if (NULL == pos)
  {
    next = cache_head;
    for (pos = next; NULL != pos; pos = next)
    {
      next = pos->next;
      if (GNUNET_YES == remove_expired (pos))
        continue;
      if (0 == strcmp (pos->hostname, hostname))
        break;
    }
  }
  if (NULL == pos)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No cache entry for '%s'\n", hostname);
    return GNUNET_NO;
  }
  if ((GNUNET_NO == in_hosts) && (cache_head != pos))
  {
    /* move result to head to achieve LRU for cache eviction */
    GNUNET_CONTAINER_DLL_remove (cache_head, cache_tail, pos);
    GNUNET_CONTAINER_DLL_insert (cache_head, cache_tail, pos);
  }
  found = GNUNET_NO;
  for (struct RecordListEntry *rle = pos->records_head; NULL != rle;
       rle = rle->next)
  {
    const struct GNUNET_DNSPARSER_Record *record = rle->record;
 
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Checking cache entry for '%s', record is for '%s'\n",
                hostname,
                record->name);
    if ((GNUNET_DNSPARSER_TYPE_CNAME == record->type) &&
        (GNUNET_DNSPARSER_TYPE_CNAME != record_type) && (GNUNET_NO == found))
    {
      const char *hostname = record->data.hostname;
 
      process_get (hostname, record_type, client_request_id, client);
      return GNUNET_YES;     /* counts as a cache "hit" */
    }
    if (0 == strcmp (record->name, hostname))
      found |= send_reply (rle->record, record_type, client_request_id, client);
  }
  if (GNUNET_NO == found)
    return GNUNET_NO; /* had records, but none matched! */
  send_end_msg (client_request_id, client);
  return GNUNET_YES;
}

References cache_head, cache_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_CONTAINER_DLL_remove, GNUNET_DNSPARSER_TYPE_CNAME, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_NO, GNUNET_YES, hostname, ResolveCache::hostname, hosts_head, RecordListEntry::next, ResolveCache::next, process_get(), record(), ResolveCache::records_head, remove_expired(), send_end_msg(), and send_reply().

Referenced by handle_resolve_result(), and process_get().

Here is the call graph for this function:

Here is the caller graph for this function:

pack()

static int pack ( const char *  hostname, uint16_t  type, uint16_t  dns_id, char **  packet_buf, size_t *  packet_size  )

static

Create DNS query for hostname of type type with DNS request ID dns_id.

Parameters

	hostname	DNS name to query
	type	requested DNS record type
	dns_id	what should be the DNS request ID
[out]	packet_buf	where to write the request packet
[out]	packet_size	set to size of packet_buf on success

Returns

GNUNET_OK on success

Definition at line 679 of file gnunet-service-resolver.c.

{
  struct GNUNET_DNSPARSER_Query query;
  struct GNUNET_DNSPARSER_Packet packet;
 
  query.name = (char *) hostname;
  query.type = type;
  query.dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
  memset (&packet, 0, sizeof(packet));
  packet.num_queries = 1;
  packet.queries = &query;
  packet.id = htons (dns_id);
  packet.flags.recursion_desired = 1;
  if (GNUNET_OK !=
      GNUNET_DNSPARSER_pack (&packet, UINT16_MAX, packet_buf, packet_size))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to pack query for hostname `%s'\n",
                hostname);
    packet_buf = NULL;
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_DNSPARSER_Query::dns_traffic_class, GNUNET_DNSPARSER_Packet::flags, GNUNET_DNSPARSER_pack(), GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_OK, GNUNET_SYSERR, GNUNET_TUN_DNS_CLASS_INTERNET, hostname, GNUNET_DNSPARSER_Packet::id, GNUNET_DNSPARSER_Query::name, GNUNET_DNSPARSER_Packet::num_queries, GNUNET_DNSPARSER_Packet::queries, GNUNET_TUN_DnsFlags::recursion_desired, GNUNET_DNSPARSER_Query::type, and type.

Referenced by handle_resolve_result(), and resolve_and_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

cache_answers()

static void cache_answers ( const char *  name, struct GNUNET_DNSPARSER_Record *  records, unsigned int  num_records  )

static

Definition at line 710 of file gnunet-service-resolver.c.

{
  struct ResolveCache *rc;
  struct GNUNET_DNSPARSER_Record *record;
  struct RecordListEntry *rle;
 
  for (unsigned int i = 0; i != num_records; i++)
  {
    record = &records[i];
 
    for (rc = cache_head; NULL != rc; rc = rc->next)
      if (0 == strcasecmp (rc->hostname, name))
        break;
    if (NULL == rc)
    {
      rc = GNUNET_new (struct ResolveCache);
      rc->hostname = GNUNET_strdup (name);
      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                  "Caching record for name %s under %s\n",
                  record->name, name);
      GNUNET_CONTAINER_DLL_insert (cache_head, cache_tail, rc);
      cache_size++;
    }
    /* TODO: ought to check first if we have this exact record
       already in the cache! */
    rle = GNUNET_new (struct RecordListEntry);
    rle->record = GNUNET_DNSPARSER_duplicate_record (record);
    GNUNET_CONTAINER_DLL_insert (rc->records_head, rc->records_tail, rle);
  }
}

References cache_head, cache_size, cache_tail, GNUNET_CONTAINER_DLL_insert, GNUNET_DNSPARSER_duplicate_record(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_strdup, ResolveCache::hostname, name, ResolveCache::next, record(), RecordListEntry::record, records, ResolveCache::records_head, and ResolveCache::records_tail.

Referenced by handle_resolve_result().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_resolve_result()

static void handle_resolve_result ( void *  cls, const struct GNUNET_TUN_DnsHeader *  dns, size_t  dns_len  )

static

We got a result from DNS.

Add it to the cache and see if we can make our client happy...

Parameters

cls	the struct ActiveLookup
dns	the DNS response
dns_len	number of bytes in dns

Definition at line 753 of file gnunet-service-resolver.c.

{
  struct ActiveLookup *al = cls;
  struct GNUNET_DNSPARSER_Packet *parsed;
 
  parsed = GNUNET_DNSPARSER_parse ((const char *) dns, dns_len);
  if (NULL == parsed)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to parse DNS reply (hostname %s, request ID %u)\n",
                al->hostname,
                al->dns_id);
    return;
  }
  if (al->dns_id != ntohs (parsed->id))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Request ID in DNS reply does not match\n");
    GNUNET_DNSPARSER_free_packet (parsed);
    return;
  }
  if (0 == parsed->num_answers + parsed->num_authority_records
      + parsed->num_additional_records)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "DNS reply (hostname %s, request ID %u) contains no answers\n",
                al->hostname,
                (unsigned int) al->client_request_id);
    /* resume by trying again from cache */
    if (GNUNET_NO == try_cache (al->hostname,
                                al->record_type,
                                al->client_request_id,
                                al->client))
    /* cache failed, tell client we could not get an answer */
    {
      send_end_msg (al->client_request_id, al->client);
    }
    GNUNET_DNSPARSER_free_packet (parsed);
    free_active_lookup (al);
    return;
  }
  /* LRU-based cache eviction: we remove from tail */
  while (cache_size > MAX_CACHE)
    free_cache_entry (cache_tail);
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Got reply for hostname %s and request ID %u\n",
              al->hostname,
              (unsigned int) al->client_request_id);
  /* add to cache */
  cache_answers (al->hostname, parsed->answers, parsed->num_answers);
  cache_answers (al->hostname,
                 parsed->authority_records,
                 parsed->num_authority_records);
  cache_answers (al->hostname,
                 parsed->additional_records,
                 parsed->num_additional_records);
 
  /* see if we need to do the 2nd request for AAAA records */
  if ((GNUNET_DNSPARSER_TYPE_ALL == al->record_type) &&
      (GNUNET_NO == al->did_aaaa))
  {
    char *packet_buf;
    size_t packet_size;
    uint16_t dns_id;
 
    dns_id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                                  UINT16_MAX);
    if (GNUNET_OK == pack (al->hostname,
                           GNUNET_DNSPARSER_TYPE_AAAA,
                           dns_id,
                           &packet_buf,
                           &packet_size))
    {
      al->did_aaaa = GNUNET_YES;
      al->dns_id = dns_id;
      GNUNET_DNSSTUB_resolve_cancel (al->resolve_handle);
      al->resolve_handle = GNUNET_DNSSTUB_resolve (dnsstub_ctx,
                                                   packet_buf,
                                                   packet_size,
                                                   &handle_resolve_result,
                                                   al);
      GNUNET_free (packet_buf);
      GNUNET_DNSPARSER_free_packet (parsed);
      return;
    }
  }
 
  /* resume by trying again from cache */
  if (GNUNET_NO == try_cache (al->hostname,
                              al->record_type,
                              al->client_request_id,
                              al->client))
  /* cache failed, tell client we could not get an answer */
  {
    send_end_msg (al->client_request_id, al->client);
  }
  free_active_lookup (al);
  GNUNET_DNSPARSER_free_packet (parsed);
}

References GNUNET_DNSPARSER_Packet::additional_records, GNUNET_DNSPARSER_Packet::answers, GNUNET_DNSPARSER_Packet::authority_records, cache_answers(), cache_size, cache_tail, ActiveLookup::client, ActiveLookup::client_request_id, ActiveLookup::did_aaaa, ActiveLookup::dns_id, dnsstub_ctx, free_active_lookup(), free_cache_entry(), GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_DNSPARSER_free_packet(), GNUNET_DNSPARSER_parse(), GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_ALL, GNUNET_DNSSTUB_resolve(), GNUNET_DNSSTUB_resolve_cancel(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_OK, GNUNET_YES, ActiveLookup::hostname, GNUNET_DNSPARSER_Packet::id, MAX_CACHE, GNUNET_DNSPARSER_Packet::num_additional_records, GNUNET_DNSPARSER_Packet::num_answers, GNUNET_DNSPARSER_Packet::num_authority_records, pack(), ActiveLookup::record_type, ActiveLookup::resolve_handle, send_end_msg(), and try_cache().

Referenced by resolve_and_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

handle_resolve_timeout()

static void handle_resolve_timeout ( void *  cls )

static

We encountered a timeout trying to perform a DNS lookup.

Parameters

cls	a struct ActiveLookup

Definition at line 864 of file gnunet-service-resolver.c.

{
  struct ActiveLookup *al = cls;
 
  al->timeout_task = NULL;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "DNS lookup timeout!\n");
  send_end_msg (al->client_request_id, al->client);
  free_active_lookup (al);
}

References ActiveLookup::client, ActiveLookup::client_request_id, free_active_lookup(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, send_end_msg(), and ActiveLookup::timeout_task.

Referenced by resolve_and_cache().

Here is the call graph for this function:

Here is the caller graph for this function:

resolve_and_cache()

static int resolve_and_cache ( const char *  hostname, uint16_t  record_type, uint32_t  client_request_id, struct GNUNET_SERVICE_Client *  client  )

static

Initiate an active lookup, then cache the result and try to then complete the resolution.

Parameters

hostname	DNS name to resolve
record_type	record type to locate
client_request_id	client request ID
client	handle to the client

Returns

GNUNET_OK if the DNS query is now pending

Definition at line 886 of file gnunet-service-resolver.c.

{
  char *packet_buf;
  size_t packet_size;
  struct ActiveLookup *al;
  uint16_t dns_id;
  uint16_t type;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "resolve_and_cache `%s'\n", hostname);
  dns_id = (uint16_t) GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_NONCE,
                                                UINT16_MAX);
 
  if (GNUNET_DNSPARSER_TYPE_ALL == record_type)
    type = GNUNET_DNSPARSER_TYPE_A;
  else
    type = record_type;
  if (GNUNET_OK != pack (hostname, type, dns_id, &packet_buf, &packet_size))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Failed to pack query for hostname `%s'\n",
                hostname);
    return GNUNET_SYSERR;
  }
 
  al = GNUNET_new (struct ActiveLookup);
  al->hostname = GNUNET_strdup (hostname);
  al->record_type = record_type;
  al->client_request_id = client_request_id;
  al->dns_id = dns_id;
  al->client = client;
  al->timeout_task =
    GNUNET_SCHEDULER_add_delayed (DNS_TIMEOUT, &handle_resolve_timeout, al);
  al->resolve_handle = GNUNET_DNSSTUB_resolve (dnsstub_ctx,
                                               packet_buf,
                                               packet_size,
                                               &handle_resolve_result,
                                               al);
  GNUNET_free (packet_buf);
  GNUNET_CONTAINER_DLL_insert (lookup_head, lookup_tail, al);
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Resolving %s, client_request_id = %u, dns_id = %u\n",
              hostname,
              (unsigned int) client_request_id,
              (unsigned int) dns_id);
  return GNUNET_OK;
}

References ActiveLookup::client, ActiveLookup::client_request_id, ActiveLookup::dns_id, DNS_TIMEOUT, dnsstub_ctx, GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_QUALITY_NONCE, GNUNET_CRYPTO_random_u32(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_ALL, GNUNET_DNSSTUB_resolve(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_delayed(), GNUNET_strdup, GNUNET_SYSERR, handle_resolve_result(), handle_resolve_timeout(), hostname, ActiveLookup::hostname, lookup_head, lookup_tail, pack(), ActiveLookup::record_type, ActiveLookup::resolve_handle, ActiveLookup::timeout_task, and type.

Referenced by process_get().

Here is the call graph for this function:

Here is the caller graph for this function:

check_get()

static int check_get ( void *  cls, const struct GNUNET_RESOLVER_GetMessage *  get  )

static

Verify well-formedness of GET-message.

Parameters

cls	closure, unused
get	the actual message

Returns

GNUNET_OK if get is well-formed

Definition at line 990 of file gnunet-service-resolver.c.

{
  uint16_t size;
  int direction;
  int af;
 
  (void) cls;
  size = ntohs (get->header.size) - sizeof(*get);
  direction = ntohl (get->direction);
  if (GNUNET_NO == direction)
  {
    GNUNET_MQ_check_zero_termination (get);
    return GNUNET_OK;
  }
  af = ntohl (get->af);
  switch (af)
  {
  case AF_INET:
    if (size != sizeof(struct in_addr))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    break;
 
  case AF_INET6:
    if (size != sizeof(struct in6_addr))
    {
      GNUNET_break (0);
      return GNUNET_SYSERR;
    }
    break;
 
  default:
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References direction, get, GNUNET_break, GNUNET_MQ_check_zero_termination, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, and size.

handle_get()

static void handle_get ( void *  cls, const struct GNUNET_RESOLVER_GetMessage *  msg  )

static

Handle GET-message.

Parameters

cls	identification of the client
msg	the actual message

Definition at line 1038 of file gnunet-service-resolver.c.

{
  struct GNUNET_SERVICE_Client *client = cls;
  int direction;
  int af;
  uint32_t client_request_id;
  char *hostname;
 
  direction = ntohl (msg->direction);
  af = ntohl (msg->af);
  client_request_id = msg->client_id;
  GNUNET_SERVICE_client_continue (client);
  if (GNUNET_NO == direction)
  {
    /* IP from hostname */
    hostname = GNUNET_strdup ((const char *) &msg[1]);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Client asks to resolve `%s'\n",
                hostname);
    switch (af)
    {
    case AF_UNSPEC: {
        process_get (hostname,
                     GNUNET_DNSPARSER_TYPE_ALL,
                     client_request_id,
                     client);
        break;
      }
 
    case AF_INET: {
        process_get (hostname,
                     GNUNET_DNSPARSER_TYPE_A,
                     client_request_id,
                     client);
        break;
      }
 
    case AF_INET6: {
        process_get (hostname,
                     GNUNET_DNSPARSER_TYPE_AAAA,
                     client_request_id,
                     client);
        break;
      }
 
    default: {
        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "got invalid af: %d\n", af);
        GNUNET_assert (0);
      }
    }
  }
  else
  {
    /* hostname from IP */
    hostname = make_reverse_hostname (&msg[1], af);
    process_get (hostname,
                 GNUNET_DNSPARSER_TYPE_PTR,
                 client_request_id,
                 client);
  }
  GNUNET_free (hostname);
}

References direction, GNUNET_assert, GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_DNSPARSER_TYPE_ALL, GNUNET_DNSPARSER_TYPE_PTR, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NO, GNUNET_SERVICE_client_continue(), GNUNET_strdup, hostname, make_reverse_hostname(), msg, and process_get().

Here is the call graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Service is shutting down, clean up.

Parameters

cls	NULL, unused

Definition at line 1108 of file gnunet-service-resolver.c.

{
  (void) cls;
 
  while (NULL != lookup_head)
    free_active_lookup (lookup_head);
  while (NULL != cache_head)
    free_cache_entry (cache_head);
  while (NULL != hosts_head)
    free_hosts_entry (hosts_head);
  GNUNET_DNSSTUB_stop (dnsstub_ctx);
  GNUNET_free (my_domain);
}

References cache_head, dnsstub_ctx, free_active_lookup(), free_cache_entry(), free_hosts_entry(), GNUNET_DNSSTUB_stop(), GNUNET_free, hosts_head, lookup_head, and my_domain.

Referenced by init_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

add_host()

static void add_host ( const char *  hostname, uint16_t  rec_type, const void *  data, size_t  data_size  )

static

Add information about a host from /etc/hosts to our cache.

Parameters

hostname	the name of the host
rec_type	DNS record type to use
data	payload
data_size	number of bytes in data

Definition at line 1133 of file gnunet-service-resolver.c.

{
  struct ResolveCache *rc;
  struct RecordListEntry *rle;
  struct GNUNET_DNSPARSER_Record *rec;
 
  rec = GNUNET_malloc (sizeof(struct GNUNET_DNSPARSER_Record));
  rec->expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS;
  rec->type = rec_type;
  rec->dns_traffic_class = GNUNET_TUN_DNS_CLASS_INTERNET;
  rec->name = GNUNET_strdup (hostname);
  rec->data.raw.data = GNUNET_memdup (data, data_size);
  rec->data.raw.data_len = data_size;
  rle = GNUNET_new (struct RecordListEntry);
  rle->record = rec;
  rc = GNUNET_new (struct ResolveCache);
  rc->hostname = GNUNET_strdup (hostname);
  GNUNET_CONTAINER_DLL_insert (rc->records_head, rc->records_tail, rle);
  GNUNET_CONTAINER_DLL_insert (hosts_head, hosts_tail, rc);
}

References GNUNET_DNSPARSER_RawRecord::data, GNUNET_DNSPARSER_Record::data, data, GNUNET_DNSPARSER_RawRecord::data_len, data_size, GNUNET_DNSPARSER_Record::dns_traffic_class, GNUNET_DNSPARSER_Record::expiration_time, GNUNET_CONTAINER_DLL_insert, GNUNET_malloc, GNUNET_memdup, GNUNET_new, GNUNET_strdup, GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TUN_DNS_CLASS_INTERNET, hostname, ResolveCache::hostname, hosts_head, hosts_tail, GNUNET_DNSPARSER_Record::name, GNUNET_DNSPARSER_Record::raw, RecordListEntry::record, ResolveCache::records_head, ResolveCache::records_tail, and GNUNET_DNSPARSER_Record::type.

Referenced by extract_hosts().

Here is the caller graph for this function:

extract_hosts()

static void extract_hosts ( const char *  line, size_t  line_len  )

static

Extract host information from a line in /etc/hosts.

Parameters

line	the line to parse
line_len	number of bytes in line

Definition at line 1165 of file gnunet-service-resolver.c.

{
  const char *c;
  struct in_addr v4;
  struct in6_addr v6;
  char *tbuf;
  char *tok;
 
  /* ignore everything after '#' */
  c = memrchr (line, (unsigned char) '#', line_len);
  if (NULL != c)
    line_len = c - line;
  /* ignore leading whitespace */
  while ((0 < line_len) && isspace ((unsigned char) *line))
  {
    line++;
    line_len--;
  }
  tbuf = GNUNET_strndup (line, line_len);
  tok = strtok (tbuf, " \t");
  if (NULL == tok)
  {
    GNUNET_free (tbuf);
    return;
  }
  if (1 == inet_pton (AF_INET, tok, &v4))
  {
    while (NULL != (tok = strtok (NULL, " \t")))
      add_host (tok, GNUNET_DNSPARSER_TYPE_A, &v4, sizeof(struct in_addr));
  }
  else if (1 == inet_pton (AF_INET6, tok, &v6))
  {
    while (NULL != (tok = strtok (NULL, " \t")))
      add_host (tok, GNUNET_DNSPARSER_TYPE_AAAA, &v6, sizeof(struct in6_addr));
  }
  GNUNET_free (tbuf);
}

References add_host(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_free, GNUNET_strndup, line, and memrchr.

Referenced by load_etc_hosts().

Here is the call graph for this function:

Here is the caller graph for this function:

load_etc_hosts()

static void load_etc_hosts ( void  )

static

Reads the list of hosts from /etc/hosts.

Definition at line 1208 of file gnunet-service-resolver.c.

{
  struct GNUNET_DISK_FileHandle *fh;
  struct GNUNET_DISK_MapHandle *mh;
  off_t bytes_read;
  const char *buf;
  size_t read_offset;
 
  fh = GNUNET_DISK_file_open ("/etc/hosts",
                              GNUNET_DISK_OPEN_READ,
                              GNUNET_DISK_PERM_NONE);
  if (NULL == fh)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Failed to open /etc/hosts");
    return;
  }
  if (GNUNET_OK != GNUNET_DISK_file_handle_size (fh, &bytes_read))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "Could not determine size of /etc/hosts. "
                "DNS resolution will not be possible.\n");
    GNUNET_DISK_file_close (fh);
    return;
  }
  if (((unsigned long long) bytes_read) > (unsigned long long) SIZE_MAX)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                "/etc/hosts file too large to mmap. "
                "DNS resolution will not be possible.\n");
    GNUNET_DISK_file_close (fh);
    return;
  }
  buf = GNUNET_DISK_file_map (fh,
                              &mh,
                              GNUNET_DISK_MAP_TYPE_READ,
                              (size_t) bytes_read);
  read_offset = 0;
  while (read_offset < (size_t) bytes_read)
  {
    const char *newline;
    size_t line_len;
 
    newline = strchr (buf + read_offset, '\n');
    if (NULL == newline)
      break;
    line_len = newline - buf - read_offset;
    extract_hosts (buf + read_offset, line_len);
    read_offset += line_len + 1;
  }
  GNUNET_DISK_file_unmap (mh);
  GNUNET_DISK_file_close (fh);
}

References buf, extract_hosts(), fh, GNUNET_DISK_file_close(), GNUNET_DISK_file_handle_size(), GNUNET_DISK_file_map(), GNUNET_DISK_file_open(), GNUNET_DISK_file_unmap(), GNUNET_DISK_MAP_TYPE_READ, GNUNET_DISK_OPEN_READ, GNUNET_DISK_PERM_NONE, GNUNET_ERROR_TYPE_ERROR, GNUNET_ERROR_TYPE_INFO, GNUNET_log, GNUNET_OK, mh, and SIZE_MAX.

Referenced by init_cb().

Here is the call graph for this function:

Here is the caller graph for this function:

init_cb()

static void init_cb ( void *  cls, const struct GNUNET_CONFIGURATION_Handle *  cfg, struct GNUNET_SERVICE_Handle *  sh  )

static

Service is starting, initialize everything.

Parameters

cls	NULL, unused
cfg	our configuration
sh	service handle

Definition at line 1270 of file gnunet-service-resolver.c.

{
  char **dns_servers;
  int num_dns_servers;
 
  (void) cfg;
  (void) sh;
  load_etc_hosts ();
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task, cls);
  dnsstub_ctx = GNUNET_DNSSTUB_start (128);
  dns_servers = NULL;
  num_dns_servers = lookup_dns_servers (&dns_servers);
  if (0 >= num_dns_servers)
  {
    GNUNET_log (
      GNUNET_ERROR_TYPE_ERROR,
      _ ("No DNS server available. DNS resolution will not be possible.\n"));
    return;
  }
  for (int i = 0; i < num_dns_servers; i++)
  {
    int result = GNUNET_DNSSTUB_add_dns_ip (dnsstub_ctx, dns_servers[i]);
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Adding DNS server '%s': %s\n",
                dns_servers[i],
                GNUNET_OK == result ? "success" : "failure");
    GNUNET_free (dns_servers[i]);
  }
  GNUNET_free (dns_servers);
}

References _, cfg, dnsstub_ctx, GNUNET_DNSSTUB_add_dns_ip(), GNUNET_DNSSTUB_start(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_OK, GNUNET_SCHEDULER_add_shutdown(), load_etc_hosts(), lookup_dns_servers(), result, sh, and shutdown_task().

Here is the call graph for this function:

connect_cb()

static void* connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, struct GNUNET_MQ_Handle *  mq  )

static

Callback called when a client connects to the service.

Parameters

cls	closure for the service, unused
c	the new client that connected to the service
mq	the message queue used to send messages to the client

Returns

c

Definition at line 1313 of file gnunet-service-resolver.c.

{
  (void) cls;
  (void) mq;
 
  return c;
}

References mq.

disconnect_cb()

static void disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  c, void *  internal_cls  )

static

Callback called when a client disconnected from the service.

Parameters

cls	closure for the service
c	the client that disconnected
internal_cls	should be equal to c

Definition at line 1332 of file gnunet-service-resolver.c.

{
  struct ActiveLookup *n;
 
  (void) cls;
 
  GNUNET_assert (c == internal_cls);
  n = lookup_head;
  for (struct ActiveLookup *al = n; NULL != al; al = n)
  {
    n = al->next;
    if (al->client == c)
      free_active_lookup (al);
  }
}

References free_active_lookup(), GNUNET_assert, lookup_head, and ActiveLookup::next.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"resolver"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	init_cb,
		&	connect_cb,
		&	disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(get, GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST, struct GNUNET_RESOLVER_GetMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

cache_head

struct ResolveCache* cache_head

static

Start of the linked list of cached DNS lookup results.

Definition at line 161 of file gnunet-service-resolver.c.

Referenced by cache_answers(), free_cache_entry(), shutdown_task(), and try_cache().

cache_tail

struct ResolveCache* cache_tail

static

Tail of the linked list of cached DNS lookup results.

Definition at line 166 of file gnunet-service-resolver.c.

Referenced by cache_answers(), free_cache_entry(), handle_resolve_result(), and try_cache().

hosts_head

struct ResolveCache* hosts_head

static

Head of the linked list of DNS lookup results from /etc/hosts.

Definition at line 171 of file gnunet-service-resolver.c.

Referenced by add_host(), free_hosts_entry(), shutdown_task(), and try_cache().

hosts_tail

struct ResolveCache* hosts_tail

static

Tail of the linked list of DNS lookup results from /etc/hosts.

Definition at line 176 of file gnunet-service-resolver.c.

Referenced by add_host(), and free_hosts_entry().

lookup_head

struct ActiveLookup* lookup_head

static

Start of the linked list of active DNS lookups.

Definition at line 181 of file gnunet-service-resolver.c.

Referenced by disconnect_cb(), free_active_lookup(), resolve_and_cache(), and shutdown_task().

lookup_tail

struct ActiveLookup* lookup_tail

static

Tail of the linked list of active DNS lookups.

Definition at line 186 of file gnunet-service-resolver.c.

Referenced by free_active_lookup(), and resolve_and_cache().

dnsstub_ctx

struct GNUNET_DNSSTUB_Context* dnsstub_ctx

static

context of dnsstub library

Definition at line 191 of file gnunet-service-resolver.c.

Referenced by handle_resolve_result(), init_cb(), resolve_and_cache(), and shutdown_task().

my_domain

char* my_domain

static

My domain, to be appended to the hostname to get a FQDN.

Definition at line 196 of file gnunet-service-resolver.c.

Referenced by lookup_dns_servers(), process_get(), and shutdown_task().

cache_size

unsigned int cache_size

static

How many entries do we have in cache_head DLL?

Definition at line 201 of file gnunet-service-resolver.c.

Referenced by cache_answers(), free_cache_entry(), free_hosts_entry(), and handle_resolve_result().