#include "gnunet_dnsparser_lib.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"
}
/**
- * 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 GNUNET_YES if canonical
*/
static int
-is_canonical (char* name)
+is_canonical (const char* name)
{
- char* ndup;
- char* tok;
-
- ndup = GNUNET_strdup (name);
- strtok (ndup, ".");
+ const char *pos;
+ const char *dot;
- for (tok = strtok (NULL, "."); tok != NULL; tok = strtok (NULL, "."))
- {
- /*
- * probably srv
- */
- if (*tok == '_')
- continue;
- GNUNET_free (ndup);
+ if (NULL == strchr (name, '.'))
+ return GNUNET_YES;
+ if ('_' != name[0])
return GNUNET_NO;
- }
- GNUNET_free (ndup);
+ pos = &name[1];
+ while (NULL != (dot = strchr (pos, '.')))
+ if ('_' != dot[1])
+ return GNUNET_NO;
+ else
+ pos = dot + 1;
return GNUNET_YES;
}
+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);
+}
+
+
/**
* Callback that shortens authorities
*
create_pkey_cont (void* cls, int32_t success, const char* emsg)
{
//FIXME do sth with error
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
+ struct GetPseuAuthorityHandle* gph = cls;
- 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);
+ 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;
gph->namestore_task = NULL;
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_AUTO_PSEU: Name %s already taken in NS!\n", name);
- GNUNET_free (gph->auth);
- 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;
}
| 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, //cont
- gph); //cls
+ gph->key,
+ gph->test_name,
+ &new_pkey,
+ &create_pkey_cont,
+ gph);
}
/**
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_AUTO_PSEU: No PSEU, no shorten. Finished.\n");
- GNUNET_free (gph->auth);
- 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;
}
- memcpy (gph->test_name, name, strlen(name)+1);
-
+ 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
*
{
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;
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);
- GNUNET_free (gph->auth);
- 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;
}
const struct GNUNET_CRYPTO_RsaSignature *signature)
{
struct GetPseuAuthorityHandle* gph = cls;
- struct GNUNET_CRYPTO_ShortHashCode name_hash;
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;
+ unsigned int i;
uint32_t xquery;
gph->namestore_task = NULL;
/* no pseu found */
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->auth->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);
for (i=0; i < rd_count; i++)
{
- if (0 != (strcmp (name, "+")))
+ if (0 != (strcmp (name, GNUNET_GNS_TLD_PLUS)))
continue;
if (rd[i].record_type != GNUNET_GNS_RECORD_PSEU)
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);
- GNUNET_free (gph->auth);
- GNUNET_CRYPTO_rsa_key_free (gph->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
- GNUNET_free (gph);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_AUTO_PSEU: name for zone in our root %s\n", name);
+ free_get_pseu_authority_handle (gph);
}
}
+
static void
start_shorten (struct AuthorityChain *auth,
- struct GNUNET_CRYPTO_RsaPrivateKey *key)
+ const struct GNUNET_CRYPTO_RsaPrivateKey *key)
{
struct GetPseuAuthorityHandle *gph;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pb_key;
GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
- pb_key = GNUNET_CRYPTO_rsa_encode_key (key);
-
- if (NULL == pb_key)
+ if (NULL == (pb_key = GNUNET_CRYPTO_rsa_encode_key (key)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Failed to encode RSA key on shorten\n");
return;
}
-
gph = GNUNET_malloc (sizeof (struct GetPseuAuthorityHandle));
- gph->key = GNUNET_CRYPTO_rsa_decode_key ((char*)pb_key, ntohs (pb_key->len));
-
+ 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,
unsigned long long max_bg_queries,
int ignore_pending)
{
- if (NULL == nh)
- return GNUNET_SYSERR;
- if (NULL == dh)
+ if ( (NULL == nh) ||
+ (NULL == dh) )
return GNUNET_SYSERR;
cfg = c;
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);
return GNUNET_OK;
}
GNUNET_CONTAINER_HeapCostType cost)
{
struct NamestoreBGTask *nbg = element;
- ResolverCleanupContinuation cont = cls;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_CLEANUP: Terminating ns task\n");
GNUNET_NAMESTORE_cancel (nbg->qe);
GNUNET_CONTAINER_heap_remove_node (node);
-
- if (0 == GNUNET_CONTAINER_heap_get_size (ns_task_heap))
- cont ();
-
return GNUNET_YES;
}
GNUNET_CONTAINER_HeapCostType cost)
{
struct ResolverHandle *rh = element;
- ResolverCleanupContinuation cont = cls;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_CLEANUP-%llu: Terminating background lookup for %s\n",
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;
}
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;
-
- 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;
- GNUNET_free (tmp->auth);
- GNUNET_CRYPTO_rsa_key_free (tmp->key);
- GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, tmp);
- GNUNET_free (tmp);
+ tmp->namestore_task = NULL;
+ }
+ free_get_pseu_authority_handle (tmp);
}
while (NULL != rlh_head)
if (0 != s)
GNUNET_CONTAINER_heap_iterate (dht_lookup_heap,
&cleanup_pending_background_queries,
- cont);
+ 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 ();
}
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,
GNUNET_NO,
&background_lookup_result_processor,
NULL);
+
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_DHT_get_stop (rh->get_handle);
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 = 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_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, (char*)&lookup_key_string);
+ rh->id, rh->name, GNUNET_h2s (&lookup_key));
//rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
rh->dht_heap_node = NULL;
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 (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
"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,
- NULL,
- 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);
}
{
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,
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;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Got DHT result\n", rh->id);
}
}
+ 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 */
+ /* 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 (0 != rh->answered)
{
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);
}
if (0 != rd_count)
{
/* results found yay */
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_REC-%llu: Record resolved from namestore!\n", rh->id);
- finish_lookup(rh, rlh, rd_count, rd);
+ 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);
+ 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
*/
if ((0 != (rh->status & RSL_RECORD_EXPIRED)) &&
(0 == (rh->status & RSL_RECORD_EXISTS)) )
+ {
+
+ 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,
+ if (0 == GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
&rh->private_local_zone))
+ {
+
+ 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;
return;
}
/* give up, cannot resolve */
- finish_lookup(rh, rlh, 0, NULL);
+ finish_lookup (rh, rlh, 0, NULL);
}
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);
- //FIXME handle return values here
- 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);
+ GNUNET_GNS_get_key_for_record (rh->authority_name, &rh->authority, &lookup_key);
rh->dht_heap_node = NULL;
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??)
*/
}
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,
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??)
*/
}
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,
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??)
*/
}
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_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;
}
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);
- GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh);
proc (proc_cls, name);
return;
}
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);
}
/**
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);
}