*/
/**
- *
- *
* @file gns/gnunet-service-gns_resolver.c
* @brief GNUnet GNS resolver logic
* @author Martin Schanzenbach
#include "gnunet_dns_service.h"
#include "gnunet_resolver_service.h"
#include "gnunet_dnsparser_lib.h"
-#include "../dns/dnsparser.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"
+/**
+ * Default DHT timeout
+ */
#define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT
+
+/**
+ * DHT replication level
+ */
#define DHT_GNS_REPLICATION_LEVEL 5
+
+/**
+ * Maximum label length of DNS names
+ */
#define MAX_DNS_LABEL_LENGTH 63
*/
static struct ResolverHandle *nah_tail;
+/**
+ * Global configuration.
+ */
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
/**
* a resolution identifier pool variable
- * FIXME overflow?
* This is a non critical identifier useful for debugging
*/
static unsigned long long rid = 0;
+/*
+ * Check if name is in srv format (_x._y.xxx)
+ *
+ * @param name
+ * @return GNUNET_YES if true
+ */
static int
is_srv (char* name)
{
char* ndup;
- int ret = 1;
+ int ret = GNUNET_YES;
if (*name != '_')
- return 0;
+ return GNUNET_NO;
if (NULL == strstr (name, "._"))
- return 0;
+ return GNUNET_NO;
ndup = GNUNET_strdup (name);
strtok (ndup, ".");
if (NULL == strtok (NULL, "."))
- ret = 0;
+ ret = GNUNET_NO;
if (NULL == strtok (NULL, "."))
- ret = 0;
+ ret = GNUNET_NO;
if (NULL != strtok (NULL, "."))
- ret = 0;
+ ret = GNUNET_NO;
+
+ GNUNET_free (ndup);
return ret;
}
/**
- * Determine if this name is canonical.
- * i.e.
- * a.b.gnunet = not canonical
- * a = canonical
+ * Determine if this name is canonical (is a legal name in a zone, without delegation);
+ * note that we do not test that the name does not contain illegal characters, we only
+ * test for delegation. Note that service records (i.e. _foo._srv) are canonical names
+ * even though they consist of multiple labels.
+ *
+ * Examples:
+ * a.b.gads = not canonical
+ * a = canonical
+ * _foo._srv = canonical
+ * _f.bar = not canonical
*
* @param name the name to test
- * @return 1 if canonical
+ * @return GNUNET_YES if canonical
*/
static int
-is_canonical(char* name)
+is_canonical (const char* name)
{
- char* ndup;
- char* tok;
+ const char *pos;
+ const char *dot;
- ndup = GNUNET_strdup (name);
- strtok (ndup, ".");
+ if (NULL == strchr (name, '.'))
+ return GNUNET_YES;
+ if ('_' != name[0])
+ return GNUNET_NO;
+ pos = &name[1];
+ while (NULL != (dot = strchr (pos, '.')))
+ if ('_' != dot[1])
+ return GNUNET_NO;
+ else
+ pos = dot + 1;
+ return GNUNET_YES;
+}
- for (tok = strtok (NULL, "."); tok != NULL; tok = strtok (NULL, "."))
- {
- /*
- * probably srv
- */
- if (*tok == '_')
- continue;
- GNUNET_free (ndup);
- return 0;
- }
- GNUNET_free (ndup);
- return 1;
+
+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);
}
shorten_authority_chain (struct GetPseuAuthorityHandle *gph);
+/**
+ * Continueation for pkey record creation (shorten)
+ *
+ * @param cls a GetPseuAuthorityHandle
+ * @param success unused
+ * @param emsg unused
+ */
static void
-create_pseu_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 = (struct GetPseuAuthorityHandle*)cls;
- struct AuthorityChain *iter;
+ struct GetPseuAuthorityHandle* gph = cls;
- gph->namestore_task = NULL;
- do
- {
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- } while (iter != NULL);
- GNUNET_CRYPTO_rsa_key_free (gph->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
- GNUNET_free (gph);
+ free_get_pseu_authority_handle (gph);
}
*/
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)
+ 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)
{
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
+ struct GetPseuAuthorityHandle* gph = cls;
struct GNUNET_NAMESTORE_RecordData new_pkey;
- struct AuthorityChain *iter;
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);
- if (0 == strcmp (gph->name, name))
- {
- if (gph->ahead->next != NULL)
- {
- if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone,
- &gph->our_zone))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n");
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- shorten_authority_chain (gph);
- return;
- }
- }
-
- /* Clean up */
- do
- {
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- } while (iter != NULL);
- GNUNET_CRYPTO_rsa_key_free (gph->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
- GNUNET_free (gph);
- return;
- }
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: Trying delegated name %s\n", gph->name);
- memcpy (gph->test_name, gph->name, strlen (gph->name)+1);
- gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &gph->our_zone,
- gph->test_name,
- GNUNET_NAMESTORE_TYPE_ANY,
- &process_pseu_lookup_ns,
- gph);
+ free_get_pseu_authority_handle (gph);
return;
}
new_pkey.expiration_time = UINT64_MAX;
new_pkey.data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode);
- new_pkey.data = &gph->ahead->zone;
+ new_pkey.data = &gph->auth->zone;
new_pkey.record_type = GNUNET_GNS_RECORD_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_pseu_cont, //cont
- gph); //cls
+ gph->key,
+ gph->test_name,
+ &new_pkey,
+ &create_pkey_cont,
+ gph);
}
/**
{
if (NULL == name)
{
- memcpy (gph->test_name, gph->ahead->name, strlen (gph->ahead->name)+1);
- }
- else
- {
- memcpy (gph->test_name, name, strlen(name)+1);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_AUTO_PSEU: No PSEU, no shorten. Finished.\n");
+ free_get_pseu_authority_handle (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);
+ &gph->our_zone,
+ gph->test_name,
+ GNUNET_NAMESTORE_TYPE_ANY,
+ &process_pseu_lookup_ns,
+ gph);
}
+
/**
* Handle timeout for dht request
*
* @param tc the task context
*/
static void
-handle_auth_discovery_timeout(void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+handle_auth_discovery_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
- struct AuthorityChain *iter;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_GET_AUTH: dht lookup for query PSEU timed out.\n");
GNUNET_DHT_get_stop (gph->get_handle);
gph->get_handle = NULL;
-
- if (gph->ahead->next != NULL)
- {
- if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone,
- &gph->our_zone))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n");
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- shorten_authority_chain (gph);
- return;
- }
- }
-
process_pseu_result (gph, NULL);
}
+
/**
* Function called when we find a PSEU entry in the DHT
*
* @param data the record data
*/
static void
-process_auth_discovery_dht_result(void* cls,
- struct GNUNET_TIME_Absolute exp,
- const struct GNUNET_HashCode * key,
- const struct GNUNET_PeerIdentity *get_path,
- unsigned int get_path_length,
- const struct GNUNET_PeerIdentity *put_path,
- unsigned int put_path_length,
- enum GNUNET_BLOCK_Type type,
- size_t size, const void *data)
+process_auth_discovery_dht_result (void* cls,
+ struct GNUNET_TIME_Absolute exp,
+ const struct GNUNET_HashCode * key,
+ const struct GNUNET_PeerIdentity *get_path,
+ unsigned int get_path_length,
+ const struct GNUNET_PeerIdentity *put_path,
+ unsigned int put_path_length,
+ enum GNUNET_BLOCK_Type type,
+ size_t size,
+ const void *data)
{
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
- struct AuthorityChain *iter;
+ struct GetPseuAuthorityHandle* gph = cls;
struct GNSNameRecordBlock *nrb;
- char* rd_data = (char*)data;
+ const char* rd_data = data;
char* name;
int num_records;
size_t rd_size;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_GET_AUTH: got dht result (size=%d)\n", size);
-
/* stop lookup and timeout task */
GNUNET_DHT_get_stop (gph->get_handle);
gph->get_handle = NULL;
GNUNET_SCHEDULER_cancel (gph->timeout);
- if (data == NULL)
+ if (NULL == data)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"GNS_GET_AUTH: got dht result null!\n", size);
-
- do
- {
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- } while (iter != NULL);
- GNUNET_CRYPTO_rsa_key_free (gph->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
- GNUNET_free (gph);
+ free_get_pseu_authority_handle (gph);
return;
}
nrb = (struct GNSNameRecordBlock*)data;
-
-
-
- nrb = (struct GNSNameRecordBlock*)data;
-
name = (char*)&nrb[1];
num_records = ntohl (nrb->rd_count);
{
}
}
}
-
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: no pseu in dht!\n");
-
- if (gph->ahead->next != NULL)
- {
- if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone,
- &gph->our_zone))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n");
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- shorten_authority_chain (gph);
- 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
*
* @param signature the signature
*/
static void
-process_auth_discovery_ns_result(void* cls,
+process_auth_discovery_ns_result (void* cls,
const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
const struct GNUNET_NAMESTORE_RecordData *rd,
const struct GNUNET_CRYPTO_RsaSignature *signature)
{
- uint32_t xquery;
- struct GNUNET_CRYPTO_ShortHashCode name_hash;
+ struct GetPseuAuthorityHandle* gph = cls;
struct GNUNET_HashCode lookup_key;
- struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string;
- struct GNUNET_HashCode name_hash_double;
- struct GNUNET_HashCode zone_hash_double;
- int i;
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
- struct AuthorityChain *iter;
+ unsigned int i;
+ uint32_t xquery;
gph->namestore_task = NULL;
/* no pseu found */
- if (rd_count == 0)
+ if (0 == rd_count)
{
- /**
- * check dht
- */
- GNUNET_CRYPTO_short_hash ("+", strlen ("+"), &name_hash);
- GNUNET_CRYPTO_short_hash_double (&name_hash, &name_hash_double);
- GNUNET_CRYPTO_short_hash_double (&gph->ahead->zone, &zone_hash_double);
- GNUNET_CRYPTO_hash_xor (&name_hash_double, &zone_hash_double, &lookup_key);
- GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string);
-
+ GNUNET_GNS_get_key_for_record (GNUNET_GNS_TLD_PLUS, &gph->auth->zone, &lookup_key);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: starting dht lookup for %s with key: %s\n",
- "+", (char*)&lookup_key_string);
+ "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);
GNUNET_assert (gph->get_handle == NULL);
- gph->get_handle = GNUNET_DHT_get_start(dht_handle,
+ gph->get_handle = GNUNET_DHT_get_start (dht_handle,
GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
&lookup_key,
DHT_GNS_REPLICATION_LEVEL,
- GNUNET_DHT_RO_NONE,
+ GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
&xquery,
sizeof(xquery),
&process_auth_discovery_dht_result,
for (i=0; i < rd_count; i++)
{
- if ((strcmp (name, "+") == 0) &&
- (rd[i].record_type == GNUNET_GNS_RECORD_PSEU))
- {
- /* found pseu */
- process_pseu_result (gph, (char*)rd[i].data);
- return;
- }
+ 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");
-
- if (gph->ahead->next != NULL)
- {
- if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone,
- &gph->our_zone))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n");
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- shorten_authority_chain (gph);
- return;
- }
- }
-
process_pseu_result (gph, NULL);
}
+
/**
* Callback called by namestore for a zone to name
* result
const struct GNUNET_NAMESTORE_RecordData *rd,
const struct GNUNET_CRYPTO_RsaSignature *signature)
{
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
- struct AuthorityChain *iter;
+ struct GetPseuAuthorityHandle* gph = cls;
gph->namestore_task = NULL;
- /* we found a match in our own zone */
- if (rd_len != 0)
+ if (0 == rd_len)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: name for zone in our root %s\n", name);
-
- iter = gph->ahead;
- do
- {
- iter = gph->ahead->next;
- GNUNET_free (gph->ahead);
- gph->ahead = iter;
- } while (iter != NULL);
- GNUNET_CRYPTO_rsa_key_free (gph->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
- GNUNET_free (gph);
- }
- else
- {
-
gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &gph->ahead->zone,
+ &gph->auth->zone,
"+",
GNUNET_GNS_RECORD_PSEU,
&process_auth_discovery_ns_result,
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);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_AUTO_PSEU: New authority %s discovered\n",
- gph->ahead->name);
+ gph->auth->name);
gph->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
&gph->our_zone,
- &gph->ahead->zone,
+ &gph->auth->zone,
&process_zone_to_name_discover,
gph);
}
+
+/**
+ * Start shortening algorithm using auth as
+ * authority chain
+ *
+ * @param auth the authorities that were resolved
+ * @param key the private key for PKEY import
+ */
static void
-start_shorten (struct AuthorityChain *atail,
- struct GNUNET_CRYPTO_RsaPrivateKey *key)
+start_shorten (struct AuthorityChain *auth,
+ const struct GNUNET_CRYPTO_RsaPrivateKey *key)
{
- struct AuthorityChain *new_head = NULL;
- struct AuthorityChain *new_tail = NULL;
- struct AuthorityChain *iter;
- struct AuthorityChain *acopy;
struct GetPseuAuthorityHandle *gph;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pb_key;
-
- /* First copy the authority chain in reverse order */
- for (iter = atail; iter != NULL; iter = iter->prev)
+
+ GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
+ if (NULL == (pb_key = GNUNET_CRYPTO_rsa_encode_key (key)))
{
- acopy = GNUNET_malloc (sizeof (struct AuthorityChain));
- memcpy (acopy, iter, sizeof (struct AuthorityChain));
- acopy->next = NULL;
- acopy->prev = NULL;
- GNUNET_CONTAINER_DLL_insert (new_head, new_tail, acopy);
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Failed to encode RSA key on shorten\n");
+ return;
}
-
gph = GNUNET_malloc (sizeof (struct GetPseuAuthorityHandle));
-
- GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
- pb_key = GNUNET_CRYPTO_rsa_encode_key (key);
- gph->key = GNUNET_CRYPTO_rsa_decode_key ((char*)pb_key, ntohs (pb_key->len));
- //gph->key = key;//GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
- //memcpy (gph->key, key, sizeof (struct GNUNET_CRYPTO_RsaPrivateKey));
-
+ 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->ahead = new_head;
-
+ gph->auth = GNUNET_malloc (sizeof (struct AuthorityChain));
+ memcpy (gph->auth, auth, sizeof (struct AuthorityChain));
GNUNET_CONTAINER_DLL_insert (gph_head, gph_tail, gph);
-
shorten_authority_chain (gph);
}
* @param nh the namestore handle
* @param dh the dht handle
* @param lz the local zone's hash
- * @param cfg configuration 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
* @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 *cfg,
- unsigned long long max_bg_queries,
- int ignore_pending)
+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);
+ GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
ns_task_heap =
- GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN);
+ 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;
-
- gph_head = NULL;
- gph_tail = NULL;
- rlh_head = NULL;
- rlh_tail = NULL;
- nsh_head = NULL;
- nsh_tail = NULL;
- nah_head = NULL;
- nah_tail = NULL;
-
+ ignore_pending_records = ignore_pending;
GNUNET_RESOLVER_connect (cfg);
-
- if (NULL == vpn_handle)
- {
- vpn_handle = GNUNET_VPN_connect (cfg);
- if (NULL == vpn_handle)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_INIT: Error connecting to VPN!\n");
-
- return GNUNET_SYSERR;
- }
- }
-
- if ((namestore_handle != NULL) && (dht_handle != NULL))
- {
- return GNUNET_OK;
- }
-
- return GNUNET_SYSERR;
+ return GNUNET_OK;
}
* @return always GNUNET_YES
*/
static int
-cleanup_pending_ns_tasks(void* cls,
- struct GNUNET_CONTAINER_HeapNode *node,
- void *element,
- GNUNET_CONTAINER_HeapCostType cost)
+cleanup_pending_ns_tasks (void* cls,
+ struct GNUNET_CONTAINER_HeapNode *node,
+ void *element,
+ GNUNET_CONTAINER_HeapCostType cost)
{
- struct NamestoreBGTask *nbg = (struct NamestoreBGTask *)element;
- ResolverCleanupContinuation cont = cls;
+ struct NamestoreBGTask *nbg = element;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_CLEANUP: Terminating ns task\n");
GNUNET_NAMESTORE_cancel (nbg->qe);
- GNUNET_CONTAINER_heap_remove_node(node);
-
- if (GNUNET_CONTAINER_heap_get_size(ns_task_heap) == 0)
- cont();
-
+ GNUNET_CONTAINER_heap_remove_node (node);
return GNUNET_YES;
}
/**
- * Cleanup background lookups FIXME get rid of this??
+ * Cleanup background lookups FIXME get rid of this?? YES this doesn't do
+ * anything! => find in code and remove all references to the heap
*
* @param cls closure to iterator
* @param node heap nodes
void *element,
GNUNET_CONTAINER_HeapCostType cost)
{
- struct ResolverHandle *rh = (struct ResolverHandle *)element;
- ResolverCleanupContinuation cont = cls;
+ struct ResolverHandle *rh = element;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_CLEANUP-%llu: Terminating background lookup for %s\n",
rh->id, rh->name);
-
- //finish_lookup (rh, rh->proc_cls, 0, NULL);
- //rh->get_handle = NULL;
- //rh->proc(rh->proc_cls, rh, 0, NULL);
-
- GNUNET_CONTAINER_heap_remove_node(node);
-
- if (GNUNET_CONTAINER_heap_get_size(dht_lookup_heap) == 0)
+ GNUNET_CONTAINER_heap_remove_node (node);
+ if (0 == GNUNET_CONTAINER_heap_get_size (dht_lookup_heap))
{
- if (GNUNET_CONTAINER_heap_get_size(ns_task_heap) == 0)
- cont();
- else
- {
- GNUNET_CONTAINER_heap_iterate (ns_task_heap,
- &cleanup_pending_ns_tasks,
- cont);
- }
+ GNUNET_CONTAINER_heap_iterate (ns_task_heap,
+ &cleanup_pending_ns_tasks,
+ NULL);
}
-
-
return GNUNET_YES;
}
while (NULL != ac)
{
ac_next = ac->next;
- GNUNET_free(ac);
+ GNUNET_free (ac);
ac = ac_next;
}
GNUNET_NETWORK_socket_close (rh->dns_sock);
if (NULL != rh->dns_resolver_handle)
GNUNET_RESOLVER_request_cancel (rh->dns_resolver_handle);
- GNUNET_free(rh);
+
+ if (NULL != rh->rd.data)
+ GNUNET_free ((void*)(rh->rd.data));
+ GNUNET_free (rh);
}
static void
finish_shorten (struct ResolverHandle *rh,
struct NameShortenHandle *nsh);
+
+
/**
* finish get auth
*
static void
finish_get_auth (struct ResolverHandle *rh,
struct GetNameAuthorityHandle* rlh);
+
+
/**
* Shutdown resolver
*/
void
-gns_resolver_cleanup (ResolverCleanupContinuation cont)
+gns_resolver_cleanup ()
{
unsigned int s;
struct GetPseuAuthorityHandle *tmp;
- struct AuthorityChain *iter;
-
- tmp = gph_head;
- for (tmp = gph_head; tmp != NULL; tmp = gph_head)
+ while (NULL != (tmp = gph_head))
{
if (tmp->get_handle != NULL)
+ {
GNUNET_DHT_get_stop (tmp->get_handle);
- tmp->get_handle = NULL;
+ tmp->get_handle = NULL;
+ }
if (tmp->timeout != GNUNET_SCHEDULER_NO_TASK)
+ {
GNUNET_SCHEDULER_cancel (tmp->timeout);
- tmp->timeout = GNUNET_SCHEDULER_NO_TASK;
-
+ tmp->timeout = GNUNET_SCHEDULER_NO_TASK;
+ }
if (NULL != tmp->namestore_task)
- GNUNET_NAMESTORE_cancel (tmp->namestore_task);
- tmp->namestore_task = NULL;
-
- iter = tmp->ahead;
- do
{
- iter = tmp->ahead->next;
- GNUNET_free (tmp->ahead);
- tmp->ahead = iter;
- } while (iter != NULL);
-
- GNUNET_CRYPTO_rsa_key_free (tmp->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, tmp);
- GNUNET_free (tmp);
+ 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);
}
- s = GNUNET_CONTAINER_heap_get_size(dht_lookup_heap);
+ s = GNUNET_CONTAINER_heap_get_size (dht_lookup_heap);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_CLEANUP: %d pending background queries to terminate\n", s);
if (0 != s)
GNUNET_CONTAINER_heap_iterate (dht_lookup_heap,
&cleanup_pending_background_queries,
- cont);
- else if (0 != GNUNET_CONTAINER_heap_get_size(ns_task_heap))
+ NULL);
+ else if (0 != GNUNET_CONTAINER_heap_get_size (ns_task_heap))
{
GNUNET_CONTAINER_heap_iterate (ns_task_heap,
&cleanup_pending_ns_tasks,
- cont);
+ NULL);
}
- else
- cont();
}
-
-
/**
* Callback when record data is put into namestore
*
* @param emsg the error message. NULL if SUCCESS==GNUNET_OK
*/
void
-on_namestore_record_put_result(void *cls,
- int32_t success,
- const char *emsg)
+on_namestore_record_put_result (void *cls,
+ int32_t success,
+ const char *emsg)
{
struct NamestoreBGTask *nbg = cls;
"GNS_NS: Error putting records into namestore: %s\n", emsg);
}
+
+/**
+ * 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)
+handle_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ResolverHandle *rh = cls;
- if (rh->timeout_cont)
- rh->timeout_cont(rh->timeout_cont_cls, tc);
+ if (NULL != rh->timeout_cont)
+ rh->timeout_cont (rh->timeout_cont_cls, tc);
}
+
/**
* Processor for background lookups in the DHT
*
* @param rd record data
*/
static void
-background_lookup_result_processor(void *cls,
+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);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_BG: background dht lookup finished. (%d results)\n",
+ rd_count);
}
+
/**
* Handle timeout for DHT requests
*
* @param tc the task context
*/
static void
-dht_lookup_timeout(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+dht_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ResolverHandle *rh = cls;
- struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls;
+ struct RecordLookupHandle *rlh = rh->proc_cls;
char new_name[MAX_DNS_NAME_LENGTH];
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: dht lookup for query %s (%ds)timed out.\n",
- rh->id, rh->name, rh->timeout.rel_value);
+ 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
*/
- //strcpy(new_name, rh->name);
- //memcpy(new_name+strlen(new_name), GNUNET_GNS_TLD, strlen(GNUNET_GNS_TLD));
- GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
- rh->name, GNUNET_GNS_TLD);
+ GNUNET_snprintf (new_name, MAX_DNS_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,
- rh->priv_key,
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_NO,
- &background_lookup_result_processor,
- NULL);
+ 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);
+ rh->proc (rh->proc_cls, rh, 0, NULL);
}
* @param data the record data
*/
static void
-process_record_result_dht(void* cls,
- struct GNUNET_TIME_Absolute exp,
- const struct GNUNET_HashCode * key,
- const struct GNUNET_PeerIdentity *get_path,
- unsigned int get_path_length,
- const struct GNUNET_PeerIdentity *put_path,
- unsigned int put_path_length,
- enum GNUNET_BLOCK_Type type,
- size_t size, const void *data)
+process_record_result_dht (void* cls,
+ struct GNUNET_TIME_Absolute exp,
+ const struct GNUNET_HashCode * key,
+ const struct GNUNET_PeerIdentity *get_path,
+ unsigned int get_path_length,
+ const struct GNUNET_PeerIdentity *put_path,
+ unsigned int put_path_length,
+ enum GNUNET_BLOCK_Type type,
+ size_t size, const void *data)
{
struct ResolverHandle *rh;
struct RecordLookupHandle *rlh;
int rd_size;
rh = (struct ResolverHandle *)cls;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: got dht result (size=%d)\n", rh->id, size);
-
- //FIXME maybe check expiration here, check block type
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: got dht result (size=%d)\n", rh->id, size);
rlh = (struct RecordLookupHandle *) rh->proc_cls;
nrb = (struct GNSNameRecordBlock*)data;
if (rh->dht_heap_node != NULL)
{
- GNUNET_CONTAINER_heap_remove_node(rh->dht_heap_node);
+ GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
rh->dht_heap_node = NULL;
}
if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
- GNUNET_SCHEDULER_cancel(rh->timeout_task);
+ GNUNET_SCHEDULER_cancel (rh->timeout_task);
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
rh->get_handle = NULL;
name = (char*)&nrb[1];
- num_records = ntohl(nrb->rd_count);
+ num_records = ntohl (nrb->rd_count);
{
struct GNUNET_NAMESTORE_RecordData rd[num_records];
struct NamestoreBGTask *ns_heap_root;
struct NamestoreBGTask *namestore_bg_task;
- rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock);
- rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock);
+ 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_PHASE_REC-%llu: Error deserializing data!\n", rh->id);
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "GNS_PHASE_REC-%llu: Error deserializing data!\n", rh->id);
+ rh->proc (rh->proc_cls, rh, 0, NULL);
return;
}
for (i=0; i<num_records; i++)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Got name: %s (wanted %s)\n",
- rh->id, name, rh->name);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Got type: %d (wanted %d)\n",
- rh->id, rd[i].record_type, rlh->record_type);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Got data length: %d\n",
- rh->id, rd[i].data_size);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Got flag %d\n",
- rh->id, rd[i].flags);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Got name: %s (wanted %s)\n",
+ rh->id, name, rh->name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Got type: %d (wanted %d)\n",
+ rh->id, rd[i].record_type, rlh->record_type);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Got data length: %d\n",
+ rh->id, rd[i].data_size);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Got flag %d\n",
+ rh->id, rd[i].flags);
- if ((strcmp(name, rh->name) == 0) &&
+ if ((strcmp (name, rh->name) == 0) &&
(rd[i].record_type == rlh->record_type))
{
rh->answered++;
ns_heap_root = GNUNET_CONTAINER_heap_remove_root (ns_task_heap);
GNUNET_NAMESTORE_cancel (ns_heap_root->qe);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Replacing oldest background ns task\n",
- rh->id);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Replacing oldest background ns task\n",
+ rh->id);
}
/* Save to namestore */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Caching record for %s\n",
+ rh->id, name);
namestore_bg_task = GNUNET_malloc (sizeof (struct NamestoreBGTask));
namestore_bg_task->qe = GNUNET_NAMESTORE_record_put (namestore_handle,
&nrb->public_key,
GNUNET_TIME_absolute_get().abs_value);
- if (rh->answered)
- rh->proc(rh->proc_cls, rh, num_records, rd);
+ if (0 < rh->answered)
+ rh->proc (rh->proc_cls, rh, num_records, rd);
else
- rh->proc(rh->proc_cls, rh, 0, NULL);
+ rh->proc (rh->proc_cls, rh, 0, NULL);
}
}
resolve_record_dht (struct ResolverHandle *rh)
{
uint32_t xquery;
- struct GNUNET_CRYPTO_ShortHashCode name_hash;
struct GNUNET_HashCode lookup_key;
- struct GNUNET_HashCode name_hash_double;
- struct GNUNET_HashCode zone_hash_double;
- struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string;
- struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls;
+ struct RecordLookupHandle *rlh = rh->proc_cls;
struct ResolverHandle *rh_heap_root;
- GNUNET_CRYPTO_short_hash(rh->name, strlen(rh->name), &name_hash);
- GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
- GNUNET_CRYPTO_short_hash_double(&rh->authority, &zone_hash_double);
- GNUNET_CRYPTO_hash_xor(&name_hash_double, &zone_hash_double, &lookup_key);
- GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string);
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: starting dht lookup for %s with key: %s\n",
- rh->id, rh->name, (char*)&lookup_key_string);
+ GNUNET_GNS_get_key_for_record (rh->name, &rh->authority, &lookup_key);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: starting dht lookup for %s with key: %s\n",
+ rh->id, rh->name, GNUNET_h2s (&lookup_key));
- //rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
rh->dht_heap_node = NULL;
- if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+ if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value != rh->timeout.rel_value)
{
/**
* Update timeout if necessary
*/
- if (rh->timeout_task == GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK == rh->timeout_task)
{
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Adjusting timeout\n", rh->id);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Adjusting timeout\n", rh->id);
/*
* Set timeout for authority lookup phase to 1/2
*/
- rh->timeout_task = GNUNET_SCHEDULER_add_delayed(
- GNUNET_TIME_relative_divide(rh->timeout, 2),
- &handle_lookup_timeout,
- rh);
+ rh->timeout_task = GNUNET_SCHEDULER_add_delayed (
+ GNUNET_TIME_relative_divide (rh->timeout, 2),
+ &handle_lookup_timeout,
+ rh);
}
- //rh->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
- // &dht_lookup_timeout,
- // rh);
rh->timeout_cont = &dht_lookup_timeout;
rh->timeout_cont_cls = rh;
}
GNUNET_CONTAINER_heap_get_size (dht_lookup_heap))
{
rh_heap_root = GNUNET_CONTAINER_heap_remove_root (dht_lookup_heap);
- GNUNET_DHT_get_stop(rh_heap_root->get_handle);
+ GNUNET_DHT_get_stop (rh_heap_root->get_handle);
rh_heap_root->get_handle = NULL;
rh_heap_root->dht_heap_node = NULL;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Replacing oldest background query for %s\n",
rh->id, rh_heap_root->name);
- rh_heap_root->proc(rh_heap_root->proc_cls,
- rh_heap_root,
- 0,
- NULL);
+ rh_heap_root->proc (rh_heap_root->proc_cls,
+ rh_heap_root,
+ 0,
+ NULL);
}
rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap,
- rh,
- GNUNET_TIME_absolute_get().abs_value);
+ rh,
+ GNUNET_TIME_absolute_get ().abs_value);
}
- xquery = htonl(rlh->record_type);
+ xquery = htonl (rlh->record_type);
- GNUNET_assert(rh->get_handle == NULL);
- rh->get_handle = GNUNET_DHT_get_start(dht_handle,
- GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
- &lookup_key,
- DHT_GNS_REPLICATION_LEVEL,
- GNUNET_DHT_RO_NONE,
- &xquery,
- sizeof(xquery),
- &process_record_result_dht,
- rh);
+ GNUNET_assert (rh->get_handle == NULL);
+ rh->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_record_result_dht,
+ rh);
}
struct GNUNET_TIME_Absolute et;
unsigned int i;
- rh = (struct ResolverHandle *) cls;
- rlh = (struct RecordLookupHandle *)rh->proc_cls;
+ rh = cls;
+ rlh = rh->proc_cls;
rh->namestore_task = NULL;
- GNUNET_CRYPTO_short_hash(key,
- sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
- &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)
{
rh->status |= RSL_RECORD_EXISTS;
return;
}
- else
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Processing additional result %s from namestore\n",
+ rh->id, name);
+ for (i=0; i<rd_count;i++)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Processing additional result %s from namestore\n",
- rh->id, name);
- for (i=0; i<rd_count;i++)
- {
- if (rd[i].record_type != rlh->record_type)
- continue;
-
- if (ignore_pending_records &&
- (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Record %s is awaiting user confirmation. Skipping\n",
- rh->id, name);
- continue;
- }
+ if (rd[i].record_type != rlh->record_type)
+ 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_REC-%llu: This record is expired. Skipping\n",
- rh->id);
- continue;
- }
- rh->answered++;
+ if (ignore_pending_records &&
+ (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Record %s is awaiting user confirmation. Skipping\n",
+ rh->id, name);
+ continue;
}
-
- /**
- * no answers found
- */
- if (rh->answered == 0)
+
+ //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)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: No answers found. This is odd!\n", rh->id);
- rh->proc(rh->proc_cls, rh, 0, NULL);
- return;
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: This record is expired. Skipping\n",
+ rh->id);
+ continue;
}
+ rh->answered++;
+ }
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Found %d answer(s) to query in %d records!\n",
- rh->id, rh->answered, rd_count);
-
- rh->proc(rh->proc_cls, rh, rd_count, rd);
+ /**
+ * no answers found
+ */
+ if (0 == rh->answered)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: No answers found. This is odd!\n", rh->id);
+ rh->proc(rh->proc_cls, rh, 0, NULL);
+ return;
}
+
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Found %d answer(s) to query in %d records!\n",
+ rh->id, rh->answered, rd_count);
+ rh->proc(rh->proc_cls, rh, rd_count, rd);
}
struct RecordLookupHandle *rlh;
struct GNUNET_NAMESTORE_RecordData rd;
- rlh = (struct RecordLookupHandle *)rh->proc_cls;
+ rlh = rh->proc_cls;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC_VPN-%llu: Got answer from VPN to query!\n",
rh->id);
- if (af == AF_INET)
+ if (AF_INET == af)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Answer is IPv4!\n",
rh->id);
- if (rlh->record_type != GNUNET_GNS_RECORD_A)
+ if (GNUNET_GNS_RECORD_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, 1, &rd);
return;
}
- else if (af == AF_INET6)
+ else if (AF_INET6 == af)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Answer is IPv6!\n",
rh->id);
- if (rlh->record_type != GNUNET_GNS_RECORD_AAAA)
+ if (GNUNET_GNS_RECORD_AAAA != rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Requested record is not IPv6!\n",
}
-
-
/**
* Process VPN lookup result for record
*
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct RecordLookupHandle* rlh = (struct RecordLookupHandle*) cls;
+ struct RecordLookupHandle* rlh = cls;
- if (rd_count == 0)
+ if (0 == rd_count)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC_VPN-%llu: VPN returned no records. (status: %d)!\n",
send_dns_packet (struct ResolverHandle *rh);
+/**
+ * Read DNS response
+ *
+ * @param cls the ResolverHandle for this lookup
+ * @param addr the sockaddr
+ * @param addrlen the socket address length
+ */
static void
handle_dns_resolver (void *cls,
const struct sockaddr *addr,
return;
}
- if (addrlen == sizeof (struct sockaddr_in))
+ if (sizeof (struct sockaddr_in) == addrlen)
{
sai = (struct sockaddr_in*) addr;
rd.record_type = GNUNET_GNS_RECORD_A;
rd.data_size = sizeof (struct in_addr);
rd.data = &sai->sin_addr;
}
- else
+ else if (sizeof (struct sockaddr_in6) == addrlen)
{
sai6 = (struct sockaddr_in6*) addr;
rd.record_type = GNUNET_GNS_RECORD_AAAA;
rd.data_size = sizeof (struct in6_addr);
rd.data = &sai6->sin6_addr;
}
-
+ else
+ {
+ 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);
-
}
/**
struct RecordLookupHandle *rlh = rh->proc_cls;
int af;
- if ((rlh->record_type != GNUNET_GNS_RECORD_A) &&
- (rlh->record_type != GNUNET_GNS_RECORD_AAAA))
+ 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");
return;
}
- if (rlh->record_type == GNUNET_GNS_RECORD_A)
+ if (GNUNET_GNS_RECORD_A == rlh->record_type)
af = AF_INET;
else
af = AF_INET6;
- //GNUNET_RESOLVER_connect (cfg); FIXME into init
-
rh->dns_resolver_handle = GNUNET_RESOLVER_ip_get (rh->dns_name,
af,
rh->timeout,
);
strcpy (rh->dns_name, packet->answers[i].data.hostname);
found_cname = GNUNET_YES;
- //send_dns_packet (rh);
- //GNUNET_DNSPARSER_free_packet (packet);
continue;
}
for (i = 0; i < packet->num_additional_records; i++)
{
- if (found_delegation == GNUNET_NO)
+ if (GNUNET_NO == found_delegation)
break;
if ((packet->additional_records[i].type == GNUNET_GNS_RECORD_A) &&
return;
}
+
/**
* Sends a UDP dns query to a nameserver specified in the rh
*
"Sending %dbyte DNS query\n",
rh->dns_raw_packet_size);
- 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));
+ 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?
}
+
/**
* The final phase of resoution.
* We found a NS RR and want to resolve via DNS
struct RecordLookupHandle *rlh = rh->proc_cls;
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 (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
{
GNUNET_SCHEDULER_cancel(rh->timeout_task);
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
/* Start shortening */
- if ((rh->priv_key != NULL) && is_canonical (rh->name))
+ 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_tail,
+ start_shorten (rh->authority_chain_head,
rh->priv_key);
}
for (i = 0; i < rd_count; i++)
{
/* Synthesize dns name */
- if (rd[i].record_type == GNUNET_GNS_RECORD_NS)
+ if (GNUNET_GNS_RECORD_NS == rd[i].record_type)
{
strcpy (rh->dns_zone, (char*)rd[i].data);
if (0 == strcmp (rh->name, ""))
sprintf (rh->dns_name, "%s.%s", rh->name, (char*)rd[i].data);
}
/* The glue */
- if (rd[i].record_type == GNUNET_GNS_RECORD_A)
- dnsip = *((struct in_addr*)rd[i].data);
+ 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));
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
rh->dns_name,
inet_ntoa (dnsip));
rh->dns_sock = GNUNET_NETWORK_socket_create (AF_INET, SOCK_DGRAM, 0);
- if (rh->dns_sock == NULL)
+ if (NULL == rh->dns_sock)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC_DNS-%llu: Error creating udp socket for dns!\n",
finish_lookup (rh, rlh, 0, NULL);
return;
}
-
- /*TODO create dnsparser query, serialize, sendto, handle reply*/
query.name = rh->dns_name;
query.type = rlh->record_type;
query.class = GNUNET_DNSPARSER_CLASS_INTERNET;
int af;
/* We cancel here as to not include the ns lookup in the timeout */
- if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
{
GNUNET_SCHEDULER_cancel(rh->timeout_task);
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
/* Start shortening */
- if ((rh->priv_key != NULL) && is_canonical (rh->name))
+ if ((NULL != rh->priv_key) &&
+ (GNUNET_YES == is_canonical (rh->name)))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC_VPN-%llu: Trying to shorten authority chain\n",
rh->id);
- start_shorten (rh->authority_chain_tail,
+ start_shorten (rh->authority_chain_head,
rh->priv_key);
}
(char*)&vpn[1],
GNUNET_h2s (&serv_desc));
rh->proc = &handle_record_vpn;
-
+ if (GNUNET_GNS_RECORD_A == rlh->record_type)
+ af = AF_INET;
+ else
+ af = AF_INET6;
if (NULL == vpn_handle)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_VPN-%llu: VPN not connected!\n",
- rh->id);
- finish_lookup (rh, rh->proc_cls, 0, NULL);
- return;
+ vpn_handle = GNUNET_VPN_connect (cfg);
+ if (NULL == vpn_handle)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_INIT: Error connecting to VPN!\n");
+ finish_lookup (rh, rh->proc_cls, 0, NULL);
+ return;
+ }
}
- if (rlh->record_type == GNUNET_GNS_RECORD_A)
- af = AF_INET;
- else
- af = AF_INET6;
-
- //FIXME timeout??
rh->vpn_handle = GNUNET_VPN_redirect_to_peer (vpn_handle,
- af, ntohs (vpn->proto),
- (struct GNUNET_PeerIdentity *)&vpn->peer,
- &serv_desc,
- GNUNET_NO, //nac
- GNUNET_TIME_UNIT_FOREVER_ABS, //FIXME
- &process_record_result_vpn,
- rh);
-
+ af, ntohs (vpn->proto),
+ (struct GNUNET_PeerIdentity *)&vpn->peer,
+ &serv_desc,
+ GNUNET_NO, //nac
+ GNUNET_TIME_UNIT_FOREVER_ABS, //FIXME
+ &process_record_result_vpn,
+ rh);
}
+
/**
* The final phase of resolution.
* rh->name is a name that is canonical and we do not have a delegation.
struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls;
/* We cancel here as to not include the ns lookup in the timeout */
- if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
{
GNUNET_SCHEDULER_cancel(rh->timeout_task);
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
/* Start shortening */
- if ((rh->priv_key != NULL) && is_canonical (rh->name))
+ if ((NULL != rh->priv_key) &&
+ (GNUNET_YES == is_canonical (rh->name)))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Trying to shorten authority chain\n",
rh->id);
- start_shorten (rh->authority_chain_tail,
+ start_shorten (rh->authority_chain_head,
rh->priv_key);
}
}
-
/**
* Handle timeout for DHT requests
*
char new_name[MAX_DNS_NAME_LENGTH];
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_DHT-%llu: dht lookup for query %s (%ds)timed out.\n",
+ "GNS_PHASE_DELEGATE_DHT-%llu: dht lookup for query %s (%llus)timed out.\n",
rh->id, rh->authority_name, rh->timeout.rel_value);
rh->status |= RSL_TIMED_OUT;
-
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-
- GNUNET_DHT_get_stop (rh->get_handle);
+ if (NULL != rh->get_handle)
+ GNUNET_DHT_get_stop (rh->get_handle);
+
rh->get_handle = NULL;
-
if (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
return;
}
- if (strcmp(rh->name, "") == 0)
+ if (0 == strcmp(rh->name, ""))
{
/*
* promote authority back to name and try to resolve record
/**
* Start resolution in bg
*/
- GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH,
- "%s.%s.%s", rh->name, rh->authority_name, GNUNET_GNS_TLD);
- //strcpy(new_name, rh->name);
- //strcpy(new_name+strlen(new_name), ".");
- //memcpy(new_name+strlen(new_name), GNUNET_GNS_TLD, strlen(GNUNET_GNS_TLD));
+ GNUNET_assert (0 < GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH,
+ "%s.%s.%s", rh->name, rh->authority_name, GNUNET_GNS_TLD));
strcpy(rh->name, new_name);
"GNS_PHASE_DELEGATE_DHT-%llu: Starting background query for %s type %d\n",
rh->id, rh->name, rlh->record_type);
- gns_resolver_lookup_record(rh->authority,
- rh->private_local_zone,
- rlh->record_type,
- new_name,
- rh->priv_key,
- GNUNET_TIME_UNIT_FOREVER_REL,
- GNUNET_NO,
- &background_lookup_result_processor,
- NULL);
-
+ 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->proc(rh->proc_cls, rh, 0, NULL);
}
-/* Prototype */
+
+/**
+ * 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);
-/* Prototype */
+
+/**
+ * Resolve the delegation chain for the request in our namestore
+ *
+ * @param rh the resolver handle
+ */
static void resolve_delegation_ns(struct ResolverHandle *rh);
for (i = 0; i < rd_count; i++)
{
- if (rd[i].record_type == GNUNET_GNS_RECORD_REV)
+ if (GNUNET_GNS_RECORD_REV == rd[i].record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_REV-%llu: Zone has been revoked.\n",
}
}
- if ((name == NULL) ||
- (remaining_time.rel_value == 0))
+ if ((NULL == name) ||
+ (0 == remaining_time.rel_value))
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_REV-%llu: + Records don't exist or are expired.\n",
rh->id, name);
- if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
+ if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value != rh->timeout.rel_value)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_REV-%llu: Starting background lookup for %s type %d\n",
- rh->id, "+.gnunet", GNUNET_GNS_RECORD_REV);
+ rh->id, "+.gads", GNUNET_GNS_RECORD_REV);
gns_resolver_lookup_record(rh->authority,
rh->private_local_zone,
GNUNET_GNS_RECORD_REV,
GNUNET_GNS_TLD,
- rh->priv_key,
+ NULL,
GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_NO,
&background_lookup_result_processor,
* else resolve again with new authority
*/
if (strcmp (rh->name, "") == 0)
- rh->proc (rh->proc_cls, rh, 0, NULL);
+ rh->proc (rh->proc_cls, rh, rh->rd_count, &rh->rd);
else
resolve_delegation_ns (rh);
- return;
}
"GNS_NS: Error putting records into namestore: %s\n", emsg);
}
+
/**
* Function called when we get a result from the dht
* for our query. Recursively tries to resolve authorities
enum GNUNET_BLOCK_Type type,
size_t size, const void *data)
{
- struct ResolverHandle *rh;
+ struct ResolverHandle *rh = cls;
struct GNSNameRecordBlock *nrb;
uint32_t num_records;
char* name = NULL;
char* rd_data = (char*) data;
- int i;
+ uint32_t i;
int rd_size;
- struct GNUNET_CRYPTO_ShortHashCode zone, name_hash;
- struct GNUNET_HashCode zone_hash_double, name_hash_double;
+ struct GNUNET_CRYPTO_ShortHashCode zone;
- rh = (struct ResolverHandle *)cls;
-
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Got DHT result\n", rh->id);
/* stop dht lookup and timeout task */
GNUNET_DHT_get_stop (rh->get_handle);
-
rh->get_handle = NULL;
-
if (rh->dht_heap_node != NULL)
{
GNUNET_CONTAINER_heap_remove_node(rh->dht_heap_node);
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,
"GNS_PHASE_DELEGATE_DHT-%llu: Got flag %d\n",
rh->id, rd[i].flags);
- if ((rd[i].record_type == GNUNET_GNS_RECORD_VPN) ||
- (rd[i].record_type == GNUNET_GNS_RECORD_NS) ||
- (rd[i].record_type == GNUNET_GNS_RECORD_CNAME))
+ 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))
{
/**
* This is a VPN,NS,CNAME entry. Let namestore handle this after caching
*/
- if (strcmp(rh->name, "") == 0)
+ if (0 == strcmp(rh->name, ""))
strcpy(rh->name, rh->authority_name);
else
GNUNET_snprintf(rh->name, MAX_DNS_NAME_LENGTH, "%s.%s",
break;
}
- if ((strcmp(name, rh->authority_name) == 0) &&
- (rd[i].record_type == GNUNET_GNS_RECORD_PKEY))
+ if ((0 == strcmp(name, rh->authority_name)) &&
+ (GNUNET_GNS_RECORD_PKEY == rd[i].record_type))
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Authority found in DHT\n",
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;
+
/** try to import pkey if private key available */
//if (rh->priv_key && is_canonical (rh->name))
// process_discovered_authority(name, auth->zone,
}
}
+ GNUNET_GNS_get_zone_from_key (name, key, &zone);
- GNUNET_CRYPTO_short_hash(name, strlen(name), &name_hash);
- GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
- GNUNET_CRYPTO_hash_xor(key, &name_hash_double, &zone_hash_double);
- GNUNET_CRYPTO_short_hash_from_truncation (&zone_hash_double, &zone);
-
- /* Save to namestore */
- if (0 != GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_tail->zone,
+ /* Save to namestore
+ if (0 != GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
&zone))
- {
+ {*/
if (max_allowed_ns_tasks <=
GNUNET_CONTAINER_heap_get_size (ns_task_heap))
{
GNUNET_NAMESTORE_cancel (ns_heap_root->qe);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Replacing oldest background ns task\n",
+ "GNS_PHASE_DELEGATE_DHT-%llu: Replacing oldest background ns task\n",
rh->id);
}
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_DHT-%llu: Caching record for %s\n",
+ rh->id, name);
namestore_bg_task = GNUNET_malloc (sizeof (struct NamestoreBGTask));
namestore_bg_task->node = GNUNET_CONTAINER_heap_insert (ns_task_heap,
&on_namestore_delegation_put_result, //cont
namestore_bg_task); //cls
}
- }
+ //}
- if (rh->answered)
+ if (0 != rh->answered)
{
rh->answered = 0;
/**
"GNS_PHASE_DELEGATE_DHT-%llu: Answer from DHT for %s. Yet to resolve: %s\n",
rh->id, rh->authority_name, rh->name);
- if (strcmp(rh->name, "") == 0)
+ if (0 == strcmp(rh->name, ""))
{
/* Start shortening */
- if ((rh->priv_key != NULL) && is_canonical (rh->name))
+ if ((NULL != rh->priv_key) &&
+ (GNUNET_YES == is_canonical (rh->name)))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Trying to shorten authority chain\n",
rh->id);
- start_shorten (rh->authority_chain_tail,
+ start_shorten (rh->authority_chain_head,
rh->priv_key);
}
}
else
rh->proc = &handle_delegation_ns;
+
/* Check for key revocation and delegate */
rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
&rh->authority,
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Adding %s back to %s\n",
rh->id, rh->authority_name, rh->name);
- if (strcmp(rh->name, "") == 0)
+ if (0 == strcmp(rh->name, ""))
strcpy(rh->name, rh->authority_name);
else
GNUNET_snprintf(rh->name, MAX_DNS_NAME_LENGTH, "%s.%s",
rh->proc(rh->proc_cls, rh, 0, NULL);
}
+//FIXME maybe define somewhere else?
#define MAX_SOA_LENGTH sizeof(uint32_t)+sizeof(uint32_t)+sizeof(uint32_t)+sizeof(uint32_t)\
+(MAX_DNS_NAME_LENGTH*2)
#define MAX_MX_LENGTH sizeof(uint16_t)+MAX_DNS_NAME_LENGTH
#define MAX_SRV_LENGTH (sizeof(uint16_t)*3)+MAX_DNS_NAME_LENGTH
+/**
+ * Exands a name ending in .+ with the zone of origin.
+ * FIXME: funky api: 'dest' must be large enough to hold
+ * the result; this is a bit yucky...
+ *
+ * @param dest destination buffer
+ * @param src the .+ name
+ * @param repl the string to replace the + with
+ */
static void
-expand_plus(char* dest, char* src, char* repl)
+expand_plus (char* dest,
+ const char* src,
+ const char* repl)
{
char* pos;
- unsigned int s_len = strlen(src)+1;
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_POSTPROCESS: Got %s to expand with %s\n", src, repl);
+ size_t s_len = strlen (src) + 1;
- if (s_len < 3)
+ //Eh? I guess this is at least strlen ('x.+') == 3 FIXME
+ if (3 > s_len)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_POSTPROCESS: %s to short\n", src);
-
/* no postprocessing */
- memcpy(dest, src, s_len+1);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_POSTPROCESS: %s too short\n", src);
+ memcpy (dest, src, s_len);
return;
}
-
- if (0 == strcmp(src+s_len-3, ".+"))
+ if (0 == strcmp (src + s_len - 3, ".+"))
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_POSTPROCESS: Expanding .+ in %s\n", src);
- memset(dest, 0, s_len+strlen(repl)+strlen(GNUNET_GNS_TLD));
- strcpy(dest, src);
- pos = dest+s_len-2;
- strcpy(pos, repl);
- pos += strlen(repl);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_POSTPROCESS: Expanded to %s\n", dest);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_POSTPROCESS: Expanding .+ in %s\n",
+ src);
+ memset (dest, 0, s_len + strlen (repl) + strlen(GNUNET_GNS_TLD));
+ strcpy (dest, src);
+ pos = dest + s_len - 2;
+ strcpy (pos, repl);
+ pos += strlen (repl);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_POSTPROCESS: Expanded to %s\n",
+ dest);
}
else
{
- memcpy(dest, src, s_len+1);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_POSTPROCESS: No postprocessing for %s\n", src);
+ memcpy (dest, src, s_len);
}
}
+
/**
* finish lookup
*/
char* pos;
unsigned int offset;
- if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+ if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
{
GNUNET_SCHEDULER_cancel(rh->timeout_task);
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh);
- if (rd_count > 0)
+ if (0 < rd_count)
memcpy(p_rd, rd, rd_count*sizeof(struct GNUNET_NAMESTORE_RecordData));
for (i = 0; i < rd_count; i++)
{
- if (rd[i].record_type != 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)
+ 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))
{
p_rd[i].data = rd[i].data;
continue;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_POSTPROCESS: Postprocessing\n");
-
- if (strcmp(rh->name, "+") == 0)
+ if (0 == strcmp(rh->name, "+"))
repl_string = rlh->name;
else
repl_string = rlh->name+strlen(rh->name)+1;
offset = 0;
- if (rd[i].record_type == GNUNET_GNS_RECORD_MX)
+ if (GNUNET_GNS_RECORD_MX == rd[i].record_type)
{
memcpy (new_mx_data, (char*)rd[i].data, sizeof(uint16_t));
- offset = sizeof(uint16_t);
- pos = new_mx_data+offset;
- expand_plus(pos, (char*)rd[i].data+sizeof(uint16_t),
- repl_string);
- offset += strlen(new_mx_data+sizeof(uint16_t))+1;
+ offset = sizeof (uint16_t);
+ pos = new_mx_data + offset;
+ // FIXME: how do we know that 'pos' has enough space for the new name?
+ expand_plus (pos, (char*)rd[i].data+sizeof(uint16_t),
+ repl_string);
+ offset += strlen(new_mx_data+sizeof(uint16_t)) + 1;
p_rd[i].data = new_mx_data;
p_rd[i].data_size = offset;
}
- else if (rd[i].record_type == GNUNET_GNS_RECORD_SRV)
+ else if (GNUNET_GNS_RECORD_SRV == rd[i].record_type)
{
/*
* Prio, weight and port
new_srv->prio = old_srv->prio;
new_srv->weight = old_srv->weight;
new_srv->port = old_srv->port;
+ // FIXME: how do we know that '&new_srv[1]' has enough space for the new name?
expand_plus((char*)&new_srv[1], (char*)&old_srv[1],
repl_string);
p_rd[i].data = new_srv_data;
p_rd[i].data_size = sizeof (struct srv_data) + strlen ((char*)&new_srv[1]) + 1;
}
- else if (rd[i].record_type == GNUNET_GNS_RECORD_SOA)
+ else if (GNUNET_GNS_RECORD_SOA == rd[i].record_type)
{
/* expand mname and rname */
old_soa = (struct soa_data*)rd[i].data;
new_soa = (struct soa_data*)new_soa_data;
memcpy (new_soa, old_soa, sizeof (struct soa_data));
+ // FIXME: how do we know that 'new_soa[1]' has enough space for the new name?
expand_plus((char*)&new_soa[1], (char*)&old_soa[1], repl_string);
offset = strlen ((char*)&new_soa[1]) + 1;
+ // FIXME: how do we know that 'new_soa[1]' has enough space for the new name?
expand_plus((char*)&new_soa[1] + offset,
(char*)&old_soa[1] + strlen ((char*)&old_soa[1]) + 1,
repl_string);
else
{
pos = new_rr_data;
+ // FIXME: how do we know that 'rd[i].data' has enough space for the new name?
expand_plus(pos, (char*)rd[i].data, repl_string);
p_rd[i].data_size = strlen(new_rr_data)+1;
p_rd[i].data = new_rr_data;
free_resolver_handle (rh);
}
+
/**
* Process DHT lookup result for record.
*
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct RecordLookupHandle* rlh;
+ struct RecordLookupHandle* rlh = cls;
- rlh = (struct RecordLookupHandle*)cls;
- if (rd_count == 0)
+ if (0 == rd_count)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: No records for %s found in DHT. Aborting\n",
rh->id, rh->name);
/* give up, cannot resolve */
- finish_lookup(rh, rlh, 0, NULL);
+ finish_lookup (rh, rlh, 0, NULL);
return;
}
-
/* results found yay */
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Record resolved from DHT!", rh->id);
-
- finish_lookup(rh, rlh, rd_count, rd);
-
+ finish_lookup (rh, rlh, rd_count, rd);
}
-
-
/**
* Process namestore lookup result for record.
*
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct RecordLookupHandle* rlh;
- rlh = (struct RecordLookupHandle*) cls;
+ struct RecordLookupHandle* rlh = cls;
int check_dht = GNUNET_YES;
-
- if (rd_count == 0)
+
+ if (0 != rd_count)
+ {
+ /* results found yay */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Record resolved from namestore!\n", rh->id);
+ finish_lookup (rh, rlh, rd_count, rd);
+ return;
+ }
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: NS returned no records. (status: %d)!\n",
+ rh->id,
+ rh->status);
+ /**
+ * There are 5 conditions that have to met for us to consult the DHT:
+ * 1. The entry in the DHT is RSL_RECORD_EXPIRED OR
+ * 2. No entry in the NS existed AND
+ * 3. The zone queried is not the local resolver's zone AND
+ * 4. The name that was looked up is '+'
+ * because if it was any other canonical name we either already queried
+ * the DHT for the authority in the authority lookup phase (and thus
+ * would already have an entry in the NS for the record)
+ * 5. We are not in cache only mode
+ */
+ if ((0 != (rh->status & RSL_RECORD_EXPIRED)) &&
+ (0 == (rh->status & RSL_RECORD_EXISTS)) )
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: NS returned no records. (status: %d)!\n",
- rh->id,
- rh->status);
-
- /**
- * There are 5 conditions that have to met for us to consult the DHT:
- * 1. The entry in the DHT is RSL_RECORD_EXPIRED OR
- * 2. No entry in the NS existed AND
- * 3. The zone queried is not the local resolver's zone AND
- * 4. The name that was looked up is '+'
- * because if it was any other canonical name we either already queried
- * the DHT for the authority in the authority lookup phase (and thus
- * would already have an entry in the NS for the record)
- * 5. We are not in cache only mode
- */
- if (((rh->status & RSL_RECORD_EXPIRED) != 0) &&
- ((rh->status & RSL_RECORD_EXISTS) == 0) )
- check_dht = GNUNET_NO;
-
- if (0 != GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- &rh->private_local_zone))
- check_dht = GNUNET_NO;
- if ((strcmp (rh->name, "+") != 0) && (is_srv (rh->name) != 0))
- check_dht = GNUNET_NO;
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Not expired and exists!\n",
+ rh->id);
+ check_dht = GNUNET_NO;
+ }
+
+ if (0 == GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
+ &rh->private_local_zone))
+ {
- if (rh->only_cached == GNUNET_YES)
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC-%llu: Our zone!\n",
+ rh->id);
+ check_dht = GNUNET_NO;
+ }
+
+ if ((0 != strcmp (rh->name, "+")) && (GNUNET_YES == is_srv (rh->name)))
check_dht = GNUNET_NO;
-
- if (GNUNET_YES == check_dht)
- {
- rh->proc = &handle_record_dht;
- resolve_record_dht(rh);
- return;
- }
- /* give up, cannot resolve */
- finish_lookup(rh, rlh, 0, NULL);
+
+ if (GNUNET_YES == rh->only_cached)
+ check_dht = GNUNET_NO;
+
+ if (GNUNET_YES == check_dht)
+ {
+ rh->proc = &handle_record_dht;
+ resolve_record_dht(rh);
return;
}
-
- /* results found yay */
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Record resolved from namestore!\n", rh->id);
-
- finish_lookup(rh, rlh, rd_count, rd);
-
-
+ /* give up, cannot resolve */
+ finish_lookup (rh, rlh, 0, NULL);
}
{
uint32_t len;
- if (is_canonical (name))
+ if (GNUNET_YES == is_canonical (name))
{
strcpy(dest, name);
strcpy(name, "");
return;
}
- for (len = strlen(name); len > 0; len--)
+ for (len = strlen(name); 0 < len; len--)
{
if (*(name+len) == '.')
break;
}
//Was canonical?
- if (len == 0)
+ if (0 == len)
return;
name[len] = '\0';
strcpy(dest, (name+len+1));
}
+
/**
* Checks if name is in tld
*
int offset = 0;
if (strlen(name) <= strlen(tld))
- {
return GNUNET_NO;
- }
offset = strlen(name)-strlen(tld);
- if (strcmp(name+offset, tld) != 0)
+ if (0 != strcmp(name+offset, tld))
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"%s is not in .%s TLD\n", name, tld);
return GNUNET_YES;
}
+
/**
* DHT resolution for delegation finished. Processing result.
*
const struct GNUNET_NAMESTORE_RecordData *rd)
{
struct RecordLookupHandle* rlh;
- rlh = (struct RecordLookupHandle*) cls;
+ rlh = cls;
- if (strcmp(rh->name, "") == 0)
+ if (0 == strcmp(rh->name, ""))
{
- if ((rlh->record_type == GNUNET_GNS_RECORD_PKEY))
+ if (GNUNET_GNS_RECORD_PKEY == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Resolved queried PKEY via DHT.\n",
/**
* we still have some left
**/
- if (is_canonical(rh->name))
+ if (GNUNET_YES == is_canonical (rh->name))
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Resolving canonical record %s in ns\n",
resolve_delegation_dht(struct ResolverHandle *rh)
{
uint32_t xquery;
- struct GNUNET_CRYPTO_ShortHashCode name_hash;
- struct GNUNET_HashCode name_hash_double;
- struct GNUNET_HashCode zone_hash_double;
struct GNUNET_HashCode lookup_key;
struct ResolverHandle *rh_heap_root;
- pop_tld(rh->name, rh->authority_name);
- GNUNET_CRYPTO_short_hash(rh->authority_name,
- strlen(rh->authority_name),
- &name_hash);
- GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double);
- GNUNET_CRYPTO_short_hash_double(&rh->authority, &zone_hash_double);
- GNUNET_CRYPTO_hash_xor(&name_hash_double, &zone_hash_double, &lookup_key);
+ pop_tld(rh->name, rh->authority_name);
+
+ GNUNET_GNS_get_key_for_record (rh->authority_name, &rh->authority, &lookup_key);
rh->dht_heap_node = NULL;
if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
{
- //rh->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
- // &dht_authority_lookup_timeout,
- // rh);
rh->timeout_cont = &dht_authority_lookup_timeout;
rh->timeout_cont_cls = rh;
}
}
xquery = htonl(GNUNET_GNS_RECORD_PKEY);
-
GNUNET_assert(rh->get_handle == NULL);
rh->get_handle = GNUNET_DHT_get_start(dht_handle,
GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
&lookup_key,
DHT_GNS_REPLICATION_LEVEL,
- GNUNET_DHT_RO_NONE,
+ GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
&xquery,
sizeof(xquery),
&process_delegation_result_dht,
rh);
-
}
const struct GNUNET_NAMESTORE_RecordData *rd)
{
struct RecordLookupHandle* rlh;
- rlh = (struct RecordLookupHandle*) cls;
+ rlh = cls;
int check_dht = GNUNET_YES;
int s_len = 0;
return;
}
- if (strcmp(rh->name, "") == 0)
+ if (0 == strcmp(rh->name, ""))
{
/* We resolved full name for delegation. resolving record */
rh->id);
if (rh->status & RSL_CNAME_FOUND)
{
- if (rlh->record_type == GNUNET_GNS_RECORD_CNAME)
+ if (GNUNET_GNS_RECORD_CNAME == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried CNAME in NS.\n",
}
/* A .+ CNAME */
- if (is_tld ((char*)rd->data, GNUNET_GNS_TLD_PLUS))
+ if (GNUNET_YES == is_tld ((char*)rd->data, GNUNET_GNS_TLD_PLUS))
{
s_len = strlen (rd->data) - 2;
memcpy (rh->name, rd->data, s_len);
resolve_delegation_ns (rh);
return;
}
- else if (is_tld ((char*)rd->data, GNUNET_GNS_TLD_ZKEY))
+ else if (GNUNET_YES == is_tld ((char*)rd->data, GNUNET_GNS_TLD_ZKEY))
{
gns_resolver_lookup_record (rh->authority,
rh->private_local_zone,
}
else if (rh->status & RSL_DELEGATE_VPN)
{
- if (rlh->record_type == GNUNET_GNS_RECORD_VPN)
+ if (GNUNET_GNS_RECORD_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 (rlh->record_type == GNUNET_GNS_RECORD_NS)
+ if (GNUNET_GNS_RECORD_NS == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried NSRR in NS.\n",
finish_lookup (rh, rlh, 0, NULL);
return;
}
- else if (rlh->record_type == GNUNET_GNS_RECORD_PKEY)
+ else if (GNUNET_GNS_RECORD_PKEY == rlh->record_type)
{
- GNUNET_assert(rd_count == 1);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried PKEY in NS.\n",
rh->id);
if (rh->status & RSL_DELEGATE_NS)
{
- if (rlh->record_type == GNUNET_GNS_RECORD_NS)
+ if (GNUNET_GNS_RECORD_NS == rlh->record_type)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried NSRR in NS.\n",
&rh->private_local_zone))
check_dht = GNUNET_NO;
- if (rh->only_cached == GNUNET_YES)
+ if (GNUNET_YES == rh->only_cached)
check_dht = GNUNET_NO;
- if (check_dht == GNUNET_NO)
+ if (GNUNET_YES == check_dht)
{
- if (is_canonical(rh->name))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Resolving canonical record %s\n",
- rh->id,
- rh->name);
- rh->proc = &handle_record_ns;
- resolve_record_ns(rh);
- }
- else
- {
- /* give up, cannot resolve */
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Cannot fully resolve delegation for %s!\n",
- rh->id,
- rh->name);
- finish_lookup(rh, rlh, rd_count, rd);
- //rlh->proc(rlh->proc_cls, 0, NULL);
- }
+
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Trying to resolve delegation for %s via DHT\n",
+ rh->id, rh->name);
+ rh->proc = &handle_delegation_dht;
+ resolve_delegation_dht(rh);
+ return;
+ }
+
+ if (GNUNET_NO == is_canonical (rh->name))
+ {
+ /* give up, cannot resolve */
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Cannot fully resolve delegation for %s!\n",
+ rh->id,
+ rh->name);
+ finish_lookup(rh, rlh, rd_count, rd);
return;
}
-
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Trying to resolve delegation for %s via DHT\n",
- rh->id, rh->name);
- rh->proc = &handle_delegation_dht;
- resolve_delegation_dht(rh);
+ "GNS_PHASE_DELEGATE_NS-%llu: Resolving canonical record %s\n",
+ rh->id,
+ rh->name);
+ rh->proc = &handle_record_ns;
+ resolve_record_ns(rh);
}
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,
* If we have found some records for the LAST label
* we return the results. Else null.
*/
- if (strcmp(rh->name, "") == 0)
+ if (strcmp (rh->name, "") == 0)
{
/* Start shortening */
- if ((rh->priv_key != NULL) && is_canonical (rh->name))
+ if ((rh->priv_key != NULL) &&
+ (is_canonical (rh->name) == GNUNET_YES))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Trying to shorten authority chain\n",
rh->id);
- start_shorten (rh->authority_chain_tail,
+ start_shorten (rh->authority_chain_head,
rh->priv_key);
}
/* simply promote back */
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n",
- rh->id, rh->authority_name);
- strcpy(rh->name, rh->authority_name);
- rh->proc(rh->proc_cls, rh, rd_count, rd);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n",
+ rh->id, rh->authority_name);
+ strcpy (rh->name, rh->authority_name);
+ rh->proc (rh->proc_cls, rh, rd_count, rd);
}
else
{
- rh->proc(rh->proc_cls, rh, 0, NULL);
+ GNUNET_snprintf (new_name, MAX_DNS_NAME_LENGTH,
+ "%s.%s", rh->name, rh->authority_name);
+ strcpy (rh->name, new_name);
+ rh->proc (rh->proc_cls, rh, 0, NULL);
}
}
name, record_type);
- if (is_canonical((char*)name) && (strcmp(GNUNET_GNS_TLD, name) != 0))
+ if ((is_canonical ((char*)name) == GNUNET_YES) &&
+ (strcmp(GNUNET_GNS_TLD, name) != 0))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"%s is canonical and not gnunet -> cannot resolve!\n", name);
rh->private_local_zone = pzone;
rh->only_cached = only_cached;
rh->namestore_task = NULL;
+ rh->rd.data = NULL;
GNUNET_CONTAINER_DLL_insert (rlh_head, rlh_tail, rh);
if (NULL == key)
- {
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"No shorten key for resolution\n");
- }
if (timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value)
{
&rh->authority))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Cannot convert ZKEY %s to hash!\n", string_hash);
+ "Cannot convert ZKEY `%s' to hash!\n", string_hash);
+ if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
+ GNUNET_SCHEDULER_cancel (rh->timeout_task);
GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh);
GNUNET_free (rh);
GNUNET_free (rlh);
}
}
- else
+ else if (is_gnunet_tld (name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"TLD is gnunet\n");
memcpy (rh->name, name,
strlen(name)-strlen(GNUNET_GNS_TLD) - 1);
}
+ else
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Cannot handle this TLD %s\n", string_hash);
+
+ if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
+ GNUNET_SCHEDULER_cancel (rh->timeout_task);
+ GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh);
+ GNUNET_free (rh);
+ GNUNET_free (rlh);
+ proc (cls, 0, NULL);
+ return;
+ }
}
/**
rh->authority_chain_head->next = NULL;
rh->authority_chain_tail = rh->authority_chain_head;
rh->authority_chain_head->zone = rh->authority;
+ strcpy (rh->authority_chain_head->name, "");
/**
* Copy original query into lookup handle
nsh->shorten_zone) == 0)
{
/**
- * This is our zone append .gnunet unless name is empty
+ * 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??)
*/
* No PSEU found.
* continue with next authority if exists
*/
- if ((rh->authority_chain_head->next == NULL))
+ if (NULL == rh->authority_chain_head->next)
{
finish_shorten (rh, nsh);
return;
}
next_authority = rh->authority_chain_head;
- GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
- "%s.%s", rh->name, next_authority->name);
+ if (0 == strcmp (rh->name, ""))
+ strcpy (tmp_name, next_authority->name);
+ else
+ GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
+ "%s.%s", rh->name, next_authority->name);
strcpy(rh->name, tmp_name);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
rh);
}
+
/**
* Callback calles by namestore for a zone to name
* result
nsh->private_zone) == 0)
{
/**
- * This is our zone append .gnunet unless name is empty
+ * 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??)
*/
* No PSEU found.
* continue with next authority if exists
*/
- if ((rh->authority_chain_head->next == NULL))
+ if (NULL == rh->authority_chain_head->next)
{
finish_shorten (rh, nsh);
return;
}
next_authority = rh->authority_chain_head;
- GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
- "%s.%s", rh->name, next_authority->name);
+ if (0 == strcmp (rh->name, ""))
+ strcpy (tmp_name, next_authority->name);
+ else
+ GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
+ "%s.%s", rh->name, next_authority->name);
strcpy(rh->name, tmp_name);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
}
}
+
/**
* Callback calles by namestore for a zone to name
* result
nsh->root_zone) == 0)
{
/**
- * This is our zone append .gnunet unless name is empty
+ * 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??)
*/
* No PSEU found.
* continue with next authority if exists
*/
- if ((rh->authority_chain_head->next == NULL))
+ if (NULL == rh->authority_chain_head->next)
{
finish_shorten (rh, nsh);
return;
}
next_authority = rh->authority_chain_head;
- GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
- "%s.%s", rh->name, next_authority->name);
+ if (0 == strcmp (rh->name, ""))
+ strcpy (tmp_name, next_authority->name);
+ else
+ GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
+ "%s.%s", rh->name, next_authority->name);
strcpy(rh->name, tmp_name);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
char result[MAX_DNS_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.
"PKEY resolved as far as possible in ns up to %s!\n", rh->name);
memset(result, 0, sizeof (result));
- if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- nsh->root_zone) == 0)
+ if (0 == GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
+ nsh->root_zone))
{
/**
- * This is our zone append .gnunet unless name is empty
+ * 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??)
*/
else if (NULL != nsh->private_zone)
{
/**
- * This is our zone append .gnunet unless name is empty
+ * 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??)
*/
else if (NULL != nsh->shorten_zone)
{
/**
- * This is our zone append .gnunet unless name is empty
+ * 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??)
*/
{
struct ResolverHandle *rh = cls;
struct NameShortenHandle *nsh = rh->proc_cls;
- struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc;
char new_name[MAX_DNS_NAME_LENGTH];
+ rh->namestore_task = NULL;
+
/* zkey not in our zone */
if (name == NULL)
{
* because PKEY import will happen if the user follows the zkey
* link.
*/
- GNUNET_CRYPTO_short_hash_to_enc ((struct GNUNET_CRYPTO_ShortHashCode*)rd,
- &enc);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "No name found for zkey %s returning verbatim!\n", enc);
- if (strcmp(rh->name, "") != 0)
+ "No name found for zkey %s returning verbatim!\n", nsh->result);
+ /*if (strcmp(rh->name, "") != 0)
GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s.%s",
rh->name, enc, GNUNET_GNS_TLD_ZKEY);
else
GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
enc, GNUNET_GNS_TLD_ZKEY);
- strcpy (nsh->result, new_name);
+ strcpy (nsh->result, new_name);*/
finish_shorten (rh, nsh);
return;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting shorten for %s!\n", name);
- if (is_canonical ((char*)name))
+ if (is_canonical ((char*)name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"%s is canonical. Returning verbatim\n", name);
}
nsh = GNUNET_malloc (sizeof (struct NameShortenHandle));
-
nsh->proc = proc;
nsh->proc_cls = proc_cls;
nsh->root_zone = zone;
strcpy (nsh->shorten_zone_name, shorten_zone_name);
strcpy (nsh->result, name);
-
rh = GNUNET_malloc (sizeof (struct ResolverHandle));
rh->authority = *zone;
rh->id = rid++;
rh->private_local_zone = *zone;
GNUNET_CONTAINER_DLL_insert (nsh_head, nsh_tail, rh);
-
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Checking for TLD...\n");
+ "Checking for TLD...\n");
if (is_zkey_tld (name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
{
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);
- GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh);
proc (proc_cls, name);
return;
}
-
rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
zone, //ours
&zkey,
return;
}
- else
+ else if (is_gnunet_tld (name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"TLD is gnunet\n");
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;
/*********** 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);
+ nah->proc (nah->proc_cls, nah->result);
GNUNET_CONTAINER_DLL_remove (nah_head, nah_tail, rh);
- GNUNET_free(nah);
- free_resolver_handle(rh);
+ GNUNET_free (nah);
+ free_resolver_handle (rh);
}
/**
uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct GetNameAuthorityHandle* nah;
+ struct GetNameAuthorityHandle* nah = rh->proc_cls;
size_t answer_len;
- nah = (struct GetNameAuthorityHandle*) rh->proc_cls;
-
/**
* At this point rh->name contains the part of the name
* that we do not have a PKEY in our namestore to resolve.
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Building response!\n");
- if (is_canonical(rh->name))
+ if (is_canonical (rh->name) == GNUNET_YES)
{
/**
* We successfully resolved the authority in the ns
answer_len = strlen(nah->name) - strlen(rh->name)
+ strlen(GNUNET_GNS_TLD) + 1;
memset(nah->result, 0, answer_len);
- strcpy(nah->result, nah->name + strlen(rh->name) + 1);
+ if (0 != strcmp (rh->name, ""))
+ strcpy(nah->result, nah->name + strlen(rh->name) + 1);
+ else
+ strcpy(nah->result, nah->name);
finish_get_auth (rh, nah);
}