#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 "block_gns.h"
#include "gns.h"
/**
* Determine if this name is canonical.
* i.e.
- * a.b.gnunet = not canonical
+ * a.b.gads = not canonical
* a = canonical
*
* @param name the name to test
GNUNET_CRYPTO_rsa_key_free (gph->key);
GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
GNUNET_free (gph);
+ return;
}
- else
- 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",
const struct GNUNET_PeerIdentity *put_path,
unsigned int put_path_length,
enum GNUNET_BLOCK_Type type,
- size_t size, const void *data)
+ size_t size,
+ const void *data)
{
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
+ struct GetPseuAuthorityHandle* gph = cls;
struct GNSNameRecordBlock *nrb;
char* rd_data = (char*)data;
char* name;
const struct GNUNET_NAMESTORE_RecordData *rd,
const struct GNUNET_CRYPTO_RsaSignature *signature)
{
- uint32_t xquery;
+ 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;
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
+ uint32_t xquery;
gph->namestore_task = NULL;
/* no pseu found */
- if (rd_count == 0)
+ if (0 == rd_count)
{
/**
* check dht
GNUNET_assert (gph->get_handle == NULL);
gph->get_handle = GNUNET_DHT_get_start (dht_handle,
- GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
- &lookup_key,
- DHT_GNS_REPLICATION_LEVEL,
- GNUNET_DHT_RO_NONE,
- &xquery,
- sizeof(xquery),
- &process_auth_discovery_dht_result,
- gph);
+ GNUNET_BLOCK_TYPE_GNS_NAMERECORD,
+ &lookup_key,
+ DHT_GNS_REPLICATION_LEVEL,
+ GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+ &xquery,
+ sizeof(xquery),
+ &process_auth_discovery_dht_result,
+ gph);
return;
}
for (i=0; i < rd_count; i++)
{
- if ((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, "+")))
+ 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");
const struct GNUNET_NAMESTORE_RecordData *rd,
const struct GNUNET_CRYPTO_RsaSignature *signature)
{
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
+ 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);
-
- GNUNET_free (gph->auth);
- 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->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);
+ GNUNET_free (gph->auth);
+ GNUNET_CRYPTO_rsa_key_free (gph->key);
+ GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
+ GNUNET_free (gph);
}
start_shorten (struct AuthorityChain *auth,
struct GNUNET_CRYPTO_RsaPrivateKey *key)
{
- struct AuthorityChain *acopy;
struct GetPseuAuthorityHandle *gph;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pb_key;
-
- acopy = GNUNET_malloc (sizeof (struct AuthorityChain));
- memcpy (acopy, auth, sizeof (struct AuthorityChain));
-
- gph = GNUNET_malloc (sizeof (struct GetPseuAuthorityHandle));
-
GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
pb_key = GNUNET_CRYPTO_rsa_encode_key (key);
+
+ if (NULL == pb_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));
-
+
+ if (NULL == gph->key)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Failed to decode RSA key on shorten\n");
+ GNUNET_free (gph);
+ return;
+ }
GNUNET_CRYPTO_short_hash (&pkey,
sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&gph->our_zone);
- gph->auth = acopy;
-
+ 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);
}
unsigned long long max_bg_queries,
int ignore_pending)
{
+ if (NULL == nh)
+ return GNUNET_SYSERR;
+ if (NULL == dh)
+ return GNUNET_SYSERR;
+
cfg = c;
namestore_handle = nh;
dht_handle = dh;
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;
nah_tail = NULL;
GNUNET_RESOLVER_connect (cfg);
-
-
- if ((namestore_handle != NULL) && (dht_handle != NULL))
- {
- return GNUNET_OK;
- }
-
- return GNUNET_SYSERR;
+ return GNUNET_OK;
}
void *element,
GNUNET_CONTAINER_HeapCostType cost)
{
- struct NamestoreBGTask *nbg = (struct NamestoreBGTask *)element;
+ struct NamestoreBGTask *nbg = element;
ResolverCleanupContinuation cont = cls;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
GNUNET_CONTAINER_heap_remove_node (node);
- if (GNUNET_CONTAINER_heap_get_size (ns_task_heap) == 0)
+ if (0 == GNUNET_CONTAINER_heap_get_size (ns_task_heap))
cont ();
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;
+ struct ResolverHandle *rh = element;
ResolverCleanupContinuation cont = cls;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_CLEANUP-%llu: Terminating background lookup for %s\n",
rh->id, rh->name);
-
GNUNET_CONTAINER_heap_remove_node (node);
-
- if (GNUNET_CONTAINER_heap_get_size (dht_lookup_heap) == 0)
+ if (0 == GNUNET_CONTAINER_heap_get_size (dht_lookup_heap))
{
if (GNUNET_CONTAINER_heap_get_size (ns_task_heap) == 0)
cont ();
{
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);
"GNS_NS: Error putting records into namestore: %s\n", emsg);
}
+
static void
handle_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ResolverHandle *rh = cls;
- if (rh->timeout_cont)
+ if (NULL != rh->timeout_cont)
rh->timeout_cont (rh->timeout_cont_cls, tc);
+ /* FIXME: does this leak memory? */
}
+
/**
* Processor for background lookups in the DHT
*
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,
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);
{
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;
}
}
/* 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)
+ if (0 < rh->answered)
rh->proc (rh->proc_cls, rh, num_records, rd);
else
rh->proc (rh->proc_cls, rh, 0, NULL);
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);
//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_BLOCK_TYPE_GNS_NAMERECORD,
&lookup_key,
DHT_GNS_REPLICATION_LEVEL,
- GNUNET_DHT_RO_NONE,
+ GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
&xquery,
sizeof (xquery),
&process_record_result_dht,
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,
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",
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",
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) &&
"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?
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) == GNUNET_YES))
+ 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",
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) == GNUNET_YES))
+ 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",
(char*)&vpn[1],
GNUNET_h2s (&serv_desc));
rh->proc = &handle_record_vpn;
-
-
-
- if (rlh->record_type == GNUNET_GNS_RECORD_A)
+ if (GNUNET_GNS_RECORD_A == rlh->record_type)
af = AF_INET;
else
af = AF_INET6;
-
- //FIXME timeout??
if (NULL == vpn_handle)
{
vpn_handle = GNUNET_VPN_connect (cfg);
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) == GNUNET_YES))
+ 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, rh->authority_name, rh->timeout.rel_value);
rh->status |= RSL_TIMED_OUT;
-
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-
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,
- 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);
}
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,
rh->proc (rh->proc_cls, rh, rh->rd_count, &rh->rd);
else
resolve_delegation_ns (rh);
-
- return;
}
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;
struct GNUNET_CRYPTO_ShortHashCode zone, name_hash;
struct GNUNET_HashCode zone_hash_double, name_hash_double;
- 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",
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) == GNUNET_YES))
+ 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",
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
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_POSTPROCESS: Got %s to expand with %s\n", src, repl);
-
- 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);
+ "GNS_POSTPROCESS: %s too short\n", src);
/* no postprocessing */
memcpy(dest, src, s_len+1);
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);
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
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;
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);
}
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) == GNUNET_YES))
- 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) == GNUNET_YES)
+ 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';
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);
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) == GNUNET_YES)
+ 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",
struct GNUNET_HashCode lookup_key;
struct ResolverHandle *rh_heap_root;
- pop_tld(rh->name, rh->authority_name);
+ 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);
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_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Resolved queried PKEY in NS.\n",
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_YES)
- {
- 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);
}
&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);
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_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);
}
projects / oweals / gnunet.git / blobdiff