GNS service

GNU Name System. More...

Collaboration diagram for GNS service:

Typedefs
typedef void(*	GNUNET_GNS_LookupResultProcessor) (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Iterator called on obtained result for a GNS lookup. More...
typedef void(*	GNUNET_GNS_LookupResultProcessor2) (void *cls, int gns_tld, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)
	Iterator called on obtained result for a GNS lookup where "not GNS" is a valid answer. More...

Enumerations
enum	GNUNET_GNS_LocalOptions { GNUNET_GNS_LO_DEFAULT = 0 , GNUNET_GNS_LO_NO_DHT = 1 , GNUNET_GNS_LO_LOCAL_MASTER = 2 }
	Options for the GNS lookup. More...

Functions
struct GNUNET_GNS_Handle *	GNUNET_GNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg)
	Initialize the connection with the GNS service. More...
void	GNUNET_GNS_disconnect (struct GNUNET_GNS_Handle *handle)
	Shutdown connection with the GNS service. More...
struct GNUNET_GNS_LookupRequest *	GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle, const char *name, const struct GNUNET_IDENTITY_PublicKey *zone, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor proc, void *proc_cls)
	Perform an asynchronous lookup operation on the GNS. More...
struct GNUNET_GNS_LookupRequest *	GNUNET_GNS_lookup_limited (struct GNUNET_GNS_Handle *handle, const char *name, const struct GNUNET_IDENTITY_PublicKey *zone, uint32_t type, enum GNUNET_GNS_LocalOptions options, uint16_t recursion_depth_limit, GNUNET_GNS_LookupResultProcessor proc, void *proc_cls)
	Perform an asynchronous lookup operation on the GNS. More...
void *	GNUNET_GNS_lookup_cancel (struct GNUNET_GNS_LookupRequest *lr)
	Cancel pending lookup request. More...
struct GNUNET_GNS_LookupWithTldRequest *	GNUNET_GNS_lookup_with_tld (struct GNUNET_GNS_Handle *handle, const char *name, uint32_t type, enum GNUNET_GNS_LocalOptions options, GNUNET_GNS_LookupResultProcessor2 proc, void *proc_cls)
	Perform an asynchronous lookup operation on the GNS, determining the zone using the TLD of the given name and the current configuration to resolve TLDs to zones. More...
void *	GNUNET_GNS_lookup_with_tld_cancel (struct GNUNET_GNS_LookupWithTldRequest *ltr)
	Cancel pending lookup request. More...

Detailed Description

GNU Name System.

See also

Documentation

Typedef Documentation

GNUNET_GNS_LookupResultProcessor

typedef void(* GNUNET_GNS_LookupResultProcessor) (void *cls, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)

Iterator called on obtained result for a GNS lookup.

Parameters

cls	closure
rd_count	number of records in rd
rd	the records in reply

Definition at line 96 of file gnunet_gns_service.h.

GNUNET_GNS_LookupResultProcessor2

typedef void(* GNUNET_GNS_LookupResultProcessor2) (void *cls, int gns_tld, uint32_t rd_count, const struct GNUNET_GNSRECORD_Data *rd)

Iterator called on obtained result for a GNS lookup where "not GNS" is a valid answer.

Parameters

cls	closure
gns_tld	GNUNET_YES if a GNS lookup was attempted, GNUNET_NO if the TLD is not configured for GNS
rd_count	number of records in rd
rd	the records in the reply

Definition at line 192 of file gnunet_gns_service.h.

Enumeration Type Documentation

GNUNET_GNS_LocalOptions

enum GNUNET_GNS_LocalOptions

Options for the GNS lookup.

Enumerator
GNUNET_GNS_LO_DEFAULT	Defaults, look in cache, then in DHT.
GNUNET_GNS_LO_NO_DHT	Never look in the DHT, keep request to local cache.
GNUNET_GNS_LO_LOCAL_MASTER	For the rightmost label, only look in the cache (it is our local namestore), for the others, the DHT is OK.

Definition at line 105 of file gnunet_gns_service.h.

{
  GNUNET_GNS_LO_DEFAULT = 0,
 
  GNUNET_GNS_LO_NO_DHT = 1,
 
  GNUNET_GNS_LO_LOCAL_MASTER = 2
};

Function Documentation

GNUNET_GNS_connect()

struct GNUNET_GNS_Handle* GNUNET_GNS_connect

(

const struct GNUNET_CONFIGURATION_Handle *

cfg

)

Initialize the connection with the GNS service.

Parameters

cfg	configuration to use

Returns

handle to the GNS service, or NULL on error

Definition at line 268 of file gns_api.c.

{
  struct GNUNET_GNS_Handle *handle;
 
  handle = GNUNET_new (struct GNUNET_GNS_Handle);
  handle->cfg = cfg;
  reconnect (handle);
  if (NULL == handle->mq)
  {
    GNUNET_free (handle);
    return NULL;
  }
  return handle;
}

References cfg, GNUNET_DNS_Handle::cfg, GNUNET_free, GNUNET_new, handle, GNUNET_DNS_Handle::mq, and reconnect().

Referenced by GNUNET_CONVERSATION_call_start(), libgnunet_plugin_rest_gns_init(), libgnunet_plugin_rest_openid_connect_init(), RECLAIM_TICKETS_init(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNS_disconnect()

void GNUNET_GNS_disconnect

(

struct GNUNET_GNS_Handle *

handle

)

Shutdown connection with the GNS service.

Parameters

handle	connection to shut down
handle	handle of the GNS connection to stop

Definition at line 290 of file gns_api.c.

{
  if (NULL != handle->mq)
  {
    GNUNET_MQ_destroy (handle->mq);
    handle->mq = NULL;
  }
  if (NULL != handle->reconnect_task)
  {
    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
    handle->reconnect_task = NULL;
  }
  GNUNET_assert (NULL == handle->lookup_head);
  GNUNET_free (handle);
}

References GNUNET_assert, GNUNET_free, GNUNET_MQ_destroy(), GNUNET_SCHEDULER_cancel(), handle, GNUNET_DNS_Handle::mq, and GNUNET_DNS_Handle::reconnect_task.

Referenced by cleanup(), do_shutdown(), GNUNET_CONVERSATION_call_stop(), libgnunet_plugin_rest_gns_done(), libgnunet_plugin_rest_openid_connect_done(), RECLAIM_TICKETS_deinit(), run(), and shutdown_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNS_lookup()

struct GNUNET_GNS_LookupRequest* GNUNET_GNS_lookup	(	struct GNUNET_GNS_Handle *	handle,
		const char *	name,
		const struct GNUNET_IDENTITY_PublicKey *	zone,
		uint32_t	type,
		enum GNUNET_GNS_LocalOptions	options,
		GNUNET_GNS_LookupResultProcessor	proc,
		void *	proc_cls
	)

Perform an asynchronous lookup operation on the GNS.

Parameters

handle	handle to the GNS service
name	the name to look up (in UTF-8 encoding)
zone	zone to look in
type	the GNS record type to look for
options	local options for the lookup
proc	function to call on result
proc_cls	closure for proc

Returns

handle to the queued request

Parameters

handle	handle to the GNS service
name	the name to look up (in UTF-8 encoding)
zone	the zone to start the resolution in
type	the record type to look up
options	local options for the lookup
proc	processor to call on result
proc_cls	closure for proc

Returns

handle to the get request

Definition at line 422 of file gns_api.c.

{
  return GNUNET_GNS_lookup_limited (handle,
                                    name,
                                    zone,
                                    type,
                                    options,
                                    DEFAULT_LIMIT,
                                    proc,
                                    proc_cls);
}

References DEFAULT_LIMIT, GNUNET_GNS_lookup_limited(), handle, name, options, GNUNET_GNS_LookupRequest::proc_cls, type, and zone.

Referenced by backward_resolution(), client_redirect(), delegation_chain_bw_resolution_start(), delegation_chain_fw_resolution_start(), forward_resolution(), lookup_authz_cb(), lookup_with_public_key(), and RECLAIM_TICKETS_consume().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNS_lookup_limited()

struct GNUNET_GNS_LookupRequest* GNUNET_GNS_lookup_limited	(	struct GNUNET_GNS_Handle *	handle,
		const char *	name,
		const struct GNUNET_IDENTITY_PublicKey *	zone,
		uint32_t	type,
		enum GNUNET_GNS_LocalOptions	options,
		uint16_t	recursion_depth_limit,
		GNUNET_GNS_LookupResultProcessor	proc,
		void *	proc_cls
	)

Perform an asynchronous lookup operation on the GNS.

Parameters

handle	handle to the GNS service
name	the name to look up (in UTF-8 encoding)
zone	zone to look in
type	the GNS record type to look for
options	local options for the lookup
recursion_depth_limit	maximum number of zones that the lookup may (still) traverse
proc	function to call on result
proc_cls	closure for proc

Returns

handle to the queued request

Definition at line 344 of file gns_api.c.

{
  /* IPC to shorten gns names, return shorten_handle */
  struct LookupMessage *lookup_msg;
  struct GNUNET_GNS_LookupRequest *lr;
  size_t nlen;
  size_t key_len;
  ssize_t written;
  char *buf;
 
  if (NULL == name)
  {
    GNUNET_break (0);
    return NULL;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Trying to lookup `%s' in GNS\n",
       name);
  nlen = strlen (name) + 1;
  if (nlen >= GNUNET_MAX_MESSAGE_SIZE - sizeof(*lr))
  {
    GNUNET_break (0);
    return NULL;
  }
  lr = GNUNET_new (struct GNUNET_GNS_LookupRequest);
  lr->gns_handle = handle;
  lr->lookup_proc = proc;
  lr->proc_cls = proc_cls;
  lr->r_id = handle->r_id_gen++;
  key_len = GNUNET_IDENTITY_public_key_get_length (zone);
  lr->env = GNUNET_MQ_msg_extra (lookup_msg,
                                 nlen + key_len,
                                 GNUNET_MESSAGE_TYPE_GNS_LOOKUP);
  buf = (char *) &lookup_msg[1];
  lookup_msg->id = htonl (lr->r_id);
  lookup_msg->options = htons ((uint16_t) options);
  lookup_msg->recursion_depth_limit
    = htons (recursion_depth_limit);
  lookup_msg->key_len = htonl (key_len);
  written = GNUNET_IDENTITY_write_public_key_to_buffer (zone,
                                                        buf,
                                                        key_len);
  GNUNET_assert (0 <= written);
  buf += written;
  lookup_msg->type = htonl (type);
  GNUNET_memcpy (buf,
                 name,
                 nlen);
  GNUNET_CONTAINER_DLL_insert (handle->lookup_head,
                               handle->lookup_tail,
                               lr);
  if (NULL != handle->mq)
    GNUNET_MQ_send_copy (handle->mq,
                         lr->env);
  return lr;
}

References buf, GNUNET_GNS_LookupWithTldRequest::gns_handle, GNUNET_assert, GNUNET_break, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_DEBUG, GNUNET_IDENTITY_public_key_get_length(), GNUNET_IDENTITY_write_public_key_to_buffer(), GNUNET_MAX_MESSAGE_SIZE, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, GNUNET_MQ_msg_extra, GNUNET_MQ_send_copy(), GNUNET_new, handle, LookupMessage::id, LookupMessage::key_len, LOG, GNUNET_GNS_LookupWithTldRequest::lookup_proc, lr, GNUNET_DNS_Handle::mq, name, options, LookupMessage::options, GNUNET_GNS_LookupRequest::proc_cls, LookupMessage::recursion_depth_limit, LookupMessage::type, type, and zone.

Referenced by GNUNET_GNS_lookup().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNS_lookup_cancel()

void* GNUNET_GNS_lookup_cancel

(

struct GNUNET_GNS_LookupRequest *

lr

)

Cancel pending lookup request.

Parameters

lr	the lookup request to cancel

Returns

closure from the lookup result processor

Definition at line 314 of file gns_api.c.

{
  struct GNUNET_GNS_Handle *handle = lr->gns_handle;
  void *ret;
 
  GNUNET_CONTAINER_DLL_remove (handle->lookup_head,
                               handle->lookup_tail,
                               lr);
  GNUNET_MQ_discard (lr->env);
  ret = lr->proc_cls;
  GNUNET_free (lr);
  return ret;
}

References GNUNET_GNS_LookupWithTldRequest::gns_handle, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_MQ_discard(), handle, lr, and ret.

Referenced by abort_parallel_lookups(), cleanup_cth(), cleanup_dsq_entry(), cleanup_handle(), and GNUNET_GNS_lookup_with_tld_cancel().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNS_lookup_with_tld()

struct GNUNET_GNS_LookupWithTldRequest* GNUNET_GNS_lookup_with_tld	(	struct GNUNET_GNS_Handle *	handle,
		const char *	name,
		uint32_t	type,
		enum GNUNET_GNS_LocalOptions	options,
		GNUNET_GNS_LookupResultProcessor2	proc,
		void *	proc_cls
	)

Perform an asynchronous lookup operation on the GNS, determining the zone using the TLD of the given name and the current configuration to resolve TLDs to zones.

Parameters

handle	handle to the GNS service
name	the name to look up, including TLD (in UTF-8 encoding)
type	the record type to look up
options	local options for the lookup
proc	processor to call on result
proc_cls	closure for proc

Returns

handle to the get request

Parameters

handle	handle to the GNS service
name	the name to look up, including TLD (in UTF-8 encoding)
type	the record type to look up
options	local options for the lookup
proc	processor to call on result
proc_cls	closure for proc

Returns

handle to the get request, NULL on error (e.g. bad configuration)

Definition at line 241 of file gns_tld_api.c.

{
  struct GNUNET_GNS_LookupWithTldRequest *ltr;
  const char *tld;
  char *dot_tld;
  char *zonestr;
  struct GNUNET_IDENTITY_PublicKey pkey;
 
  ltr = GNUNET_new (struct GNUNET_GNS_LookupWithTldRequest);
  ltr->gns_handle = handle;
  ltr->name = GNUNET_strdup (name);
  ltr->type = type;
  ltr->options = options;
  ltr->lookup_proc = proc;
  ltr->lookup_proc_cls = proc_cls;
  /* start with trivial case: TLD is zkey */
  tld = get_tld (ltr->name);
  if (GNUNET_OK ==
      GNUNET_IDENTITY_public_key_from_string (tld, &pkey))
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "`%s' seems to be a valid zone key\n", tld);
    eat_tld (ltr->name, tld);
    lookup_with_public_key (ltr, &pkey);
    return ltr;
  }
 
  /* second case: domain is mapped in our configuration file */
  for (const char *domain = name; NULL != domain;
       domain = strchr (domain, (unsigned char) '.'))
  {
    if ('.' == domain[0])
      domain++;
    GNUNET_asprintf (&dot_tld, ".%s", domain);
    if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (handle->cfg,
                                                            "gns",
                                                            dot_tld,
                                                            &zonestr))
    {
      if (GNUNET_OK !=
          GNUNET_IDENTITY_public_key_from_string (zonestr,
                                                  &pkey))
      {
        GNUNET_log_config_invalid (
          GNUNET_ERROR_TYPE_ERROR,
          "gns",
          dot_tld,
          _ ("Expected a base32-encoded public zone key\n"));
        GNUNET_free (zonestr);
        GNUNET_free (dot_tld);
        GNUNET_free (ltr->name);
        GNUNET_free (ltr);
        return NULL;
      }
      eat_tld (ltr->name, &dot_tld[1]);
      GNUNET_free (zonestr);
      GNUNET_free (dot_tld);
      lookup_with_public_key (ltr, &pkey);
      return ltr;
    }
    GNUNET_free (dot_tld);
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "`%s' should be a valid ego\n", ltr->name);
  ltr->id_co =
    GNUNET_IDENTITY_ego_lookup_by_suffix (ltr->gns_handle->cfg,
                                          ltr->name,
                                          &identity_zone_cb,
                                          ltr);
  if (NULL == ltr->id_co)
  {
    GNUNET_free (ltr->name);
    GNUNET_free (ltr);
    return NULL;
  }
  return ltr;
}

References _, GNUNET_DNS_Handle::cfg, GNUNET_GNS_Handle::cfg, eat_tld(), get_tld(), GNUNET_GNS_LookupWithTldRequest::gns_handle, GNUNET_asprintf(), GNUNET_CONFIGURATION_get_value_string(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_IDENTITY_ego_lookup_by_suffix(), GNUNET_IDENTITY_public_key_from_string(), GNUNET_log_config_invalid(), GNUNET_new, GNUNET_OK, GNUNET_strdup, handle, GNUNET_GNS_LookupWithTldRequest::id_co, identity_zone_cb(), LOG, GNUNET_GNS_LookupWithTldRequest::lookup_proc, GNUNET_GNS_LookupWithTldRequest::lookup_proc_cls, lookup_with_public_key(), name, GNUNET_GNS_LookupWithTldRequest::name, options, GNUNET_GNS_LookupWithTldRequest::options, pkey, GNUNET_GNS_LookupWithTldRequest::type, and type.

Referenced by do_s5r_read(), get_gns_cont(), GNUNET_CONVERSATION_call_start(), handle_request(), process_queue(), and run().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_GNS_lookup_with_tld_cancel()

void* GNUNET_GNS_lookup_with_tld_cancel

(

struct GNUNET_GNS_LookupWithTldRequest *

ltr

)

Cancel pending lookup request.

Parameters

ltr	the lookup request to cancel

Returns

closure from the lookup result processor

Definition at line 332 of file gns_tld_api.c.

{
  void *ret = ltr->lookup_proc_cls;
 
  if (NULL != ltr->id_co)
  {
    GNUNET_IDENTITY_ego_lookup_by_suffix_cancel (ltr->id_co);
    ltr->id_co = NULL;
  }
  if (NULL != ltr->lr)
  {
    GNUNET_GNS_lookup_cancel (ltr->lr);
    ltr->lr = NULL;
  }
  GNUNET_free (ltr->longest_match);
  GNUNET_free (ltr->name);
  GNUNET_free (ltr);
  return ret;
}

References GNUNET_free, GNUNET_GNS_lookup_cancel(), GNUNET_IDENTITY_ego_lookup_by_suffix_cancel(), GNUNET_GNS_LookupWithTldRequest::id_co, GNUNET_GNS_LookupWithTldRequest::longest_match, GNUNET_GNS_LookupWithTldRequest::lookup_proc_cls, GNUNET_GNS_LookupWithTldRequest::lr, GNUNET_GNS_LookupWithTldRequest::name, and ret.

Referenced by cleanup_handle(), cleanup_s5r(), do_shutdown(), do_timeout(), free_request(), GNUNET_CONVERSATION_call_stop(), and process_lookup_result().

Here is the call graph for this function:

Here is the caller graph for this function: