/*
This file is part of GNUnet.
- (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
+ (C) 2011-2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
* @file gns/gnunet-service-gns_resolver.c
* @brief GNUnet GNS resolver logic
* @author Martin Schanzenbach
+ * @author Christian Grothoff
*/
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_transport_service.h"
-#include "gnunet_dns_service.h"
+#include "gnunet_dnsstub_lib.h"
#include "gnunet_dht_service.h"
#include "gnunet_namestore_service.h"
#include "gnunet_dns_service.h"
#include "gns_protocol.h"
#include "gnunet_gns_service.h"
#include "gns_common.h"
-#include "block_gns.h"
#include "gns.h"
#include "gnunet-service-gns_resolver.h"
-#ifndef WINDOWS
#include "gnunet_vpn_service.h"
-#endif
/**
- * Default DHT timeout
+ * Default DHT timeout for lookups.
*/
-#define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT
+#define DHT_LOOKUP_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 60)
/**
* DHT replication level
/**
- * Our handle to the namestore service
+ * DLL to hold the authority chain we had to pass in the resolution
+ * process.
*/
-static struct GNUNET_NAMESTORE_Handle *namestore_handle;
+struct AuthorityChain
+{
+ /**
+ * This is a DLL.
+ */
+ struct AuthorityChain *prev;
-#ifndef WINDOWS
-/**
- * Our handle to the vpn service
- */
-static struct GNUNET_VPN_Handle *vpn_handle;
-#endif
+ /**
+ * This is a DLL.
+ */
+ struct AuthorityChain *next;
-/**
- * Resolver handle to the dht
- */
-static struct GNUNET_DHT_Handle *dht_handle;
+ /**
+ * label corresponding to the authority
+ */
+ char label[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
+
+ /**
+ * #GNUNET_YES if the authority was a GNS authority,
+ * #GNUNET_NO if the authority was a DNS authority.
+ */
+ int gns_authority;
+
+ /**
+ * Information about the resolver authority for this label.
+ */
+ union
+ {
+
+ /**
+ * The zone of the GNS authority
+ */
+ struct GNUNET_CRYPTO_EccPublicKey gns_authority;
+
+ struct
+ {
+ /**
+ * Domain of the DNS resolver that is the authority.
+ * (appended to construct the DNS name to resolve;
+ * this is NOT the DNS name of the DNS server!).
+ */
+ char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+
+ /**
+ * IP address of the DNS resolver that is authoritative.
+ * (this implementation currently only supports one
+ * IP at a time).
+ */
+ struct sockaddr_storage dns_ip;
+
+ } dns_authority;
+
+ } authority_info;
+
+};
-/**
- * Heap for parallel DHT lookups
- */
-static struct GNUNET_CONTAINER_Heap *dht_lookup_heap;
/**
- * Heap for namestore queues
+ * Resolution status indicator
*/
-static struct GNUNET_CONTAINER_Heap *ns_task_heap;
+enum ResolutionStatus
+{
+ /**
+ * the name to lookup exists
+ */
+ RSL_RECORD_EXISTS = 1,
+
+ /**
+ * the name in the record expired
+ */
+ RSL_RECORD_EXPIRED = 2,
+
+ /**
+ * resolution timed out
+ */
+ RSL_TIMED_OUT = 4,
+
+ /**
+ * Found VPN delegation
+ */
+ RSL_DELEGATE_VPN = 8,
+
+ /**
+ * Found NS delegation
+ */
+ RSL_DELEGATE_NS = 16,
+
+ /**
+ * Found PKEY delegation
+ */
+ RSL_DELEGATE_PKEY = 32,
+
+ /**
+ * Found CNAME record
+ */
+ RSL_CNAME_FOUND = 64,
+
+ /**
+ * Found PKEY has been revoked
+ */
+ RSL_PKEY_REVOKED = 128
+};
+
/**
- * Maximum amount of parallel queries in background
+ * Handle to a currenty pending resolution. On result (positive or
+ * negative) the #GNS_ResultProcessor is called.
*/
-static unsigned long long max_allowed_background_queries;
+struct GNS_ResolverHandle
+{
+
+ /**
+ * DLL
+ */
+ struct GNS_ResolverHandle *next;
+
+ /**
+ * DLL
+ */
+ struct GNS_ResolverHandle *prev;
+
+ /**
+ * The top-level GNS authoritative zone to query
+ */
+ struct GNUNET_CRYPTO_EccPublicKey authority_zone;
+
+ /**
+ * called when resolution phase finishes
+ */
+ GNS_ResultProcessor proc;
+
+ /**
+ * closure passed to proc
+ */
+ void* proc_cls;
+
+ /**
+ * Handle for DHT lookups. should be NULL if no lookups are in progress
+ */
+ struct GNUNET_DHT_GetHandle *get_handle;
+
+ /**
+ * Handle to a VPN request, NULL if none is active.
+ */
+ struct GNUNET_VPN_RedirectionRequest *vpn_handle;
+
+ /**
+ * Socket for a DNS request, NULL if none is active.
+ */
+ struct GNUNET_DNSSTUB_RequestSocket *dns_request;
+
+ /**
+ * Pending Namestore task
+ */
+ struct GNUNET_NAMESTORE_QueueEntry *namestore_task;
+
+ /**
+ * Heap node associated with this lookup. Used to limit number of
+ * concurrent requests.
+ */
+ struct GNUNET_CONTAINER_HeapNode *dht_heap_node;
+
+ /**
+ * DLL to store the authority chain
+ */
+ struct AuthorityChain *authority_chain_head;
+
+ /**
+ * DLL to store the authority chain
+ */
+ struct AuthorityChain *authority_chain_tail;
+
+ /**
+ * Private key of the shorten zone, NULL to not shorten.
+ */
+ struct GNUNET_CRYPTO_EccPrivateKey *shorten_key;
+
+ /**
+ * The name to resolve
+ */
+ char name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+
+ /**
+ * Current offset in 'name' where we are resolving.
+ */
+ size_t name_resolution_pos;
+
+ /**
+ * Use only cache
+ */
+ int only_cached;
+
+};
+
/**
- * Maximum amount of parallel namestore tasks in background
+ * Handle for a PSEU lookup used to shorten names.
*/
-static unsigned long long max_allowed_ns_tasks;
+struct GetPseuAuthorityHandle
+{
+ /**
+ * DLL
+ */
+ struct GetPseuAuthorityHandle *next;
+
+ /**
+ * DLL
+ */
+ struct GetPseuAuthorityHandle *prev;
+
+ /**
+ * Private key of the (shorten) zone to store the resulting
+ * pseudonym in.
+ */
+ struct GNUNET_CRYPTO_EccPrivateKey shorten_zone_key;
+
+ /**
+ * Original label (used if no PSEU record is found).
+ */
+ char label[GNUNET_DNSPARSER_MAX_LABEL_LENGTH + 1];
+
+ /**
+ * The zone for which we are trying to find the PSEU record.
+ */
+ struct GNUNET_CRYPTO_EccPublicKey target_zone;
+
+ /**
+ * Handle for DHT lookups. Should be NULL if no lookups are in progress
+ */
+ struct GNUNET_DHT_GetHandle *get_handle;
+
+ /**
+ * Handle to namestore request
+ */
+ struct GNUNET_NAMESTORE_QueueEntry *namestore_task;
+
+ /**
+ * Task to abort DHT lookup operation.
+ */
+ GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+};
+
/**
- * Wheather or not to ignore pending records
+ * Our handle to the namestore service
*/
-static int ignore_pending_records;
+static struct GNUNET_NAMESTORE_Handle *namestore_handle;
/**
- * Our local zone
+ * Our handle to the vpn service
*/
-static struct GNUNET_CRYPTO_ShortHashCode local_zone;
+static struct GNUNET_VPN_Handle *vpn_handle;
/**
- * Background shortening handles
+ * Resolver handle to the dht
*/
-static struct GetPseuAuthorityHandle *gph_head;
+static struct GNUNET_DHT_Handle *dht_handle;
/**
- * Background shortening handles
+ * Handle to perform DNS lookups.
*/
-static struct GetPseuAuthorityHandle *gph_tail;
+static struct GNUNET_DNSSTUB_Context *dns_handle;
/**
- * Resolver lookup list
+ * Heap for limiting parallel DHT lookups
*/
-static struct ResolverHandle *rlh_head;
+static struct GNUNET_CONTAINER_Heap *dht_lookup_heap;
/**
- * Resolver lookup list
+ * Maximum amount of parallel queries in background
*/
-static struct ResolverHandle *rlh_tail;
+static unsigned long long max_allowed_background_queries;
/**
- * Resolver shorten list
+ * Head of PSEU/shorten operations list.
*/
-static struct ResolverHandle *nsh_head;
+struct GetPseuAuthorityHandle *gph_head;
/**
- * Resolver shorten list
+ * Tail of PSEU/shorten operations list.
*/
-static struct ResolverHandle *nsh_tail;
+struct GetPseuAuthorityHandle *gph_tail;
/**
- * Resolver get auth list
+ * Head of resolver lookup list
*/
-static struct ResolverHandle *nah_head;
+static struct GNS_ResolverHandle *rlh_head;
/**
- * Resolver get auth list
+ * Tail of resolver lookup list
*/
-static struct ResolverHandle *nah_tail;
+static struct GNS_ResolverHandle *rlh_tail;
/**
* Global configuration.
*/
static const struct GNUNET_CONFIGURATION_Handle *cfg;
-/**
- * a resolution identifier pool variable
- * This is a non critical identifier useful for debugging
- */
-static unsigned long long rid_gen;
-
/**
* Check if name is in srv format (_x._y.xxx)
}
-static void
-free_get_pseu_authority_handle (struct GetPseuAuthorityHandle *gph)
-{
- gph->namestore_task = NULL;
- GNUNET_free (gph->auth);
- GNUNET_CRYPTO_rsa_key_free (gph->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
- GNUNET_free (gph);
-}
+/* ******************** Shortening logic ************************ */
/**
- * Callback that shortens authorities
+ * Cleanup a 'struct GetPseuAuthorityHandle', terminating all
+ * pending activities.
*
- * @param gph the handle containing the name to shorten
+ * @param gph handle to terminate
*/
static void
-shorten_authority_chain (struct GetPseuAuthorityHandle *gph);
+free_get_pseu_authority_handle (struct GetPseuAuthorityHandle *gph)
+{
+ if (NULL != gph->get_handle)
+ {
+ GNUNET_DHT_get_stop (gph->get_handle);
+ gph->get_handle = NULL;
+ }
+ if (NULL != gph->namestore_task)
+ {
+ GNUNET_NAMESTORE_cancel (gph->namestore_task);
+ gph->namestore_task = NULL;
+ }
+ if (GNUNET_SCHEDULER_NO_TASK != gph->timeout_task)
+ {
+ GNUNET_SCHEDULER_cancel (gph->timeout_task);
+ gph->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+ GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
+ GNUNET_free (gph);
+}
/**
* @param emsg unused
*/
static void
-create_pkey_cont (void* cls, int32_t success, const char* emsg)
+create_pkey_cont (void* cls,
+ int32_t success,
+ const char *emsg)
{
- //FIXME do sth with error
struct GetPseuAuthorityHandle* gph = cls;
+ gph->namestore_task = NULL;
free_get_pseu_authority_handle (gph);
}
/**
* Namestore calls this function if we have record for this name.
- * (or with rd_count=0 to indicate no matches)
+ * (or with rd_count=0 to indicate no matches).
*
* @param cls the pending query
* @param key the key of the zone we did the lookup
- * @param expiration expiration date of the namestore entry
* @param name the name for which we need an authority
* @param rd_count the number of records with 'name'
* @param rd the record data
- * @param signature the signature of the authority for the record data
*/
static void
-process_pseu_lookup_ns (void* cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
- struct GNUNET_TIME_Absolute expiration,
- const char *name, unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+process_pseu_lookup_ns (void *cls,
+ const struct GNUNET_CRYPTO_EccPrivateKey *key,
+ const char *name,
+ unsigned int rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct GetPseuAuthorityHandle* gph = cls;
+ struct GetPseuAuthorityHandle *gph = cls;
struct GNUNET_NAMESTORE_RecordData new_pkey;
+ struct GNUNET_CRYPTO_EccPublicKey pub;
gph->namestore_task = NULL;
if (rd_count > 0)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: Name %s already taken in NS!\n", name);
- free_get_pseu_authority_handle (gph);
+ "Name `%s' already taken, cannot shorten.\n",
+ name);
+ /* if this was not yet the original label, try one more
+ time, this time not using PSEU but the original label */
+ if (0 == strcmp (name,
+ gph->label))
+ {
+ free_get_pseu_authority_handle (gph);
+ }
+ else
+ {
+ GNUNET_CRYPTO_ecc_key_get_public (&gph->shorten_zone_key,
+ &pub);
+ gph->namestore_task = GNUNET_NAMESTORE_lookup (namestore_handle,
+ &pub,
+ gph->label,
+ &process_pseu_lookup_ns,
+ gph);
+ }
return;
}
-
- /* name is free */
+ /* name is available */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: Name %s not taken in NS! Adding\n",
- gph->test_name);
-
+ "Shortening `%s' to `%s'\n",
+ GNUNET_NAMESTORE_z2s (&gph->target_zone),
+ name);
new_pkey.expiration_time = UINT64_MAX;
- new_pkey.data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode);
- new_pkey.data = &gph->auth->zone;
- new_pkey.record_type = GNUNET_GNS_RECORD_PKEY;
+ new_pkey.data_size = sizeof (struct GNUNET_CRYPTO_EccPublicKey);
+ new_pkey.data = &gph->target_zone;
+ new_pkey.record_type = GNUNET_NAMESTORE_TYPE_PKEY;
new_pkey.flags = GNUNET_NAMESTORE_RF_AUTHORITY
| GNUNET_NAMESTORE_RF_PRIVATE
| GNUNET_NAMESTORE_RF_PENDING;
- gph->namestore_task = GNUNET_NAMESTORE_record_create (namestore_handle,
- gph->key,
- gph->test_name,
- &new_pkey,
- &create_pkey_cont,
- gph);
+ gph->namestore_task
+ = GNUNET_NAMESTORE_records_store (namestore_handle,
+ &gph->shorten_zone_key,
+ name,
+ 1, &new_pkey,
+ &create_pkey_cont, gph);
}
/**
- * process result of a dht pseu lookup
+ * Process result of a DHT lookup for a PSEU record.
*
- * @param gph the handle
- * @param name the pseu result or NULL
+ * @param gph the handle to our shorten operation
+ * @param pseu the pseu result or NULL
*/
static void
process_pseu_result (struct GetPseuAuthorityHandle* gph,
- const char* name)
+ const char *pseu)
{
- if (NULL == name)
+ struct GNUNET_CRYPTO_EccPublicKey pub;
+
+ GNUNET_CRYPTO_ecc_key_get_public (&gph->shorten_zone_key,
+ &pub);
+ if (NULL == pseu)
{
+ /* no PSEU found, try original label */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: No PSEU, no shorten. Finished.\n");
- free_get_pseu_authority_handle (gph);
+ "No PSEU found, trying original label `%s' instead.\n",
+ gph->label);
+ gph->namestore_task = GNUNET_NAMESTORE_lookup (namestore_handle,
+ &pub,
+ gph->label,
+ &process_pseu_lookup_ns,
+ gph);
return;
}
- memcpy (gph->test_name, name, strlen(name) + 1);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: Checking %s for collision in NS\n",
- gph->test_name);
- /**
- * Check for collision
- */
- gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &gph->our_zone,
- gph->test_name,
- GNUNET_NAMESTORE_TYPE_ANY,
- &process_pseu_lookup_ns,
- gph);
+ /* check if 'pseu' is taken */
+ gph->namestore_task = GNUNET_NAMESTORE_lookup (namestore_handle,
+ &pub,
+ pseu,
+ &process_pseu_lookup_ns,
+ gph);
}
/**
- * Handle timeout for dht request
+ * Handle timeout for DHT request during shortening.
*
* @param cls the request handle as closure
* @param tc the task context
handle_auth_discovery_timeout (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct GetPseuAuthorityHandle* gph = cls;
+ struct GetPseuAuthorityHandle *gph = cls;
+ gph->timeout_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_GET_AUTH: dht lookup for query PSEU timed out.\n");
+ "DHT lookup for PSEU query timed out.\n");
GNUNET_DHT_get_stop (gph->get_handle);
gph->get_handle = NULL;
process_pseu_result (gph, NULL);
}
+/**
+ * Handle decrypted records from DHT result.
+ *
+ * @param cls closure with our 'struct GetPseuAuthorityHandle'
+ * @param rd_count number of entries in 'rd' array
+ * @param rd array of records with data to store
+ */
+static void
+process_auth_records (void *cls,
+ unsigned int rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd)
+{
+ struct GetPseuAuthorityHandle *gph = cls;
+ unsigned int i;
+
+ for (i=0; i < rd_count; i++)
+ {
+ if (GNUNET_NAMESTORE_TYPE_PSEU == rd[i].record_type)
+ {
+ /* found pseu */
+ process_pseu_result (gph,
+ (const char *) rd[i].data);
+ return;
+ }
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "No PSEU record found in DHT reply.\n");
+ process_pseu_result (gph, NULL);
+}
+
+
/**
* Function called when we find a PSEU entry in the DHT
*
static void
process_auth_discovery_dht_result (void* cls,
struct GNUNET_TIME_Absolute exp,
- const struct GNUNET_HashCode * key,
+ const struct GNUNET_HashCode *key,
const struct GNUNET_PeerIdentity *get_path,
unsigned int get_path_length,
const struct GNUNET_PeerIdentity *put_path,
size_t size,
const void *data)
{
- struct GetPseuAuthorityHandle* gph = cls;
- struct GNSNameRecordBlock *nrb;
- const char* rd_data = data;
- char* name;
- int num_records;
- size_t rd_size;
- int i;
+ struct GetPseuAuthorityHandle *gph = cls;
+ const struct GNUNET_NAMESTORE_Block *block;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_GET_AUTH: got dht result (size=%d)\n", size);
-
- /* stop lookup and timeout task */
+ "Got DHT result for PSEU request\n");
GNUNET_DHT_get_stop (gph->get_handle);
gph->get_handle = NULL;
- GNUNET_SCHEDULER_cancel (gph->timeout);
-
+ GNUNET_SCHEDULER_cancel (gph->timeout_task);
+ gph->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+
if (NULL == data)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "GNS_GET_AUTH: got dht result null!\n", size);
- free_get_pseu_authority_handle (gph);
+ /* is this allowed!? */
+ GNUNET_break (0);
+ process_pseu_result (gph, NULL);
return;
}
-
- nrb = (struct GNSNameRecordBlock*)data;
- name = (char*)&nrb[1];
- num_records = ntohl (nrb->rd_count);
+ if (size < sizeof (struct GNUNET_NAMESTORE_Block))
{
- struct GNUNET_NAMESTORE_RecordData rd[num_records];
-
- rd_data += strlen (name) + 1 + sizeof (struct GNSNameRecordBlock);
- rd_size = size - strlen (name) - 1 - sizeof (struct GNSNameRecordBlock);
-
- if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
- rd_data,
- num_records,
- rd))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "GNS_GET_AUTH: Error deserializing data!\n");
- }
- else
- {
- for (i=0; i < num_records; i++)
- {
- if ((strcmp (name, "+") == 0) &&
- (rd[i].record_type == GNUNET_GNS_RECORD_PSEU))
- {
- /* found pseu */
- process_pseu_result (gph, (char*)rd[i].data);
- return;
- }
- }
- }
+ /* how did this pass DHT block validation!? */
+ GNUNET_break (0);
+ process_pseu_result (gph, NULL);
+ return;
+ }
+ block = data;
+ if (size !=
+ ntohs (block->purpose.size) +
+ sizeof (struct GNUNET_CRYPTO_EccPublicKey) +
+ sizeof (struct GNUNET_CRYPTO_EccSignature))
+ {
+ /* how did this pass DHT block validation!? */
+ GNUNET_break (0);
+ process_pseu_result (gph, NULL);
+ return;
+ }
+ if (GNUNET_OK !=
+ GNUNET_NAMESTORE_block_decrypt (block,
+ &gph->target_zone,
+ GNUNET_GNS_TLD_PLUS,
+ &process_auth_records,
+ gph))
+ {
+ /* other peer encrypted invalid block, complain */
+ GNUNET_break_op (0);
+ process_pseu_result (gph, NULL);
+ return;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_GET_AUTH: finished shorten, no results!\n");
- process_pseu_result (gph, NULL);
}
/**
- * Process PSEU discovery for shorten via namestore
+ * Callback called by namestore for a zone to name result. We're
+ * trying to see if a short name for a given zone already exists.
*
- * @param cls the GetPseuAuthorityHandle
- * @param key the public key
- * @param expiration recorddata expiration
- * @param name the looked up name
- * @param rd_count number of records in set
- * @param rd record data
- * @param signature the signature
+ * @param cls the closure
+ * @param zone_key the zone we queried
+ * @param name the name found or NULL
+ * @param rd_len number of records for the name
+ * @param rd the record data (PKEY) for the name
*/
static void
-process_auth_discovery_ns_result (void* cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
- struct GNUNET_TIME_Absolute expiration,
- const char *name,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+process_zone_to_name_discover (void *cls,
+ const struct GNUNET_CRYPTO_EccPrivateKey *zone_key,
+ const char *name,
+ unsigned int rd_len,
+ const struct GNUNET_NAMESTORE_RecordData *rd)
{
struct GetPseuAuthorityHandle* gph = cls;
struct GNUNET_HashCode lookup_key;
- unsigned int i;
- uint32_t xquery;
gph->namestore_task = NULL;
- /* no pseu found */
- if (0 == rd_count)
+ if (0 != rd_len)
{
- GNUNET_GNS_get_key_for_record (GNUNET_GNS_TLD_PLUS, &gph->auth->zone, &lookup_key);
+ /* we found a match in our own zone */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: starting dht lookup for %s with key: %s\n",
- GNUNET_GNS_TLD_PLUS,
- GNUNET_h2s (&lookup_key));
-
- gph->timeout = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
- &handle_auth_discovery_timeout, gph);
-
- xquery = htonl (GNUNET_GNS_RECORD_PSEU);
-
- GNUNET_assert (gph->get_handle == NULL);
-
- gph->get_handle = GNUNET_DHT_get_start (dht_handle,
- GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
- &lookup_key,
- DHT_GNS_REPLICATION_LEVEL,
- GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
- &xquery,
- sizeof(xquery),
- &process_auth_discovery_dht_result,
- gph);
- return;
- }
-
- for (i=0; i < rd_count; i++)
- {
- if (0 != (strcmp (name, GNUNET_GNS_TLD_PLUS)))
- continue;
-
- if (rd[i].record_type != GNUNET_GNS_RECORD_PSEU)
- continue;
-
- /* found pseu */
- process_pseu_result (gph, (char*)rd[i].data);
- return;
- }
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: no pseu in namestore!\n");
- process_pseu_result (gph, NULL);
-}
-
-
-/**
- * Callback called by namestore for a zone to name
- * result
- *
- * @param cls the closure
- * @param zone_key the zone we queried
- * @param expire the expiration time of the name
- * @param name the name found or NULL
- * @param rd_len number of records for the name
- * @param rd the record data (PKEY) for the name
- * @param signature the signature for the record data
- */
-static void
-process_zone_to_name_discover (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- struct GNUNET_TIME_Absolute expire,
- const char *name,
- unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
-{
- struct GetPseuAuthorityHandle* gph = cls;
-
- gph->namestore_task = NULL;
- if (0 == rd_len)
- {
- gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &gph->auth->zone,
- "+",
- GNUNET_GNS_RECORD_PSEU,
- &process_auth_discovery_ns_result,
- gph);
+ "Shortening aborted, name `%s' already reserved for the zone\n",
+ name);
+ free_get_pseu_authority_handle (gph);
return;
}
- /* we found a match in our own zone */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: name for zone in our root %s\n", name);
- free_get_pseu_authority_handle (gph);
-}
-
-
-/**
- * Callback that shortens authorities
- *
- * @param gph the handle to the shorten request
- */
-static void
-shorten_authority_chain (struct GetPseuAuthorityHandle *gph)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: New authority %s discovered\n",
- gph->auth->name);
-
- gph->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- &gph->our_zone,
- &gph->auth->zone,
- &process_zone_to_name_discover,
- gph);
+ /* record does not yet exist, go into DHT to find PSEU record */
+ GNUNET_NAMESTORE_query_from_public_key (&gph->target_zone,
+ GNUNET_GNS_TLD_PLUS,
+ &lookup_key);
+ gph->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
+ &handle_auth_discovery_timeout,
+ gph);
+ gph->get_handle = GNUNET_DHT_get_start (dht_handle,
+ GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
+ &lookup_key,
+ DHT_GNS_REPLICATION_LEVEL,
+ GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+ NULL, 0,
+ &process_auth_discovery_dht_result,
+ gph);
}
/**
- * Start shortening algorithm using auth as
- * authority chain
+ * Start shortening algorithm, try to allocate a nice short
+ * canonical name for @a pub in @a shorten_zone, using
+ * @a original_label as one possible suggestion.
*
- * @param auth the authorities that were resolved
- * @param key the private key for PKEY import
+ * @param original_label original label for the zone
+ * @param pub public key of the zone to shorten
+ * @param shorten_zone private key of the target zone for the new record
*/
static void
-start_shorten (struct AuthorityChain *auth,
- const struct GNUNET_CRYPTO_RsaPrivateKey *key)
+start_shorten (const char *original_label,
+ const struct GNUNET_CRYPTO_EccPublicKey *pub,
+ const struct GNUNET_CRYPTO_EccPrivateKey *shorten_zone)
{
struct GetPseuAuthorityHandle *gph;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
- struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pb_key;
- GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
- if (NULL == (pb_key = GNUNET_CRYPTO_rsa_encode_key (key)))
+ if (strlen (original_label) > GNUNET_DNSPARSER_MAX_LABEL_LENGTH)
{
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Failed to encode RSA key on shorten\n");
+ GNUNET_break (0);
return;
}
- gph = GNUNET_malloc (sizeof (struct GetPseuAuthorityHandle));
- gph->key = GNUNET_CRYPTO_rsa_decode_key ((const char*) pb_key, ntohs (pb_key->len));
- GNUNET_free (pb_key);
- if (NULL == gph->key)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Failed to decode RSA key on shorten\n");
- GNUNET_free (gph);
- return;
- }
- GNUNET_CRYPTO_short_hash (&pkey,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
- &gph->our_zone);
- gph->auth = GNUNET_malloc (sizeof (struct AuthorityChain));
- memcpy (gph->auth, auth, sizeof (struct AuthorityChain));
+ gph = GNUNET_new (struct GetPseuAuthorityHandle);
+ gph->shorten_zone_key = *shorten_zone;
+ gph->target_zone = *pub;
+ strcpy (gph->label, original_label);
GNUNET_CONTAINER_DLL_insert (gph_head, gph_tail, gph);
- shorten_authority_chain (gph);
-}
-
-
-/**
- * Initialize the resolver
- *
- * @param nh the namestore handle
- * @param dh the dht handle
- * @param lz the local zone's hash
- * @param c configuration handle
- * @param max_bg_queries maximum number of parallel background queries in dht
- * @param ignore_pending ignore records that still require user confirmation
- * on lookup
- * @return GNUNET_OK on success
- */
-int
-gns_resolver_init (struct GNUNET_NAMESTORE_Handle *nh,
- struct GNUNET_DHT_Handle *dh,
- struct GNUNET_CRYPTO_ShortHashCode lz,
- const struct GNUNET_CONFIGURATION_Handle *c,
- unsigned long long max_bg_queries,
- int ignore_pending)
-{
- if ( (NULL == nh) ||
- (NULL == dh) )
- return GNUNET_SYSERR;
-
- cfg = c;
- namestore_handle = nh;
- dht_handle = dh;
- local_zone = lz;
- dht_lookup_heap =
- GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
- ns_task_heap =
- GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
- max_allowed_background_queries = max_bg_queries;
- max_allowed_ns_tasks = GNUNET_GNS_MAX_NS_TASKS;
- ignore_pending_records = ignore_pending;
- GNUNET_RESOLVER_connect (cfg);
- return GNUNET_OK;
+ /* first, check if we *already* have a record for this zone */
+ gph->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
+ shorten_zone,
+ pub,
+ &process_zone_to_name_discover,
+ gph);
}
-/**
- * finish lookup
- *
- * @param rh resolver handle
- * @param rlh record lookup handle
- * @param rd_count number of results
- * @param rd results
- */
-static void
-finish_lookup (struct ResolverHandle *rh,
- struct RecordLookupHandle* rlh,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd);
+/* ************************** Resolution **************************** */
+#if 0
/**
* Helper function to free resolver handle
*
}
-/**
- * finish shorten
- *
- * @param rh resolver handle
- * @param nsh name shorten handle
- */
-static void
-finish_shorten (struct ResolverHandle *rh,
- struct NameShortenHandle *nsh);
-
-
-/**
- * finish get auth
- *
- * @param rh resolver handle
- * @param nah get name authority handle
- */
-static void
-finish_get_auth (struct ResolverHandle *rh,
- struct GetNameAuthorityHandle* rlh);
-
-
-/**
- * Shutdown resolver
- */
-void
-gns_resolver_cleanup ()
-{
- struct GetPseuAuthorityHandle *tmp;
- struct ResolverHandle *rh;
- struct NamestoreBGTask *nbg;
-
- while (NULL != (tmp = gph_head))
- {
- if (tmp->get_handle != NULL)
- {
- GNUNET_DHT_get_stop (tmp->get_handle);
- tmp->get_handle = NULL;
- }
- if (tmp->timeout != GNUNET_SCHEDULER_NO_TASK)
- {
- GNUNET_SCHEDULER_cancel (tmp->timeout);
- tmp->timeout = GNUNET_SCHEDULER_NO_TASK;
- }
- if (NULL != tmp->namestore_task)
- {
- GNUNET_NAMESTORE_cancel (tmp->namestore_task);
- tmp->namestore_task = NULL;
- }
- free_get_pseu_authority_handle (tmp);
- }
-
- while (NULL != rlh_head)
- {
- finish_lookup (rlh_head, rlh_head->proc_cls, 0, NULL);
- }
- while (NULL != nsh_head)
- {
- finish_shorten (nsh_head, nsh_head->proc_cls);
- }
- while (NULL != nah_head)
- {
- finish_get_auth (nah_head, nah_head->proc_cls);
- }
-
- while (NULL != (rh = GNUNET_CONTAINER_heap_remove_root(dht_lookup_heap)))
- {
- GNUNET_free (rh);
- }
- GNUNET_CONTAINER_heap_destroy (dht_lookup_heap);
- dht_lookup_heap = NULL;
-
- while (NULL != (nbg = GNUNET_CONTAINER_heap_remove_root(ns_task_heap)))
- {
- GNUNET_NAMESTORE_cancel (nbg->qe);
- GNUNET_free (nbg);
- }
- GNUNET_CONTAINER_heap_destroy (ns_task_heap);
- ns_task_heap = NULL;
-
-}
-
-
/**
* Callback when record data is put into namestore
*
}
-/**
- * Lookup timeout task
- *
- * @param cls the ResolverHandle for the task that timed out
- * @param tc the task context
- */
-static void
-handle_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct ResolverHandle *rh = cls;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Lookup timeout for request %llu triggered\n",
- rh->id);
- if (NULL != rh->timeout_cont)
- rh->timeout_cont (rh->timeout_cont_cls, tc);
-}
-
-
-/**
- * Processor for background lookups in the DHT
- *
- * @param cls closure (NULL)
- * @param rd_count number of records found (not 0)
- * @param rd record data
- */
-static void
-background_lookup_result_processor (void *cls,
- uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
-{
- //We could do sth verbose/more useful here but it doesn't make any difference
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_BG: background dht lookup finished. (%d results)\n",
- rd_count);
-}
-
-
-/**
- * Handle timeout for DHT requests
- *
- * @param cls the request handle as closure
- * @param tc the task context
- */
-static void
-dht_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct ResolverHandle *rh = cls;
- struct RecordLookupHandle *rlh = rh->proc_cls;
- char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: dht lookup for query %s (%llus) timed out.\n",
- rh->id, rh->name, rh->timeout.rel_value);
- /**
- * Start resolution in bg
- */
- GNUNET_snprintf (new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
- rh->name, GNUNET_GNS_TLD);
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Starting background lookup for %s type %d\n",
- rh->id, new_name, rlh->record_type);
-
- gns_resolver_lookup_record (rh->authority,
- rh->private_local_zone,
- rlh->record_type,
- new_name,
- NULL,
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_NO,
- &background_lookup_result_processor,
- NULL);
-
- rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-
- GNUNET_DHT_get_stop (rh->get_handle);
- rh->get_handle = NULL;
- rh->proc (rh->proc_cls, rh, 0, NULL);
-}
-
-
/**
* Function called when we get a result from the dht
* for our record query
namestore_bg_task->node = GNUNET_CONTAINER_heap_insert (ns_task_heap,
namestore_bg_task,
- GNUNET_TIME_absolute_get().abs_value);
+ GNUNET_TIME_absolute_get().abs_value_us);
if (0 < rh->answered)
rh->proc (rh->proc_cls, rh, num_records, rd);
else
rh->dht_heap_node = NULL;
- if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value != rh->timeout.rel_value)
+ if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != rh->timeout.rel_value_us)
{
/**
* Update timeout if necessary
}
rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
rh,
- GNUNET_TIME_absolute_get ().abs_value);
+ GNUNET_TIME_absolute_get ().abs_value_us);
}
xquery = htonl (rlh->record_type);
*/
static void
process_record_result_ns (void* cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKey *key,
struct GNUNET_TIME_Absolute expiration,
const char *name, unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ResolverHandle *rh = cls;
struct RecordLookupHandle *rlh = rh->proc_cls;
rh->namestore_task = NULL;
GNUNET_CRYPTO_short_hash (key,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof (struct GNUNET_CRYPTO_EccPublicKey),
&zone);
remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
rh->status = 0;
if (NULL != name)
{
rh->status |= RSL_RECORD_EXISTS;
- if (remaining_time.rel_value == 0)
+ if (remaining_time.rel_value_us == 0)
rh->status |= RSL_RECORD_EXPIRED;
}
if (0 == rd_count)
//FIXME: eh? do I have to handle this here?
GNUNET_break (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
- et.abs_value = rd[i].expiration_time;
- if (0 == (GNUNET_TIME_absolute_get_remaining (et)).rel_value)
+ et.abs_value_us = rd[i].expiration_time;
+ if (0 == (GNUNET_TIME_absolute_get_remaining (et)).rel_value_us)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: This record is expired. Skipping\n",
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Answer is IPv4!\n",
rh->id);
- if (GNUNET_GNS_RECORD_A != rlh->record_type)
+ if (GNUNET_DNSPARSER_TYPE_A != rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Requested record is not IPv4!\n",
rh->proc (rh->proc_cls, rh, 0, NULL);
return;
}
- rd.record_type = GNUNET_GNS_RECORD_A;
+ rd.record_type = GNUNET_DNSPARSER_TYPE_A;
rd.expiration_time = UINT64_MAX; /* FIXME: should probably pick something shorter... */
rd.data = address;
rd.data_size = sizeof (struct in_addr);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Answer is IPv6!\n",
rh->id);
- if (GNUNET_GNS_RECORD_AAAA != rlh->record_type)
+ if (GNUNET_DNSPARSER_TYPE_AAAA != rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Requested record is not IPv6!\n",
rh->proc (rh->proc_cls, rh, 0, NULL);
return;
}
- rd.record_type = GNUNET_GNS_RECORD_AAAA;
+ rd.record_type = GNUNET_DNSPARSER_TYPE_AAAA;
rd.expiration_time = UINT64_MAX; /* FIXME: should probably pick something shorter... */
rd.data = address;
rd.data_size = sizeof (struct in6_addr);
/* results found yay */
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_VPN-%llu: Record resolved from VPN!", rh->id);
+ "GNS_PHASE_REC_VPN-%llu: Record resolved from VPN!\n",
+ rh->id);
finish_lookup(rh, rlh, rd_count, rd);
}
/**
- * Sends a UDP dns query to a nameserver specified in the rh
- *
- * @param rh the resolver handle
- */
-static void
-send_dns_packet (struct ResolverHandle *rh);
-
-
-/**
- * Read DNS response
+ * The final phase of resoution.
+ * We found a NS RR and want to resolve via DNS
*
- * @param cls the ResolverHandle for this lookup
- * @param addr the sockaddr
- * @param addrlen the socket address length
+ * @param rh the pending lookup handle
+ * @param rd_count length of record data
+ * @param rd record data containing VPN RR
*/
static void
-handle_dns_resolver (void *cls,
- const struct sockaddr *addr,
- socklen_t addrlen)
+resolve_record_dns (struct ResolverHandle *rh,
+ unsigned int rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct ResolverHandle *rh = cls;
struct RecordLookupHandle *rlh = rh->proc_cls;
- struct GNUNET_NAMESTORE_RecordData rd;
- struct sockaddr_in *sai;
- struct sockaddr_in6 *sai6;
+ struct GNUNET_DNSPARSER_Query query;
+ struct GNUNET_DNSPARSER_Packet packet;
+ struct GNUNET_DNSPARSER_Flags flags;
+ struct in_addr dnsip;
+ struct sockaddr_in addr;
+ struct sockaddr *sa;
+ unsigned int i;
- if (NULL == addr)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "No address found in DNS!\n");
- finish_lookup (rh, rlh, 0, NULL);
- return;
- }
+ memset (&packet, 0, sizeof (struct GNUNET_DNSPARSER_Packet));
+ memset (rh->dns_name, 0, sizeof (rh->dns_name));
- if (sizeof (struct sockaddr_in) == addrlen)
+ /* We cancel here as to not include the ns lookup in the timeout */
+ if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
{
- sai = (struct sockaddr_in*) addr;
- rd.record_type = GNUNET_GNS_RECORD_A;
- rd.data_size = sizeof (struct in_addr);
- rd.data = &sai->sin_addr;
+ GNUNET_SCHEDULER_cancel(rh->timeout_task);
+ rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
- else if (sizeof (struct sockaddr_in6) == addrlen)
+ /* Start shortening */
+ if ((NULL != rh->priv_key) &&
+ (GNUNET_YES == is_canonical (rh->name)))
{
- sai6 = (struct sockaddr_in6*) addr;
- rd.record_type = GNUNET_GNS_RECORD_AAAA;
- rd.data_size = sizeof (struct in6_addr);
- rd.data = &sai6->sin6_addr;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC_DNS-%llu: Trying to shorten authority chain\n",
+ rh->id);
+ start_shorten (rh->authority_chain_head,
+ rh->priv_key);
}
- else
+
+ for (i = 0; i < rd_count; i++)
{
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Address length is garbage!\n");
- finish_lookup (rh, rlh, 0, NULL);
- return;
- }
- rd.expiration_time = UINT64_MAX; /* FIXME: should probably pick something shorter */
- rd.flags = 0;
- finish_lookup (rh, rlh, 1, &rd);
-}
-
-
-/**
- * Resolve DNS name via local stub resolver
- *
- * @param rh the resolver handle
- */
-static void
-resolve_dns_name (struct ResolverHandle *rh)
-{
- struct RecordLookupHandle *rlh = rh->proc_cls;
- int af;
-
- if ((GNUNET_GNS_RECORD_A != rlh->record_type) &&
- (GNUNET_GNS_RECORD_AAAA != rlh->record_type))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Can only resolve A/AAAA via stub... abort\n");
- finish_lookup (rh, rlh, 0, NULL);
- return;
- }
-
- if (GNUNET_GNS_RECORD_A == rlh->record_type)
- af = AF_INET;
- else
- af = AF_INET6;
-
- rh->dns_resolver_handle = GNUNET_RESOLVER_ip_get (rh->dns_name,
- af,
- rh->timeout,
- &handle_dns_resolver,
- rh);
-}
-
-
-/**
- * Read DNS udp packet from socket
- *
- * @param cls the resolver handle
- * @param tc task context
- */
-static void
-read_dns_response (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
- struct ResolverHandle *rh = cls;
- struct RecordLookupHandle *rlh = rh->proc_cls;
- char buf[UINT16_MAX];
- ssize_t r;
- struct sockaddr_in addr;
- socklen_t addrlen;
- struct GNUNET_DNSPARSER_Packet *packet;
- struct GNUNET_NAMESTORE_RecordData rd;
- int found_delegation = GNUNET_NO;
- int found_cname = GNUNET_NO;
- char* delegation_name = NULL;
- int zone_offset = 0;
- int i;
-
- rh->dns_read_task = GNUNET_SCHEDULER_NO_TASK;
- if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
- {
- /* timeout or shutdown */
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Terminating DNS query %d\n", tc->reason);
- finish_lookup (rh, rlh, 0, NULL);
- return;
- }
-
- addrlen = sizeof (addr);
- r = GNUNET_NETWORK_socket_recvfrom (rh->dns_sock,
- buf, sizeof (buf),
- (struct sockaddr*) &addr,
- &addrlen);
-
- if (-1 == r)
- {
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom");
- finish_lookup (rh, rlh, 0, NULL);
- return;
- }
- if (NULL == (packet = GNUNET_DNSPARSER_parse (buf, r)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Failed to parse DNS reply!\n");
- finish_lookup (rh, rlh, 0, NULL);
- return;
- }
-
- for (i = 0; i < packet->num_answers; i++)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Got record type %d (want %d)\n",
- packet->answers[i].type,
- rlh->record_type);
- /* http://tools.ietf.org/html/rfc1034#section-3.6.2 */
- if (packet->answers[i].type == GNUNET_GNS_RECORD_CNAME)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "CNAME... restarting query with %s\n",
- packet->answers[i].data.hostname
- );
- strcpy (rh->dns_name, packet->answers[i].data.hostname);
- found_cname = GNUNET_YES;
- continue;
- }
-
- if ((packet->answers[i].type == rlh->record_type) &&
- (0 == strcmp (packet->answers[i].name, rh->dns_name)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Found record!\n");
- rd.data = packet->answers[i].data.raw.data;
- rd.data_size = packet->answers[i].data.raw.data_len;
- rd.record_type = packet->answers[i].type;
- rd.flags = 0;
- rd.expiration_time = packet->answers[i].expiration_time.abs_value;
- finish_lookup (rh, rlh, 1, &rd);
- GNUNET_DNSPARSER_free_packet (packet);
- return;
- }
- }
-
- if (GNUNET_YES == found_cname)
- {
- zone_offset = strlen (rh->dns_name) - strlen (rh->dns_zone) - 1;
-
- if (0 > zone_offset)
- zone_offset = 0;
-
- /* restart query with CNAME */
- if (0 == strcmp (rh->dns_name+zone_offset, rh->dns_zone))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Asking same server for %s\n", rh->dns_name);
- send_dns_packet (rh);
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Trying system resolver for %s\n", rh->dns_name);
- resolve_dns_name (rh);
- }
-
- GNUNET_DNSPARSER_free_packet (packet);
- return;
- }
-
- for (i = 0; i < packet->num_authority_records; i++)
- {
- if (packet->authority_records[i].type == GNUNET_GNS_RECORD_NS)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Found NS delegation!\n");
- found_delegation = GNUNET_YES;
- delegation_name = packet->authority_records[i].data.hostname;
- break;
- }
- }
-
- for (i = 0; i < packet->num_additional_records; i++)
- {
- if (GNUNET_NO == found_delegation)
- break;
-
- if ((packet->additional_records[i].type == GNUNET_GNS_RECORD_A) &&
- (0 == strcmp (packet->additional_records[i].name, delegation_name)))
- {
- GNUNET_assert (sizeof (struct in_addr) ==
- packet->authority_records[i].data.raw.data_len);
-
- rh->dns_addr.sin_addr =
- *((struct in_addr*)packet->authority_records[i].data.raw.data);
- send_dns_packet (rh);
- GNUNET_DNSPARSER_free_packet (packet);
- return;
- }
- }
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Nothing useful in DNS reply!\n");
- finish_lookup (rh, rlh, 0, NULL);
- GNUNET_DNSPARSER_free_packet (packet);
-}
-
-
-/**
- * Sends a UDP dns query to a nameserver specified in the rh
- *
- * @param rh the request handle
- */
-static void
-send_dns_packet (struct ResolverHandle *rh)
-{
- struct GNUNET_NETWORK_FDSet *rset;
-
- rset = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_set (rset, rh->dns_sock);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending %d byte DNS query\n",
- (int) rh->dns_raw_packet_size);
-
- if (GNUNET_SYSERR ==
- GNUNET_NETWORK_socket_sendto (rh->dns_sock,
- rh->dns_raw_packet,
- rh->dns_raw_packet_size,
- (struct sockaddr*)&rh->dns_addr,
- sizeof (struct sockaddr_in)))
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- _("Failed to send DNS request to %s\n"),
- GNUNET_a2s ((const struct sockaddr *)&rh->dns_addr,
- sizeof (struct sockaddr_in)));
-
- rh->dns_read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
- rh->timeout, //FIXME less?
- rset,
- NULL,
- &read_dns_response,
- rh);
- GNUNET_NETWORK_fdset_destroy (rset);
-}
-
-
-/**
- * The final phase of resoution.
- * We found a NS RR and want to resolve via DNS
- *
- * @param rh the pending lookup handle
- * @param rd_count length of record data
- * @param rd record data containing VPN RR
- */
-static void
-resolve_record_dns (struct ResolverHandle *rh,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
-{
- struct RecordLookupHandle *rlh = rh->proc_cls;
- struct GNUNET_DNSPARSER_Query query;
- struct GNUNET_DNSPARSER_Packet packet;
- struct GNUNET_DNSPARSER_Flags flags;
- struct in_addr dnsip;
- struct sockaddr_in addr;
- struct sockaddr *sa;
- unsigned int i;
-
- memset (&packet, 0, sizeof (struct GNUNET_DNSPARSER_Packet));
- memset (rh->dns_name, 0, sizeof (rh->dns_name));
-
- /* We cancel here as to not include the ns lookup in the timeout */
- if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
- {
- GNUNET_SCHEDULER_cancel(rh->timeout_task);
- rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
- }
- /* Start shortening */
- if ((NULL != rh->priv_key) &&
- (GNUNET_YES == is_canonical (rh->name)))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_DNS-%llu: Trying to shorten authority chain\n",
- rh->id);
- start_shorten (rh->authority_chain_head,
- rh->priv_key);
- }
-
- for (i = 0; i < rd_count; i++)
- {
- /* Synthesize dns name */
- if (GNUNET_GNS_RECORD_NS == rd[i].record_type)
- {
- strcpy (rh->dns_zone, (char*)rd[i].data);
- if (0 == strcmp (rh->name, ""))
- strcpy (rh->dns_name, (char*)rd[i].data);
- else
- sprintf (rh->dns_name, "%s.%s", rh->name, (char*)rd[i].data);
- }
- /* The glue */
- if (GNUNET_GNS_RECORD_A == rd[i].record_type)
- /* need to use memcpy as .data may be unaligned */
- memcpy (&dnsip, rd[i].data, sizeof (dnsip));
+ /* Synthesize dns name */
+ if (GNUNET_DNSPARSER_TYPE_NS == rd[i].record_type)
+ {
+ strcpy (rh->dns_zone, (char*)rd[i].data);
+ if (0 == strcmp (rh->name, ""))
+ strcpy (rh->dns_name, (char*)rd[i].data);
+ else
+ sprintf (rh->dns_name, "%s.%s", rh->name, (char*)rd[i].data);
+ }
+ /* The glue */
+ if (GNUNET_DNSPARSER_TYPE_A == rd[i].record_type)
+ /* need to use memcpy as .data may be unaligned */
+ memcpy (&dnsip, rd[i].data, sizeof (dnsip));
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_DNS-%llu: Looking up %s from %s\n",
+ "GNS_PHASE_REC_DNS-%llu: Looking up `%s' from `%s'\n",
rh->id,
rh->dns_name,
inet_ntoa (dnsip));
sa->sa_family = AF_INET;
if (GNUNET_OK != GNUNET_NETWORK_socket_bind (rh->dns_sock,
sa,
- sizeof (struct sockaddr_in)))
+ sizeof (struct sockaddr_in),
+ 0))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_DNS-%llu: Error binding udp socket for dns!\n",
+ "GNS_PHASE_REC_DNS-%llu: Error binding UDP socket for DNS lookup!\n",
rh->id);
finish_lookup (rh, rlh, 0, NULL);
return;
(char*)&vpn[1],
GNUNET_h2s (&serv_desc));
rh->proc = &handle_record_vpn;
- if (GNUNET_GNS_RECORD_A == rlh->record_type)
+ if (GNUNET_DNSPARSER_TYPE_A == rlh->record_type)
af = AF_INET;
else
af = AF_INET6;
char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_DHT-%llu: dht lookup for query %s (%llus) timed out.\n",
+ "GNS_PHASE_DELEGATE_DHT-%llu: dht lookup for query %s (%s) timed out.\n",
rh->id, rh->authority_name,
- rh->timeout.rel_value);
+ GNUNET_STRINGS_relative_time_to_string (rh->timeout,
+ GNUNET_YES));
rh->status |= RSL_TIMED_OUT;
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
-/**
- * Start DHT lookup for a name -> PKEY (compare NS) record in
- * rh->authority's zone
- *
- * @param rh the pending gns query
- */
-static void
-resolve_delegation_dht (struct ResolverHandle *rh);
-
-
-/**
- * Resolve the delegation chain for the request in our namestore
- *
- * @param rh the resolver handle
- */
-static void
-resolve_delegation_ns (struct ResolverHandle *rh);
-
-
-/**
- * Namestore resolution for delegation finished. Processing result.
- *
- * @param cls the closure
- * @param rh resolver handle
- * @param rd_count number of results (always 0)
- * @param rd record data (always NULL)
- */
-static void
-handle_delegation_ns (void* cls, struct ResolverHandle *rh,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd);
-
-
/**
* This is a callback function that checks for key revocation
*
*/
static void
process_pkey_revocation_result_ns (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKey *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ResolverHandle *rh = cls;
struct GNUNET_TIME_Relative remaining_time;
for (i = 0; i < rd_count; i++)
{
- if (GNUNET_GNS_RECORD_REV == rd[i].record_type)
+ if (GNUNET_NAMESTORE_TYPE_REV == rd[i].record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_REV-%llu: Zone has been revoked.\n",
}
if ((NULL == name) ||
- (0 == remaining_time.rel_value))
+ (0 == remaining_time.rel_value_us))
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_REV-%llu: + Records don't exist or are expired.\n",
rh->id, name);
- if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value != rh->timeout.rel_value)
+ if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us != rh->timeout.rel_value_us)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_REV-%llu: Starting background lookup for %s type %d\n",
- rh->id, "+.gads", GNUNET_GNS_RECORD_REV);
+ rh->id, "+.gads", GNUNET_NAMESTORE_TYPE_REV);
gns_resolver_lookup_record(rh->authority,
rh->private_local_zone,
- GNUNET_GNS_RECORD_REV,
+ GNUNET_NAMESTORE_TYPE_REV,
GNUNET_GNS_TLD,
NULL,
GNUNET_TIME_UNIT_FOREVER_REL,
* @param success GNUNET_OK on success
* @param emsg the error message. NULL if SUCCESS==GNUNET_OK
*/
-void
+static void
on_namestore_delegation_put_result(void *cls,
int32_t success,
const char *emsg)
rh->id, name, rh->authority_name);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Got type: %d (wanted %d)\n",
- rh->id, rd[i].record_type, GNUNET_GNS_RECORD_PKEY);
+ rh->id, rd[i].record_type, GNUNET_NAMESTORE_TYPE_PKEY);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Got data length: %d\n",
rh->id, rd[i].data_size);
"GNS_PHASE_DELEGATE_DHT-%llu: Got flag %d\n",
rh->id, rd[i].flags);
- if ((GNUNET_GNS_RECORD_VPN == rd[i].record_type) ||
- (GNUNET_GNS_RECORD_NS == rd[i].record_type) ||
- (GNUNET_GNS_RECORD_CNAME == rd[i].record_type))
+ if ((GNUNET_NAMESTORE_TYPE_VPN == rd[i].record_type) ||
+ (GNUNET_DNSPARSER_TYPE_NS == rd[i].record_type) ||
+ (GNUNET_DNSPARSER_TYPE_CNAME == rd[i].record_type))
{
/**
* This is a VPN,NS,CNAME entry. Let namestore handle this after caching
}
if ((0 == strcmp(name, rh->authority_name)) &&
- (GNUNET_GNS_RECORD_PKEY == rd[i].record_type))
+ (GNUNET_NAMESTORE_TYPE_PKEY == rd[i].record_type))
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Authority found in DHT\n",
namestore_bg_task->node = GNUNET_CONTAINER_heap_insert (ns_task_heap,
namestore_bg_task,
- GNUNET_TIME_absolute_get().abs_value);
+ GNUNET_TIME_absolute_get().abs_value_us);
namestore_bg_task->qe = GNUNET_NAMESTORE_record_put (namestore_handle,
&nrb->public_key,
name,
/* Check for key revocation and delegate */
- rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &rh->authority,
- "+",
- GNUNET_GNS_RECORD_REV,
- &process_pkey_revocation_result_ns,
- rh);
+ rh->namestore_task = GNUNET_NAMESTORE_lookup (namestore_handle,
+ &rh->authority,
+ GNUNET_GNS_MASTERZONE_STR,
+ GNUNET_NAMESTORE_TYPE_REV,
+ &process_pkey_revocation_result_ns,
+ rh);
return;
}
for (i = 0; i < rd_count; i++)
{
- if ((GNUNET_GNS_RECORD_NS != rd[i].record_type) &&
- (GNUNET_GNS_RECORD_PTR != rd[i].record_type) &&
- (GNUNET_GNS_RECORD_CNAME != rd[i].record_type) &&
- (GNUNET_GNS_RECORD_MX != rd[i].record_type) &&
- (GNUNET_GNS_RECORD_SOA != rd[i].record_type) &&
- (GNUNET_GNS_RECORD_SRV != rd[i].record_type))
+ if ((GNUNET_DNSPARSER_TYPE_NS != rd[i].record_type) &&
+ (GNUNET_DNSPARSER_TYPE_PTR != rd[i].record_type) &&
+ (GNUNET_DNSPARSER_TYPE_CNAME != rd[i].record_type) &&
+ (GNUNET_DNSPARSER_TYPE_MX != rd[i].record_type) &&
+ (GNUNET_DNSPARSER_TYPE_SOA != rd[i].record_type) &&
+ (GNUNET_DNSPARSER_TYPE_SRV != rd[i].record_type))
{
p_rd[i].data = rd[i].data;
continue;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_POSTPROCESS: Postprocessing\n");
- if (0 == strcmp(rh->name, "+"))
+ if (0 == strcmp(rh->name, GNUNET_GNS_MASTERZONE_STR))
repl_string = rlh->name;
else
repl_string = rlh->name+strlen(rh->name)+1;
offset = 0;
- if (GNUNET_GNS_RECORD_MX == rd[i].record_type)
+ if (GNUNET_DNSPARSER_TYPE_MX == rd[i].record_type)
{
memcpy (new_mx_data, (char*)rd[i].data, sizeof(uint16_t));
offset = sizeof (uint16_t);
p_rd[i].data = new_mx_data;
p_rd[i].data_size = offset;
}
- else if (GNUNET_GNS_RECORD_SRV == rd[i].record_type)
+ else if (GNUNET_DNSPARSER_TYPE_SRV == rd[i].record_type)
{
/*
* Prio, weight and port
p_rd[i].data = new_srv_data;
p_rd[i].data_size = sizeof (struct srv_data) + strlen ((char*)&new_srv[1]) + 1;
}
- else if (GNUNET_GNS_RECORD_SOA == rd[i].record_type)
+ else if (GNUNET_DNSPARSER_TYPE_SOA == rd[i].record_type)
{
/* expand mname and rname */
old_soa = (struct soa_data*)rd[i].data;
check_dht = GNUNET_NO;
}
- if ((0 != strcmp (rh->name, "+")) && (GNUNET_YES == is_srv (rh->name)))
+ if ((0 != strcmp (rh->name, GNUNET_GNS_MASTERZONE_STR)) && (GNUNET_YES == is_srv (rh->name)))
check_dht = GNUNET_NO;
if (GNUNET_YES == rh->only_cached)
//Was canonical?
if (0 == len)
return;
-
name[len] = '\0';
-
- strcpy(dest, (name+len+1));
+ strcpy (dest, (name+len+1));
}
if (0 == strcmp(rh->name, ""))
{
- if (GNUNET_GNS_RECORD_PKEY == rlh->record_type)
+ if (GNUNET_NAMESTORE_TYPE_PKEY == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Resolved queried PKEY via DHT.\n",
&rh->authority,
&lookup_key);
rh->dht_heap_node = NULL;
- if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+ if (rh->timeout.rel_value_us != GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
{
rh->timeout_cont = &dht_authority_lookup_timeout;
rh->timeout_cont_cls = rh;
}
rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
rh,
- GNUNET_TIME_absolute_get().abs_value);
+ GNUNET_TIME_absolute_get().abs_value_us);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Beginning DHT lookup for %s in zone %s for request %llu\n",
rh->authority_name,
GNUNET_short_h2s (&rh->authority),
rh->id);
- xquery = htonl (GNUNET_GNS_RECORD_PKEY);
+ xquery = htonl (GNUNET_NAMESTORE_TYPE_PKEY);
GNUNET_assert (rh->get_handle == NULL);
rh->get_handle = GNUNET_DHT_get_start (dht_handle,
GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
}
-/**
- * Checks if name is in tld
- *
- * @param name the name to check
- * @param tld the TLD to check for
- * @return GNUNET_YES or GNUNET_NO
- */
-int
-is_tld (const char* name, const char* tld)
-{
- size_t offset = 0;
-
- if (strlen (name) <= strlen (tld))
- return GNUNET_NO;
-
- offset = strlen (name) - strlen (tld);
- if (0 != strcmp (name + offset, tld))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "%s is not in .%s TLD\n", name, tld);
- return GNUNET_NO;
- }
- return GNUNET_YES;
-}
-
-
/**
* Namestore resolution for delegation finished. Processing result.
*
int check_dht;
size_t s_len;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Resolution status: %d.\n",
- rh->id, rh->status);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Resolution status: %d.\n",
+ rh->id, rh->status);
if (rh->status & RSL_PKEY_REVOKED)
{
rh->id);
if (rh->status & RSL_CNAME_FOUND)
{
- if (GNUNET_GNS_RECORD_CNAME == rlh->record_type)
+ if (GNUNET_DNSPARSER_TYPE_CNAME == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried CNAME in NS.\n",
}
else if (rh->status & RSL_DELEGATE_VPN)
{
- if (GNUNET_GNS_RECORD_VPN == rlh->record_type)
+ if (GNUNET_NAMESTORE_TYPE_VPN == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried VPNRR in NS.\n",
}
else if (rh->status & RSL_DELEGATE_NS)
{
- if (GNUNET_GNS_RECORD_NS == rlh->record_type)
+ if (GNUNET_DNSPARSER_TYPE_NS == rlh->record_type)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Resolved queried NSRR in NS.\n",
- rh->id);
- finish_lookup(rh, rlh, rd_count, rd);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Resolved queried NSRR in NS.\n",
+ rh->id);
+ finish_lookup (rh, rlh, rd_count, rd);
return;
- }
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: NS delegation starting.\n",
- rh->id);
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: NS delegation starting.\n",
+ rh->id);
GNUNET_assert (NULL != rd);
rh->proc = &handle_record_ns;
resolve_record_dns (rh, rd_count, rd);
finish_lookup (rh, rlh, 0, NULL);
return;
}
- else if (GNUNET_GNS_RECORD_PKEY == rlh->record_type)
+ else if (GNUNET_NAMESTORE_TYPE_PKEY == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried PKEY in NS.\n",
if (rh->status & RSL_DELEGATE_NS)
{
- if (GNUNET_GNS_RECORD_NS == rlh->record_type)
+ if (GNUNET_DNSPARSER_TYPE_NS == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried NSRR in NS.\n",
*/
static void
process_delegation_result_ns (void* cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKey *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ResolverHandle *rh = cls;
struct GNUNET_TIME_Relative remaining_time;
char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
unsigned int i;
struct GNUNET_TIME_Absolute et;
+ struct AuthorityChain *auth;
rh->namestore_task = NULL;
+ GNUNET_CRYPTO_short_hash (key,
+ sizeof (struct GNUNET_CRYPTO_EccPublicKey),
+ &zone);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup\n",
- rh->id, rd_count);
+ "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup for `%s' in zone %s\n",
+ rh->id, rd_count,
+ name,
+ GNUNET_short_h2s (&zone));
- GNUNET_CRYPTO_short_hash (key,
- sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
- &zone);
remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
rh->status = 0;
- if (name != NULL)
+ if (NULL != name)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Records with name %s exist.\n",
- rh->id, name);
+ "GNS_PHASE_DELEGATE_NS-%llu: Records with name `%s' exist in zone %s.\n",
+ rh->id, name,
+ GNUNET_short_h2s (&zone));
rh->status |= RSL_RECORD_EXISTS;
- if (remaining_time.rel_value == 0)
+ if (0 == remaining_time.rel_value_us)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n",
/**
* No authority found in namestore.
*/
- if (rd_count == 0)
+ if (0 == rd_count)
{
/**
* We did not find an authority in the namestore
*/
for (i=0; i < rd_count;i++)
{
-
- /**
- * A CNAME. Like regular DNS this means the is no other record for this
- * name.
- */
- if (rd[i].record_type == GNUNET_GNS_RECORD_CNAME)
+ switch (rd[i].record_type)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: CNAME found.\n",
- rh->id);
+ case GNUNET_DNSPARSER_TYPE_CNAME:
+ /* Like in regular DNS this should mean that there is no other
+ * record for this name. */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: CNAME `%.*s' found.\n",
+ rh->id,
+ (int) rd[i].data_size,
+ rd[i].data);
rh->status |= RSL_CNAME_FOUND;
rh->proc (rh->proc_cls, rh, rd_count, rd);
return;
- }
-
- /**
- * Redirect via VPN
- */
- if (rd[i].record_type == GNUNET_GNS_RECORD_VPN)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: VPN found.\n",
- rh->id);
+ case GNUNET_NAMESTORE_TYPE_VPN:
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: VPN found.\n",
+ rh->id);
rh->status |= RSL_DELEGATE_VPN;
rh->proc (rh->proc_cls, rh, rd_count, rd);
return;
- }
-
- /**
- * Redirect via NS
- * FIXME make optional
- */
- if (rd[i].record_type == GNUNET_GNS_RECORD_NS)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: NS found.\n",
- rh->id);
+ case GNUNET_DNSPARSER_TYPE_NS:
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: NS `%.*s' found.\n",
+ rh->id,
+ (int) rd[i].data_size,
+ rd[i].data);
rh->status |= RSL_DELEGATE_NS;
rh->proc (rh->proc_cls, rh, rd_count, rd);
return;
- }
-
- if (rd[i].record_type != GNUNET_GNS_RECORD_PKEY)
- continue;
-
- rh->status |= RSL_DELEGATE_PKEY;
-
- if ((ignore_pending_records != 0) &&
- (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: PKEY for %s is pending user confirmation.\n",
- rh->id,
- name);
- continue;
- }
-
- GNUNET_break (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
- et.abs_value = rd[i].expiration_time;
- if ((GNUNET_TIME_absolute_get_remaining (et)).rel_value
- == 0)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
- rh->id);
- if (remaining_time.rel_value == 0)
+ case GNUNET_NAMESTORE_TYPE_PKEY:
+ rh->status |= RSL_DELEGATE_PKEY;
+ if ((ignore_pending_records != 0) &&
+ (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
- rh->id);
- rh->authority_chain_head->fresh = 0;
- rh->proc (rh->proc_cls, rh, 0, NULL);
- return;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: PKEY for %s is pending user confirmation.\n",
+ rh->id,
+ name);
+ continue;
+ }
+ GNUNET_break (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
+ et.abs_value_us = rd[i].expiration_time;
+ if (0 == (GNUNET_TIME_absolute_get_remaining (et)).rel_value_us)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
+ rh->id);
+ if (remaining_time.rel_value_us == 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
+ rh->id);
+ rh->authority_chain_head->fresh = 0;
+ rh->proc (rh->proc_cls, rh, 0, NULL);
+ return;
+ }
+ continue;
}
-
- continue;
+ /* Resolve rest of query with new authority */
+ memcpy (&rh->authority, rd[i].data,
+ sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+ auth = GNUNET_malloc(sizeof (struct AuthorityChain));
+ auth->zone = rh->authority;
+ memset (auth->name, 0, strlen (rh->authority_name)+1);
+ strcpy (auth->name, rh->authority_name);
+ GNUNET_CONTAINER_DLL_insert (rh->authority_chain_head,
+ rh->authority_chain_tail,
+ auth);
+ if (NULL != rh->rd.data)
+ GNUNET_free ((void*)(rh->rd.data));
+ memcpy (&rh->rd, &rd[i], sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rh->rd.data = GNUNET_malloc (rd[i].data_size);
+ memcpy ((void*)rh->rd.data, rd[i].data, rd[i].data_size);
+ rh->rd_count = 1;
+ /* Check for key revocation and delegate */
+ rh->namestore_task = GNUNET_NAMESTORE_lookup (namestore_handle,
+ &rh->authority,
+ GNUNET_GNS_MASTERZONE_STR,
+ GNUNET_NAMESTORE_TYPE_REV,
+ &process_pkey_revocation_result_ns,
+ rh);
+ return;
+ default:
+ /* ignore, move to next result */
+ break;
}
-
- /**
- * Resolve rest of query with new authority
- */
- GNUNET_assert (rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
- memcpy (&rh->authority, rd[i].data,
- sizeof (struct GNUNET_CRYPTO_ShortHashCode));
- struct AuthorityChain *auth = GNUNET_malloc(sizeof (struct AuthorityChain));
- auth->zone = rh->authority;
- memset (auth->name, 0, strlen (rh->authority_name)+1);
- strcpy (auth->name, rh->authority_name);
- GNUNET_CONTAINER_DLL_insert (rh->authority_chain_head,
- rh->authority_chain_tail,
- auth);
- if (NULL != rh->rd.data)
- GNUNET_free ((void*)(rh->rd.data));
-
- memcpy (&rh->rd, &rd[i], sizeof (struct GNUNET_NAMESTORE_RecordData));
- rh->rd.data = GNUNET_malloc (rd[i].data_size);
- memcpy ((void*)rh->rd.data, rd[i].data, rd[i].data_size);
- rh->rd_count = 1;
- /* Check for key revocation and delegate */
- rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &rh->authority,
- "+",
- GNUNET_GNS_RECORD_REV,
- &process_pkey_revocation_result_ns,
- rh);
- return;
}
- /**
- * no answers found
- */
+ /* no answers that would cause delegation were found */
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Authority lookup and no PKEY...\n", rh->id);
+ "GNS_PHASE_DELEGATE_NS-%llu: Authority lookup failed (no PKEY record)\n",
+ rh->id);
/**
* If we have found some records for the LAST label
- * we return the results. Else null.
+ * we return the results. Else NULL.
*/
- if (strcmp (rh->name, "") == 0)
+ if (0 == strcmp (rh->name, ""))
{
/* Start shortening */
if ((rh->priv_key != NULL) &&
/**
* Resolve the delegation chain for the request in our namestore
+ * (as in, find the respective authority for the leftmost label).
*
* @param rh the resolver handle
*/
{
pop_tld (rh->name, rh->authority_name);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Resolving delegation for %s by looking up %s\n",
- rh->id, rh->name,
- rh->authority_name);
- rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &rh->authority,
- rh->authority_name,
- GNUNET_GNS_RECORD_ANY,
- &process_delegation_result_ns,
- rh);
+ "GNS_PHASE_DELEGATE_NS-%llu: Finding authority for `%s' by looking up `%s' in GADS zone `%s'\n",
+ rh->id,
+ rh->name,
+ rh->authority_name,
+ GNUNET_short_h2s (&rh->authority));
+ rh->namestore_task = GNUNET_NAMESTORE_lookup (namestore_handle,
+ &rh->authority,
+ rh->authority_name,
+ &process_delegation_result_ns,
+ rh);
}
+#endif
+
+
/**
- * Lookup of a record in a specific zone
- * calls lookup result processor on result
+ * Lookup of a record in a specific zone calls lookup result processor
+ * on result.
*
- * @param zone the root zone
- * @param pzone the private local zone
+ * @param zone the zone to perform the lookup in
* @param record_type the record type to look up
* @param name the name to look up
- * @param key a private key for use with PSEU import (can be NULL)
- * @param timeout timeout for resolution
+ * @param shorten_key a private key for use with PSEU import (can be NULL)
* @param only_cached GNUNET_NO to only check locally not DHT for performance
* @param proc the processor to call on result
- * @param cls the closure to pass to proc
- */
-void
-gns_resolver_lookup_record (struct GNUNET_CRYPTO_ShortHashCode zone,
- struct GNUNET_CRYPTO_ShortHashCode pzone,
- uint32_t record_type,
- const char* name,
- struct GNUNET_CRYPTO_RsaPrivateKey *key,
- struct GNUNET_TIME_Relative timeout,
- int only_cached,
- RecordLookupProcessor proc,
- void* cls)
+ * @param proc_cls the closure to pass to @a proc
+ * @return handle to cancel operation
+ */
+struct GNS_ResolverHandle *
+GNS_resolver_lookup (const struct GNUNET_CRYPTO_EccPublicKey *zone,
+ uint32_t record_type,
+ const char *name,
+ const struct GNUNET_CRYPTO_EccPrivateKey *shorten_key,
+ int only_cached,
+ GNS_ResultProcessor proc, void *proc_cls)
{
+ return NULL;
+#if 0
struct ResolverHandle *rh;
struct RecordLookupHandle* rlh;
char string_hash[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
char* nzkey_ptr = nzkey;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Starting resolution for %s (type=%d) with timeout %s!\n",
+ "Starting resolution for `%s' (type=%d) with timeout %s!\n",
name, record_type,
GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_YES));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"No shorten key for resolution\n");
- if (timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+ if (timeout.rel_value_us != GNUNET_TIME_UNIT_FOREVER_REL.rel_value_us)
{
/*
* Set timeout for authority lookup phase to 1/2
if (strcmp(GNUNET_GNS_TLD, name) == 0)
{
/**
- * Only 'gnunet' given
+ * Only '.gads' given
*/
- strcpy(rh->name, "\0");
+ strcpy (rh->name, "\0");
}
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Checking for TLD...\n");
if (is_zkey_tld(name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY));
memcpy(rh->name, name,
strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY) - 1);
- pop_tld(rh->name, string_hash);
+ pop_tld (rh->name, string_hash);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"ZKEY is %s!\n", string_hash);
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Cannot handle this TLD %s\n", string_hash);
-
+ _("Not a GADS TLD: `%s'\n"),
+ name);
if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
GNUNET_SCHEDULER_cancel (rh->timeout_task);
GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh);
rlh->proc_cls = cls;
rh->proc = &handle_delegation_ns;
- resolve_delegation_ns(rh);
-}
-
-/******** END Record Resolver ***********/
-
-static void
-finish_shorten (struct ResolverHandle *rh,
- struct NameShortenHandle *nsh)
-{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending %s as shorten result\n", nsh->result);
- nsh->proc (nsh->proc_cls, nsh->result);
- GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh);
- GNUNET_free (nsh);
- free_resolver_handle (rh);
+ resolve_delegation_ns (rh);
+#endif
}
-/**
- * Callback calles by namestore for a zone to name
- * result
- *
- * @param cls the closure
- * @param zone_key the zone we queried
- * @param expire the expiration time of the name
- * @param name the name found or NULL
- * @param rd_len number of records for the name
- * @param rd the record data (PKEY) for the name
- * @param signature the signature for the record data
- */
-static void
-process_zone_to_name_shorten_root (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- struct GNUNET_TIME_Absolute expire,
- const char *name,
- unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature);
-
/**
- * Callback called by namestore for a zone to name
- * result
+ * Cancel active resolution (i.e. client disconnected).
*
- * @param cls the closure
- * @param zone_key the zone we queried
- * @param expire the expiration time of the name
- * @param name the name found or NULL
- * @param rd_len number of records for the name
- * @param rd the record data (PKEY) for the name
- * @param signature the signature for the record data
+ * @param h resolution to abort
*/
-static void
-process_zone_to_name_shorten_shorten (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- struct GNUNET_TIME_Absolute expire,
- const char *name,
- unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+void
+GNS_resolver_lookup_cancel (struct GNS_ResolverHandle *h)
{
- struct ResolverHandle *rh = cls;
- struct NameShortenHandle* nsh = rh->proc_cls;
- struct AuthorityChain *next_authority;
-
- char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- char tmp_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- size_t answer_len;
-
- rh->namestore_task = NULL;
- /* we found a match in our own root zone */
- if (rd_len != 0)
- {
- answer_len = strlen(rh->name) + strlen(name) + strlen(GNUNET_GNS_TLD) + 3;
- memset(result, 0, answer_len);
-
- if (strlen(rh->name) > 0)
- {
- sprintf (result, "%s.%s.%s.%s",
- rh->name, name,
- nsh->shorten_zone_name,
- GNUNET_GNS_TLD);
- }
- else
- {
- sprintf (result, "%s.%s.%s", name,
- nsh->shorten_zone_name,
- GNUNET_GNS_TLD);
- }
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Found shorten result %s\n", result);
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- }
- else if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- nsh->shorten_zone) == 0)
- {
- /**
- * This is our zone append .gads unless name is empty
- * (it shouldn't be, usually FIXME what happens if we
- * shorten to our zone to a "" record??)
- */
-
- sprintf (result, "%s.%s.%s",
- rh->name,
- nsh->shorten_zone_name,
- GNUNET_GNS_TLD);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Our zone: Found %s as shorten result\n", result);
-
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- //nsh->proc(nsh->proc_cls, result);
- //GNUNET_free(nsh);
- //free_resolver_handle(rh);
- //return;
- }
-
-
- /**
- * No PSEU found.
- * continue with next authority if exists
- */
- if (NULL == rh->authority_chain_head->next)
- {
- finish_shorten (rh, nsh);
- return;
- }
- next_authority = rh->authority_chain_head;
-
- if (0 == strcmp (rh->name, ""))
- strcpy (tmp_name, next_authority->name);
- else
- GNUNET_snprintf(tmp_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
- "%s.%s", rh->name, next_authority->name);
-
- strcpy(rh->name, tmp_name);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "No PSEU found for authority %s. Promoting back: %s\n",
- next_authority->name, rh->name);
-
- GNUNET_CONTAINER_DLL_remove(rh->authority_chain_head,
- rh->authority_chain_tail,
- next_authority);
-
- GNUNET_free (next_authority);
-
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- &rh->authority_chain_tail->zone,
- &rh->authority_chain_head->zone,
- &process_zone_to_name_shorten_root,
- rh);
}
-/**
- * Callback calles by namestore for a zone to name
- * result
- *
- * @param cls the closure
- * @param zone_key the zone we queried
- * @param expire the expiration time of the name
- * @param name the name found or NULL
- * @param rd_len number of records for the name
- * @param rd the record data (PKEY) for the name
- * @param signature the signature for the record data
- */
-static void
-process_zone_to_name_shorten_private (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- struct GNUNET_TIME_Absolute expire,
- const char *name,
- unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
-{
- struct ResolverHandle *rh = cls;
- struct NameShortenHandle* nsh = rh->proc_cls;
- struct AuthorityChain *next_authority;
-
- char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- char tmp_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- size_t answer_len;
-
- rh->namestore_task = NULL;
- /* we found a match in our own root zone */
- if (rd_len != 0)
- {
- answer_len = strlen(rh->name) + strlen(name) + strlen(GNUNET_GNS_TLD) + 3;
- memset(result, 0, answer_len);
-
- if (strlen(rh->name) > 0)
- {
- sprintf (result, "%s.%s.%s", rh->name, name, GNUNET_GNS_TLD);
- }
- else
- {
- sprintf (result, "%s.%s", name, GNUNET_GNS_TLD);
- }
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Found shorten result %s\n", result);
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- }
- else if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- nsh->private_zone) == 0)
- {
- /**
- * This is our zone append .gads unless name is empty
- * (it shouldn't be, usually FIXME what happens if we
- * shorten to our zone to a "" record??)
- */
-
- sprintf (result, "%s.%s.%s",
- rh->name, nsh->private_zone_name, GNUNET_GNS_TLD);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Our private zone: Found %s as shorten result %s\n", result);
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- }
-
- if (0 != strcmp (nsh->shorten_zone_name, ""))
- {
- /* backtrack authorities for names in priv zone */
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- nsh->shorten_zone,
- &rh->authority_chain_head->zone,
- &process_zone_to_name_shorten_shorten,
- rh);
- }
- else
- {
- /**
- * No PSEU found.
- * continue with next authority if exists
- */
- if (NULL == rh->authority_chain_head->next)
- {
- finish_shorten (rh, nsh);
- return;
- }
- next_authority = rh->authority_chain_head;
-
- if (0 == strcmp (rh->name, ""))
- strcpy (tmp_name, next_authority->name);
- else
- GNUNET_snprintf(tmp_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
- "%s.%s", rh->name, next_authority->name);
-
- strcpy(rh->name, tmp_name);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "No PSEU found for authority %s. Promoting back: %s\n",
- next_authority->name, rh->name);
-
- GNUNET_CONTAINER_DLL_remove(rh->authority_chain_head,
- rh->authority_chain_tail,
- next_authority);
-
- GNUNET_free (next_authority);
-
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- &rh->authority_chain_tail->zone,
- &rh->authority_chain_head->zone,
- &process_zone_to_name_shorten_root,
- rh);
- }
-}
+/* ***************** Resolver initialization ********************* */
/**
- * Callback calles by namestore for a zone to name
- * result
- *
- * @param cls the closure
- * @param zone_key the zone we queried
- * @param expire the expiration time of the name
- * @param name the name found or NULL
- * @param rd_len number of records for the name
- * @param rd the record data (PKEY) for the name
- * @param signature the signature for the record data
- */
-static void
-process_zone_to_name_shorten_root (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- struct GNUNET_TIME_Absolute expire,
- const char *name,
- unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
-{
- struct ResolverHandle *rh = cls;
- struct NameShortenHandle* nsh = rh->proc_cls;
- struct AuthorityChain *next_authority;
- char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- char tmp_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- size_t answer_len;
-
- rh->namestore_task = NULL;
- /* we found a match in our own root zone */
- if (rd_len != 0)
- {
- answer_len = strlen(rh->name) + strlen(name) + strlen(GNUNET_GNS_TLD) + 3;
- memset(result, 0, answer_len);
-
- if (strlen(rh->name) > 0)
- {
- sprintf (result, "%s.%s.%s", rh->name, name, GNUNET_GNS_TLD);
- }
- else
- {
- sprintf (result, "%s.%s", name, GNUNET_GNS_TLD);
- }
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Found shorten result %s\n", result);
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- }
- else if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- nsh->root_zone) == 0)
- {
- /**
- * This is our zone append .gads unless name is empty
- * (it shouldn't be, usually FIXME what happens if we
- * shorten to our zone to a "" record??)
- */
-
- sprintf (result, "%s.%s", rh->name, GNUNET_GNS_TLD);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Our zone: Found %s as shorten result\n", result);
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- }
-
- if (NULL != nsh->private_zone)
- {
- /* backtrack authorities for names in priv zone */
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- nsh->private_zone,
- &rh->authority_chain_head->zone,
- &process_zone_to_name_shorten_private,
- rh);
- }
- else if (NULL != nsh->shorten_zone)
- {
- /* backtrack authorities for names in shorten zone */
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- nsh->shorten_zone,
- &rh->authority_chain_head->zone,
- &process_zone_to_name_shorten_shorten,
- rh);
- }
- else
- {
- /**
- * No PSEU found.
- * continue with next authority if exists
- */
- if (NULL == rh->authority_chain_head->next)
- {
- finish_shorten (rh, nsh);
- return;
- }
- next_authority = rh->authority_chain_head;
-
- if (0 == strcmp (rh->name, ""))
- strcpy (tmp_name, next_authority->name);
- else
- GNUNET_snprintf(tmp_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
- "%s.%s", rh->name, next_authority->name);
-
- strcpy(rh->name, tmp_name);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "No PSEU found for authority %s. Promoting back: %s\n",
- next_authority->name, rh->name);
-
- GNUNET_CONTAINER_DLL_remove(rh->authority_chain_head,
- rh->authority_chain_tail,
- next_authority);
-
- GNUNET_free (next_authority);
-
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- &rh->authority_chain_tail->zone,
- &rh->authority_chain_head->zone,
- &process_zone_to_name_shorten_root,
- rh);
- }
-}
-
-
-/**
- * Process result from namestore delegation lookup
- * for shorten operation
- *
- * @param cls the client shorten handle
- * @param rh the resolver handle
- * @param rd_count number of results (0)
- * @param rd data (NULL)
- */
-static void
-handle_delegation_ns_shorten (void* cls,
- struct ResolverHandle *rh,
- uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
-{
- struct NameShortenHandle *nsh;
- char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
-
- nsh = (struct NameShortenHandle *)cls;
- rh->namestore_task = NULL;
- /**
- * At this point rh->name contains the part of the name
- * that we do not have a PKEY in our namestore to resolve.
- * The authority chain in the resolver handle is now
- * useful to backtrack if needed
- */
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "PKEY resolved as far as possible in ns up to %s!\n", rh->name);
- memset(result, 0, sizeof (result));
-
- if (0 == GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- nsh->root_zone))
- {
- /**
- * This is our zone append .gads unless name is empty
- * (it shouldn't be, usually FIXME what happens if we
- * shorten to our zone to a "" record??)
- */
-
- sprintf (result, "%s.%s", rh->name, GNUNET_GNS_TLD);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Our zone: Found %s as shorten result\n", result);
-
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
-
- }
- else if (NULL != nsh->private_zone)
- {
- /**
- * This is our zone append .gads unless name is empty
- * (it shouldn't be, usually FIXME what happens if we
- * shorten to our zone to a "" record??)
- */
- if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- nsh->private_zone) == 0)
- {
-
- sprintf (result, "%s.%s.%s",
- rh->name, nsh->private_zone_name, GNUNET_GNS_TLD);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Our zone: Found %s as shorten result in private zone %s\n",
- result);
-
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- }
- }
- else if (NULL != nsh->shorten_zone)
- {
- /**
- * This is our zone append .gads unless name is empty
- * (it shouldn't be, usually FIXME what happens if we
- * shorten to our zone to a "" record??)
- */
- if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- nsh->shorten_zone) == 0)
- {
- sprintf (result, "%s.%s.%s",
- rh->name, nsh->private_zone_name, GNUNET_GNS_TLD);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Our zone: Found %s as shorten result in shorten zone\n",
- result);
-
- if (strlen (nsh->result) > strlen (result))
- strcpy (nsh->result, result);
- }
- }
-
-
- /* backtrack authorities for names */
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- nsh->root_zone,
- &rh->authority_chain_head->zone,
- &process_zone_to_name_shorten_root,
- rh);
-
-}
-
-
-/**
- * Callback calles by namestore for a zone to name
- * result
+ * Initialize the resolver
*
- * @param cls the closure
- * @param zone_key the zone we queried
- * @param expire the expiration time of the name
- * @param name the name found or NULL
- * @param rd_len number of records for the name
- * @param rd the record data (PKEY) for the name
- * @param signature the signature for the record data
+ * @param nh the namestore handle
+ * @param dh the dht handle
+ * @param c configuration handle
+ * @param max_bg_queries maximum number of parallel background queries in dht
+ * @param ignore_pending ignore records that still require user confirmation
+ * on lookup
*/
-static void
-process_zone_to_name_zkey(void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
- struct GNUNET_TIME_Absolute expire,
- const char *name,
- unsigned int rd_len,
- const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+void
+GNS_resolver_init (struct GNUNET_NAMESTORE_Handle *nh,
+ struct GNUNET_DHT_Handle *dh,
+ const struct GNUNET_CONFIGURATION_Handle *c,
+ unsigned long long max_bg_queries)
{
- struct ResolverHandle *rh = cls;
- struct NameShortenHandle *nsh = rh->proc_cls;
- char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+ char *dns_ip;
- rh->namestore_task = NULL;
-
- /* zkey not in our zone */
- if (name == NULL)
+ cfg = c;
+ namestore_handle = nh;
+ dht_handle = dh;
+ dht_lookup_heap =
+ GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ max_allowed_background_queries = max_bg_queries;
+ if (GNUNET_OK !=
+ GNUNET_CONFIGURATION_get_value_string (c,
+ "gns",
+ "DNS_RESOLVER",
+ &dns_ip))
{
- /**
- * In this case we have not given this PKEY a name (yet)
- * It is either just not in our zone or not even cached
- * Since we do not know at this point we will not try to shorten
- * because PKEY import will happen if the user follows the zkey
- * link.
- */
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "No name found for zkey %s returning verbatim!\n", nsh->result);
- /*if (strcmp(rh->name, "") != 0)
- GNUNET_snprintf(new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s.%s",
- rh->name, enc, GNUNET_GNS_TLD_ZKEY);
- else
- GNUNET_snprintf(new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
- enc, GNUNET_GNS_TLD_ZKEY);
-
- strcpy (nsh->result, new_name);*/
-
- finish_shorten (rh, nsh);
- return;
+ /* user did not specify DNS resolver, use 8.8.8.8 */
+ dns_ip = GNUNET_strdup ("8.8.8.8");
}
-
- if (strcmp(rh->name, "") != 0)
- GNUNET_snprintf(new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
- rh->name, name);
- else
- strcpy(new_name, name);
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Continue shorten for %s!\n", new_name);
-
- strcpy(rh->name, new_name);
-
- rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
- rh->authority_chain_tail = rh->authority_chain_head;
- rh->authority_chain_head->zone = rh->authority;
-
-
- /* Start delegation resolution in our namestore */
- resolve_delegation_ns (rh);
+ dns_handle = GNUNET_DNSSTUB_start (dns_ip);
+ GNUNET_free (dns_ip);
}
/**
- * Shorten api from resolver
- *
- * @param zone the root zone to use
- * @param pzone the private zone to use
- * @param szone the shorten zone to use
- * @param name the name to shorten
- * @param private_zone_name name of the private zone
- * @param shorten_zone_name name of the shorten zone
- * @param proc the processor to call with result
- * @param proc_cls closure to pass to proc
+ * Shutdown resolver
*/
void
-gns_resolver_shorten_name (struct GNUNET_CRYPTO_ShortHashCode *zone,
- struct GNUNET_CRYPTO_ShortHashCode *pzone,
- struct GNUNET_CRYPTO_ShortHashCode *szone,
- const char* name,
- const char* private_zone_name,
- const char* shorten_zone_name,
- ShortenResultProcessor proc,
- void* proc_cls)
+GNS_resolver_done ()
{
- struct ResolverHandle *rh;
- struct NameShortenHandle *nsh;
- char string_hash[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
- struct GNUNET_CRYPTO_ShortHashCode zkey;
- char nzkey[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
- char* nzkey_ptr = nzkey;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Starting shorten for %s!\n", name);
-
- if (is_canonical ((char*)name) == GNUNET_YES)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "%s is canonical. Returning verbatim\n", name);
- proc (proc_cls, name);
- return;
- }
-
- nsh = GNUNET_malloc (sizeof (struct NameShortenHandle));
- nsh->proc = proc;
- nsh->proc_cls = proc_cls;
- nsh->root_zone = zone;
- nsh->private_zone = pzone;
- nsh->shorten_zone = szone;
- strcpy (nsh->private_zone_name, private_zone_name);
- strcpy (nsh->shorten_zone_name, shorten_zone_name);
- strcpy (nsh->result, name);
-
- rh = GNUNET_malloc (sizeof (struct ResolverHandle));
- rh->authority = *zone;
- rh->id = rid_gen++;
- rh->proc = &handle_delegation_ns_shorten;
- rh->proc_cls = nsh;
- rh->private_local_zone = *zone;
-
- GNUNET_CONTAINER_DLL_insert (nsh_head, nsh_tail, rh);
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Checking for TLD...\n");
- if (is_zkey_tld (name) == GNUNET_YES)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "TLD is zkey\n");
- /**
- * This is a zkey tld
- * build hash and use as initial authority
- * FIXME sscanf
- */
- memset (rh->name, 0,
- strlen (name)-strlen (GNUNET_GNS_TLD_ZKEY));
- memcpy (rh->name, name,
- strlen(name)-strlen (GNUNET_GNS_TLD_ZKEY) - 1);
- pop_tld (rh->name, string_hash);
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "ZKEY is %s!\n", string_hash);
-
- GNUNET_STRINGS_utf8_toupper (string_hash, &nzkey_ptr);
-
- if (GNUNET_OK != GNUNET_CRYPTO_short_hash_from_string (nzkey,
- &zkey))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Cannot convert ZKEY %s to hash!\n", nzkey);
- GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh);
- GNUNET_free (rh);
- GNUNET_free (nsh);
- proc (proc_cls, name);
- return;
- }
- rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
- zone, //ours
- &zkey,
- &process_zone_to_name_zkey,
- rh);
- return;
-
- }
- else if (is_gads_tld (name) == GNUNET_YES)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "TLD is gnunet\n");
- /**
- * Presumably GNUNET tld
- */
- memset (rh->name, 0,
- strlen (name)-strlen (GNUNET_GNS_TLD));
- memcpy (rh->name, name,
- strlen (name)-strlen (GNUNET_GNS_TLD) - 1);
- }
- else
- {
- GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unknown TLD in %s\n", name);
- GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh);
- GNUNET_free (rh);
- GNUNET_free (nsh);
- proc (proc_cls, name);
- return;
- }
-
- rh->authority_chain_head = GNUNET_malloc (sizeof (struct AuthorityChain));
- rh->authority_chain_tail = rh->authority_chain_head;
- rh->authority_chain_head->zone = *zone;
-
- /* Start delegation resolution in our namestore */
- resolve_delegation_ns (rh);
+ while (NULL != gph_head)
+ free_get_pseu_authority_handle (gph_head);
+ GNUNET_CONTAINER_heap_destroy (dht_lookup_heap);
+ dht_lookup_heap = NULL;
+ GNUNET_DNSSTUB_stop (dns_handle);
+ dns_handle = NULL;
}
-/*********** END NAME SHORTEN ********************/
-
-/**
- * Conclude get authority lookup
- *
- * @param rh resolver handle
- * @param nah get authority lookup handle
- */
-static void
-finish_get_auth (struct ResolverHandle *rh,
- struct GetNameAuthorityHandle *nah)
-{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Got authority result %s\n", nah->result);
-
- nah->proc (nah->proc_cls, nah->result);
- GNUNET_CONTAINER_DLL_remove (nah_head, nah_tail, rh);
- GNUNET_free (nah);
- free_resolver_handle (rh);
-}
+/* *************** common helper functions (do not really belong here) *********** */
/**
- * Process result from namestore delegation lookup
- * for get authority operation
+ * Checks if "name" ends in ".tld"
*
- * @param cls the client get auth handle
- * @param rh the resolver handle
- * @param rd_count number of results (0)
- * @param rd data (NULL)
+ * @param name the name to check
+ * @param tld the TLD to check for
+ * @return GNUNET_YES or GNUNET_NO
*/
-static void
-handle_delegation_result_ns_get_auth(void* cls,
- struct ResolverHandle *rh,
- uint32_t rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+int
+is_tld (const char* name, const char* tld)
{
- struct GetNameAuthorityHandle* nah = rh->proc_cls;
- size_t answer_len;
-
- /**
- * At this point rh->name contains the part of the name
- * that we do not have a PKEY in our namestore to resolve.
- * The authority chain in the resolver handle is now
- * useful to backtrack if needed
- */
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "PKEY resolved as far as possible in ns up to %s!\n", rh->name);
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Building response!\n");
- if (is_canonical (rh->name) == GNUNET_YES)
- {
- /**
- * We successfully resolved the authority in the ns
- * FIXME for our purposes this is fine
- * but maybe we want to have an api that also looks
- * into the dht (i.e. option in message)
- **/
- if (strlen(rh->name) > strlen(nah->name))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Record name longer than original lookup name... odd!\n");
- //FIXME to sth here
- }
-
- answer_len = strlen(nah->name) - strlen(rh->name)
- + strlen(GNUNET_GNS_TLD) + 1;
- memset(nah->result, 0, answer_len);
- if (0 != strcmp (rh->name, ""))
- strcpy(nah->result, nah->name + strlen(rh->name) + 1);
- else
- strcpy(nah->result, nah->name);
+ size_t offset = 0;
- finish_get_auth (rh, nah);
- }
- else
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "Unable to resolve authority for remaining %s!\n", rh->name);
- strcpy(nah->result, "");
- finish_get_auth (rh, nah);
- }
+ if (strlen (name) <= strlen (tld))
+ return GNUNET_NO;
+ offset = strlen (name) - strlen (tld);
+ if (0 != strcmp (name + offset, tld))
+ return GNUNET_NO;
+ return GNUNET_YES;
}
-/**
- * Tries to resolve the authority for name
- * in our namestore
- *
- * @param zone the root zone to look up for
- * @param pzone the private local zone
- * @param name the name to lookup up
- * @param proc the processor to call when finished
- * @param proc_cls the closure to pass to the processor
- */
-void
-gns_resolver_get_authority(struct GNUNET_CRYPTO_ShortHashCode zone,
- struct GNUNET_CRYPTO_ShortHashCode pzone,
- const char* name,
- GetAuthorityResultProcessor proc,
- void* proc_cls)
-{
- struct ResolverHandle *rh;
- struct GetNameAuthorityHandle *nah;
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Starting authority resolution for %s!\n", name);
-
- nah = GNUNET_malloc(sizeof (struct GetNameAuthorityHandle));
- rh = GNUNET_malloc(sizeof (struct ResolverHandle));
- rh->authority = zone;
- rh->id = rid_gen++;
- rh->private_local_zone = pzone;
-
- GNUNET_CONTAINER_DLL_insert (nah_head, nah_tail, rh);
-
- if (strcmp(GNUNET_GNS_TLD, name) == 0)
- {
- strcpy(rh->name, "\0");
- }
- else
- {
- memset(rh->name, 0,
- strlen(name)-strlen(GNUNET_GNS_TLD));
- memcpy(rh->name, name,
- strlen(name)-strlen(GNUNET_GNS_TLD) - 1);
- }
-
- memset(nah->name, 0,
- strlen(name)+1);
- strcpy(nah->name, name);
-
- rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
- rh->authority_chain_tail = rh->authority_chain_head;
- rh->authority_chain_head->zone = zone;
- rh->proc = &handle_delegation_result_ns_get_auth;
- rh->proc_cls = (void*)nah;
-
- nah->proc = proc;
- nah->proc_cls = proc_cls;
- strcpy (nah->result, "");
-
- /* Start delegation resolution in our namestore */
- resolve_delegation_ns(rh);
-
-}
-/******** END GET AUTHORITY *************/
/* end of gnunet-service-gns_resolver.c */
projects / oweals / gnunet.git / blobdiff