gnunet-service-gns.c File Reference

GNU Name System (main service) More...

#include "gnunet_common.h"
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dns_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_namecache_service.h"
#include "gnunet_gnsrecord_lib.h"
#include "gnunet_gns_service.h"
#include "gnunet_statistics_service.h"
#include "gns.h"
#include "gnunet-service-gns.h"
#include "gnunet-service-gns_resolver.h"
#include "gnunet-service-gns_interceptor.h"
#include "gnunet_protocols.h"

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

Go to the source code of this file.

Data Structures
struct	ClientLookupHandle
	Handle to a lookup operation from client via API. More...
struct	GnsClient
	Information we track per connected client. More...
struct	GNS_TopLevelDomain
	Representation of a TLD, mapping the respective TLD string (e.g. More...

Functions
enum GNUNET_GenericReturnValue	GNS_find_tld (const char *tld_str, struct GNUNET_CRYPTO_PublicKey *pkey)
	Find GNS zone belonging to TLD tld. More...
const char *	GNS_get_tld (const char *name)
	Obtain the TLD of the given name. More...
static void	shutdown_task (void *cls)
	Task run during shutdown. More...
static void	client_disconnect_cb (void *cls, struct GNUNET_SERVICE_Client *client, void *app_ctx)
	Called whenever a client is disconnected. More...
static void *	client_connect_cb (void *cls, struct GNUNET_SERVICE_Client *client, struct GNUNET_MQ_Handle *mq)
	Add a client to our list of active clients. More...
static void	send_lookup_response (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Reply to client with the result from our lookup. More...
static int	check_lookup (void *cls, const struct LookupMessage *l_msg)
	Checks a GNUNET_MESSAGE_TYPE_GNS_LOOKUP message. More...
static void	handle_lookup (void *cls, const struct LookupMessage *sh_msg)
	Handle lookup requests from client. More...
static void	read_service_conf (void *cls, const char *section, const char *option, const char *value)
	Reads the configuration and populates TLDs. More...
static void	run (void *cls, const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_SERVICE_Handle *service)
	Process GNS requests. More...
	GNUNET_SERVICE_MAIN ("gns", GNUNET_SERVICE_OPTION_NONE, &run, &client_connect_cb, &client_disconnect_cb, NULL, GNUNET_MQ_hd_var_size(lookup, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, struct LookupMessage, NULL), GNUNET_MQ_handler_end())
	Define "main" method using service macro. More...

Variables
static struct GNUNET_DHT_Handle *	dht_handle
	Our handle to the DHT. More...
static struct GNUNET_NAMECACHE_Handle *	namecache_handle
	Our handle to the namecache service. More...
static int	v6_enabled
	GNUNET_YES if ipv6 is supported More...
static int	v4_enabled
	GNUNET_YES if ipv4 is supported More...
static struct GNUNET_STATISTICS_Handle *	statistics
	Handle to the statistics service. More...
static struct GNS_TopLevelDomain *	tld_head
	Head of DLL of TLDs we map to GNS zones. More...
static struct GNS_TopLevelDomain *	tld_tail
	Tail of DLL of TLDs we map to GNS zones. More...

Detailed Description

GNU Name System (main service)

Author

Martin Schanzenbach

Christian Grothoff

Definition in file gnunet-service-gns.c.

Function Documentation

GNS_find_tld()

enum GNUNET_GenericReturnValue GNS_find_tld	(	const char *	tld_str,
		struct GNUNET_CRYPTO_PublicKey *	pkey
	)

Find GNS zone belonging to TLD tld.

Parameters

	tld_str	top-level domain to look up
[out]	pkey	public key to set

Returns

GNUNET_YES if tld was found GNUNET_NO if not

Definition at line 180 of file gnunet-service-gns.c.

{
  if ('\0' == *tld_str)
    return GNUNET_NO;
  for (struct GNS_TopLevelDomain *tld = tld_head;
       NULL != tld;
       tld = tld->next)
  {
    if (0 == strcasecmp (tld_str,
                         tld->tld))
    {
      *pkey = tld->pkey;
      return GNUNET_YES;
    }
  }
  if (GNUNET_OK ==
      GNUNET_GNSRECORD_zkey_to_pkey (tld_str + 1,
                                     pkey))
    return GNUNET_YES; /* TLD string *was* the public key */
  return GNUNET_NO;
}

References GNUNET_GNSRECORD_zkey_to_pkey(), GNUNET_NO, GNUNET_OK, GNUNET_YES, pkey, GNS_TopLevelDomain::tld, and tld_head.

Referenced by handle_dns_request().

Here is the call graph for this function:

Here is the caller graph for this function:

GNS_get_tld()

const char * GNS_get_tld

(

const char *

name

)

Obtain the TLD of the given name.

Parameters

name

a name

Returns

the part of name after the last ".", or name if name does not contain a "."

Definition at line 212 of file gnunet-service-gns.c.

{
  const char *tld;
 
  tld = strrchr (name,
                 (unsigned char) '.');
  if (NULL == tld)
    tld = name;
  else
    tld++; /* skip the '.' */
  return tld;
}

References name, and GNS_TopLevelDomain::tld.

Referenced by handle_dns_request(), handle_gns_redirect_result(), and recursive_gns2dns_resolution().

Here is the caller graph for this function:

shutdown_task()

static void shutdown_task ( void *  cls )

static

Task run during shutdown.

Parameters

cls	unused, NULL

Definition at line 232 of file gnunet-service-gns.c.

{
  struct GNS_TopLevelDomain *tld;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Shutting down!\n");
  GNS_interceptor_done ();
  GNS_resolver_done ();
  if (NULL != statistics)
  {
    GNUNET_STATISTICS_destroy (statistics,
                               GNUNET_NO);
    statistics = NULL;
  }
  if (NULL != namecache_handle)
  {
    GNUNET_NAMECACHE_disconnect (namecache_handle);
    namecache_handle = NULL;
  }
  if (NULL != dht_handle)
  {
    GNUNET_DHT_disconnect (dht_handle);
    dht_handle = NULL;
  }
  while (NULL != (tld = tld_head))
  {
    GNUNET_CONTAINER_DLL_remove (tld_head,
                                 tld_tail,
                                 tld);
    GNUNET_free (tld->tld);
    GNUNET_free (tld);
  }
}

References dht_handle, GNS_interceptor_done(), GNS_resolver_done(), GNUNET_CONTAINER_DLL_remove, GNUNET_DHT_disconnect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, GNUNET_NAMECACHE_disconnect(), GNUNET_NO, GNUNET_STATISTICS_destroy(), namecache_handle, statistics, GNS_TopLevelDomain::tld, tld_head, and tld_tail.

Referenced by run().

Here is the call graph for this function:

Here is the caller graph for this function:

client_disconnect_cb()

static void client_disconnect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, void *  app_ctx  )

static

Called whenever a client is disconnected.

Parameters

cls	closure
client	identification of the client
app_ctx	client

Definition at line 276 of file gnunet-service-gns.c.

{
  struct ClientLookupHandle *clh;
  struct GnsClient *gc = app_ctx;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p disconnected\n",
              client);
  while (NULL != (clh = gc->clh_head))
  {
    if (NULL != clh->lookup)
      GNS_resolver_lookup_cancel (clh->lookup);
    GNUNET_CONTAINER_DLL_remove (gc->clh_head,
                                 gc->clh_tail,
                                 clh);
    GNUNET_free (clh);
  }
  GNUNET_free (gc);
}

References GnsClient::clh_head, GnsClient::clh_tail, GnsClient::client, GNS_resolver_lookup_cancel(), GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_log, and ClientLookupHandle::lookup.

Here is the call graph for this function:

client_connect_cb()

static void * client_connect_cb ( void *  cls, struct GNUNET_SERVICE_Client *  client, struct GNUNET_MQ_Handle *  mq  )

static

Add a client to our list of active clients.

Parameters

cls	NULL
client	client to add
mq	message queue for client

Returns

internal namestore client structure for this client

Definition at line 309 of file gnunet-service-gns.c.

{
  struct GnsClient *gc;
 
  (void) cls;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Client %p connected\n",
              client);
  gc = GNUNET_new (struct GnsClient);
  gc->client = client;
  gc->mq = mq;
  return gc;
}

References GnsClient::client, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, mq, and GnsClient::mq.

send_lookup_response()

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

static

Reply to client with the result from our lookup.

Parameters

cls	the closure (our client lookup handle)
rd_count	the number of records in rd
rd	the record data

Definition at line 334 of file gnunet-service-gns.c.

{
  struct ClientLookupHandle *clh = cls;
  struct GnsClient *gc = clh->gc;
  struct GNUNET_MQ_Envelope *env;
  struct LookupResultMessage *rmsg;
  ssize_t len;
 
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Sending LOOKUP_RESULT message with %u results\n",
              (unsigned int) rd_count);
  len = GNUNET_GNSRECORD_records_get_size (rd_count,
                                           rd);
  if (len < 0)
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (gc->client);
    return;
  }
  if (len > UINT16_MAX - sizeof(*rmsg))
  {
    GNUNET_break (0);
    GNUNET_SERVICE_client_drop (gc->client);
    return;
  }
  env = GNUNET_MQ_msg_extra (rmsg,
                             len,
                             GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT);
  rmsg->id = clh->request_id;
  rmsg->rd_count = htonl (rd_count);
  GNUNET_assert (len ==
                 GNUNET_GNSRECORD_records_serialize (rd_count,
                                                     rd,
                                                     len,
                                                     (char *) &rmsg[1]));
  GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (gc->client),
                  env);
  GNUNET_CONTAINER_DLL_remove (gc->clh_head,
                               gc->clh_tail,
                               clh);
  GNUNET_free (clh);
  GNUNET_STATISTICS_update (statistics,
                            "Completed lookups", 1,
                            GNUNET_NO);
  GNUNET_STATISTICS_update (statistics,
                            "Records resolved",
                            rd_count,
                            GNUNET_NO);
}

References GnsClient::clh_head, GnsClient::clh_tail, GnsClient::client, env, ClientLookupHandle::gc, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_GNSRECORD_records_get_size(), GNUNET_GNSRECORD_records_serialize(), GNUNET_log, GNUNET_MESSAGE_TYPE_GNS_LOOKUP_RESULT, GNUNET_MQ_msg_extra, GNUNET_MQ_send(), GNUNET_NO, GNUNET_SERVICE_client_drop(), GNUNET_SERVICE_client_get_mq(), GNUNET_STATISTICS_update(), LookupResultMessage::id, rd, rd_count, LookupResultMessage::rd_count, ClientLookupHandle::request_id, and statistics.

Referenced by handle_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

check_lookup()

static int check_lookup ( void *  cls, const struct LookupMessage *  l_msg  )

static

Checks a GNUNET_MESSAGE_TYPE_GNS_LOOKUP message.

Parameters

cls	client sending the message
l_msg	message of type struct LookupMessage

Returns

GNUNET_OK if l_msg is well-formed

Definition at line 395 of file gnunet-service-gns.c.

{
  size_t nlen;
  size_t klen;
 
  (void) cls;
  klen = ntohl (l_msg->key_len);
  nlen = ntohs (l_msg->header.size) - sizeof(struct LookupMessage) - klen;
  if (nlen > GNUNET_DNSPARSER_MAX_NAME_LENGTH)
  {
    GNUNET_break (0);
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References GNUNET_break, GNUNET_DNSPARSER_MAX_NAME_LENGTH, GNUNET_OK, GNUNET_SYSERR, LookupMessage::header, LookupMessage::key_len, and GNUNET_MessageHeader::size.

handle_lookup()

static void handle_lookup ( void *  cls, const struct LookupMessage *  sh_msg  )

static

Handle lookup requests from client.

Parameters

cls	the closure
sh_msg	the message

Definition at line 420 of file gnunet-service-gns.c.

{
  struct GnsClient *gc = cls;
  struct ClientLookupHandle *clh;
  struct GNUNET_CRYPTO_PublicKey zone;
  const char *name;
  size_t key_len;
  size_t read;
 
  GNUNET_SERVICE_client_continue (gc->client);
  key_len = ntohl (sh_msg->key_len);
  clh = GNUNET_new (struct ClientLookupHandle);
  GNUNET_CONTAINER_DLL_insert (gc->clh_head,
                               gc->clh_tail,
                               clh);
  clh->gc = gc;
  clh->request_id = sh_msg->id;
  if ((GNUNET_SYSERR ==
       GNUNET_CRYPTO_read_public_key_from_buffer (&sh_msg[1],
                                                    key_len,
                                                    &zone,
                                                    &read)) ||
      (read != key_len))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "LOOKUP: Failed to read zone key!");
    send_lookup_response (clh,
                          0,
                          NULL);
    return;
  }
  name = (const char *) &sh_msg[1] + key_len;
  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
              "Received LOOKUP `%s' message\n",
              name);
  if ((GNUNET_DNSPARSER_TYPE_A == ntohl (sh_msg->type)) &&
      (GNUNET_OK != v4_enabled))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "LOOKUP: Query for A record but AF_INET not supported!");
    send_lookup_response (clh,
                          0,
                          NULL);
    return;
  }
  if ((GNUNET_DNSPARSER_TYPE_AAAA == ntohl (sh_msg->type)) &&
      (GNUNET_OK != v6_enabled))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "LOOKUP: Query for AAAA record but AF_INET6 not supported!");
    send_lookup_response (clh,
                          0,
                          NULL);
    return;
  }
  clh->lookup = GNS_resolver_lookup (&zone,
                                     ntohl (sh_msg->type),
                                     name,
                                     (enum GNUNET_GNS_LocalOptions) ntohs (
                                       sh_msg->options),
                                     ntohs (sh_msg->recursion_depth_limit),
                                     &send_lookup_response, clh);
  GNUNET_STATISTICS_update (statistics,
                            "Lookup attempts",
                            1, GNUNET_NO);
}

References GnsClient::clh_head, GnsClient::clh_tail, GnsClient::client, ClientLookupHandle::gc, GNS_resolver_lookup(), GNUNET_CONTAINER_DLL_insert, GNUNET_CRYPTO_read_public_key_from_buffer(), GNUNET_DNSPARSER_TYPE_A, GNUNET_DNSPARSER_TYPE_AAAA, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_new, GNUNET_NO, GNUNET_OK, GNUNET_SERVICE_client_continue(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, LookupMessage::id, LookupMessage::key_len, ClientLookupHandle::lookup, name, LookupMessage::options, LookupMessage::recursion_depth_limit, ClientLookupHandle::request_id, send_lookup_response(), statistics, LookupMessage::type, v4_enabled, and v6_enabled.

Here is the call graph for this function:

read_service_conf()

static void read_service_conf ( void *  cls, const char *  section, const char *  option, const char *  value  )

static

Reads the configuration and populates TLDs.

Parameters

cls	unused
section	name of section in config, always "gns"
option	name of the option, TLDs start with "."
value	value for the option, public key for TLDs

Definition at line 498 of file gnunet-service-gns.c.

{
  struct GNUNET_CRYPTO_PublicKey pk;
  struct GNS_TopLevelDomain *tld;
 
  (void) cls;
  (void) section;
  if (option[0] != '.')
    return;
  if (GNUNET_OK !=
      GNUNET_STRINGS_string_to_data (value,
                                     strlen (value),
                                     &pk,
                                     sizeof(pk)))
  {
    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
                               section,
                               option,
                               _ (
                                 "Properly base32-encoded public key required"));
    return;
  }
  tld = GNUNET_new (struct GNS_TopLevelDomain);
  tld->tld = GNUNET_strdup (&option[1]);
  tld->pkey = pk;
  GNUNET_CONTAINER_DLL_insert (tld_head,
                               tld_tail,
                               tld);
}

References _, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_ERROR, GNUNET_log_config_invalid(), GNUNET_new, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_string_to_data(), pk, GNS_TopLevelDomain::tld, tld_head, tld_tail, and value.

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, const struct GNUNET_CONFIGURATION_Handle *  c, struct GNUNET_SERVICE_Handle *  service  )

static

Process GNS requests.

Parameters

cls	closure
server	the initialized server
c	configuration to use

Definition at line 540 of file gnunet-service-gns.c.

{
  unsigned long long max_parallel_bg_queries = 16;
 
  GNUNET_CONFIGURATION_iterate_section_values (c,
                                               "gns",
                                               &read_service_conf,
                                               NULL);
  v6_enabled = GNUNET_NETWORK_test_pf (PF_INET6);
  v4_enabled = GNUNET_NETWORK_test_pf (PF_INET);
  namecache_handle = GNUNET_NAMECACHE_connect (c);
  if (NULL == namecache_handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Failed to connect to the namecache!\n"));
    GNUNET_SCHEDULER_shutdown ();
    return;
  }
  if (GNUNET_OK ==
      GNUNET_CONFIGURATION_get_value_number (c,
                                             "gns",
                                             "MAX_PARALLEL_BACKGROUND_QUERIES",
                                             &max_parallel_bg_queries))
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Number of allowed parallel background queries: %llu\n",
                max_parallel_bg_queries);
  }
  dht_handle = GNUNET_DHT_connect (c,
                                   (unsigned int) max_parallel_bg_queries);
  if (NULL == dht_handle)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                _ ("Could not connect to DHT!\n"));
    GNUNET_SCHEDULER_add_now (&shutdown_task,
                              NULL);
    return;
  }
  GNS_resolver_init (namecache_handle,
                     dht_handle,
                     c,
                     max_parallel_bg_queries);
  if ((GNUNET_YES ==
       GNUNET_CONFIGURATION_get_value_yesno (c,
                                             "gns",
                                             "INTERCEPT_DNS")) &&
      (GNUNET_SYSERR ==
       GNS_interceptor_init (c)))
  {
    GNUNET_break (0);
    GNUNET_SCHEDULER_add_now (&shutdown_task,
                              NULL);
    return;
  }
  statistics = GNUNET_STATISTICS_create ("gns",
                                         c);
  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
                                 NULL);
}

References _, dht_handle, GNS_interceptor_init(), GNS_resolver_init(), GNUNET_break, GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_CONFIGURATION_iterate_section_values(), GNUNET_DHT_connect(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_log, GNUNET_NAMECACHE_connect(), GNUNET_NETWORK_test_pf(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_SYSERR, GNUNET_YES, namecache_handle, read_service_conf(), shutdown_task(), statistics, v4_enabled, and v6_enabled.

Here is the call graph for this function:

GNUNET_SERVICE_MAIN()

GNUNET_SERVICE_MAIN	(	"gns"	,
		GNUNET_SERVICE_OPTION_NONE	,
		&	run,
		&	client_connect_cb,
		&	client_disconnect_cb,
		NULL	,
		GNUNET_MQ_hd_var_size(lookup, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, struct LookupMessage, NULL)	,
		GNUNET_MQ_handler_end()
	)

Define "main" method using service macro.

Variable Documentation

dht_handle

struct GNUNET_DHT_Handle* dht_handle

static

Our handle to the DHT.

Definition at line 139 of file gnunet-service-gns.c.

Referenced by run(), and shutdown_task().

namecache_handle

struct GNUNET_NAMECACHE_Handle* namecache_handle

static

Our handle to the namecache service.

Definition at line 144 of file gnunet-service-gns.c.

Referenced by run(), and shutdown_task().

v6_enabled

int v6_enabled

static

GNUNET_YES if ipv6 is supported

Definition at line 149 of file gnunet-service-gns.c.

Referenced by handle_lookup(), and run().

v4_enabled

int v4_enabled

static

GNUNET_YES if ipv4 is supported

Definition at line 154 of file gnunet-service-gns.c.

Referenced by handle_lookup(), and run().

statistics

struct GNUNET_STATISTICS_Handle* statistics

static

Handle to the statistics service.

Definition at line 159 of file gnunet-service-gns.c.

Referenced by handle_lookup(), run(), send_lookup_response(), and shutdown_task().

tld_head

struct GNS_TopLevelDomain* tld_head

static

Head of DLL of TLDs we map to GNS zones.

Definition at line 164 of file gnunet-service-gns.c.

Referenced by GNS_find_tld(), read_service_conf(), and shutdown_task().

tld_tail

struct GNS_TopLevelDomain* tld_tail

static

Tail of DLL of TLDs we map to GNS zones.

Definition at line 169 of file gnunet-service-gns.c.

Referenced by read_service_conf(), and shutdown_task().