/*
This file is part of GNUnet.
- (C) 2009, 2010, 2011 Christian Grothoff (and other contributing authors)
+ (C) 2009, 2010, 2011, 2012, 2013 Christian Grothoff (and other contributing authors)
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
* @file gns/gnunet-service-gns_resolver.c
* @brief GNUnet GNS resolver logic
* @author Martin Schanzenbach
+ * @author Christian Grothoff
*/
#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_dns_service.h"
#include "gnunet_dht_service.h"
#include "gnunet_namestore_service.h"
-#include "gnunet_vpn_service.h"
#include "gnunet_dns_service.h"
#include "gnunet_resolver_service.h"
#include "gnunet_dnsparser_lib.h"
#include "block_gns.h"
#include "gns.h"
#include "gnunet-service-gns_resolver.h"
+#ifndef WINDOWS
+#include "gnunet_vpn_service.h"
+#endif
+
/**
* Default DHT timeout
*/
#define DHT_GNS_REPLICATION_LEVEL 5
-/**
- * Maximum label length of DNS names
- */
-#define MAX_DNS_LABEL_LENGTH 63
-
/**
* Our handle to the namestore service
*/
static struct GNUNET_NAMESTORE_Handle *namestore_handle;
+#ifndef WINDOWS
/**
* Our handle to the vpn service
*/
static struct GNUNET_VPN_Handle *vpn_handle;
+#endif
/**
* Resolver handle to the dht
* a resolution identifier pool variable
* This is a non critical identifier useful for debugging
*/
-static unsigned long long rid = 0;
+static unsigned long long rid_gen;
-/*
+
+/**
* Check if name is in srv format (_x._y.xxx)
*
* @param name
* @return GNUNET_YES if true
*/
static int
-is_srv (char* name)
+is_srv (const char *name)
{
- char* ndup;
- int ret = GNUNET_YES;
+ char *ndup;
+ int ret;
if (*name != '_')
return GNUNET_NO;
if (NULL == strstr (name, "._"))
return GNUNET_NO;
-
+ ret = GNUNET_YES;
ndup = GNUNET_strdup (name);
strtok (ndup, ".");
-
if (NULL == strtok (NULL, "."))
ret = GNUNET_NO;
-
if (NULL == strtok (NULL, "."))
ret = GNUNET_NO;
-
if (NULL != strtok (NULL, "."))
ret = GNUNET_NO;
-
GNUNET_free (ndup);
-
return ret;
}
* @return GNUNET_YES if canonical
*/
static int
-is_canonical (const char* name)
+is_canonical (const char *name)
{
const char *pos;
const char *dot;
{
gph->namestore_task = NULL;
GNUNET_free (gph->auth);
- GNUNET_CRYPTO_rsa_key_free (gph->key);
+ GNUNET_CRYPTO_ecc_key_free (gph->key);
GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph);
GNUNET_free (gph);
}
/**
- * Continueation for pkey record creation (shorten)
+ * Continuation for pkey record creation (shorten)
*
* @param cls a GetPseuAuthorityHandle
* @param success unused
*/
static void
process_pseu_lookup_ns (void* cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name, unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct GetPseuAuthorityHandle* gph = cls;
struct GNUNET_NAMESTORE_RecordData new_pkey;
/* name is free */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_AUTO_PSEU: Name %s not taken in NS! Adding\n", gph->test_name);
+ "GNS_AUTO_PSEU: Name %s not taken in NS! Adding\n",
+ gph->test_name);
new_pkey.expiration_time = UINT64_MAX;
new_pkey.data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode);
gph);
}
+
/**
* process result of a dht pseu lookup
*
* @param name the pseu result or NULL
*/
static void
-process_pseu_result (struct GetPseuAuthorityHandle* gph, char* name)
+process_pseu_result (struct GetPseuAuthorityHandle* gph,
+ const char* name)
{
if (NULL == name)
{
handle_auth_discovery_timeout (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls;
+ struct GetPseuAuthorityHandle* gph = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_GET_AUTH: dht lookup for query PSEU timed out.\n");
{
for (i=0; i < num_records; i++)
{
- if ((strcmp (name, "+") == 0) &&
+ if ((strcmp (name, GNUNET_GNS_MASTERZONE_STR) == 0) &&
(rd[i].record_type == GNUNET_GNS_RECORD_PSEU))
{
/* found pseu */
*/
static void
process_auth_discovery_ns_result (void* cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name,
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct GetPseuAuthorityHandle* gph = cls;
struct GNUNET_HashCode lookup_key;
GNUNET_h2s (&lookup_key));
gph->timeout = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT,
- &handle_auth_discovery_timeout, gph);
+ &handle_auth_discovery_timeout, gph);
xquery = htonl (GNUNET_GNS_RECORD_PSEU);
*/
static void
process_zone_to_name_discover (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
struct GNUNET_TIME_Absolute expire,
const char *name,
unsigned int rd_len,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct GetPseuAuthorityHandle* gph = cls;
{
gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
&gph->auth->zone,
- "+",
+ GNUNET_GNS_MASTERZONE_STR,
GNUNET_GNS_RECORD_PSEU,
&process_auth_discovery_ns_result,
gph);
static void
shorten_authority_chain (struct GetPseuAuthorityHandle *gph)
{
-
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_AUTO_PSEU: New authority %s discovered\n",
gph->auth->name);
&gph->auth->zone,
&process_zone_to_name_discover,
gph);
-
}
*/
static void
start_shorten (struct AuthorityChain *auth,
- const struct GNUNET_CRYPTO_RsaPrivateKey *key)
+ const struct GNUNET_CRYPTO_EccPrivateKey *key)
{
struct GetPseuAuthorityHandle *gph;
- struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
- struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pb_key;
+ struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded pkey;
+ struct GNUNET_CRYPTO_EccPrivateKeyBinaryEncoded *pb_key;
- GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
- if (NULL == (pb_key = GNUNET_CRYPTO_rsa_encode_key (key)))
+ GNUNET_CRYPTO_ecc_key_get_public (key, &pkey);
+ if (NULL == (pb_key = GNUNET_CRYPTO_ecc_encode_key (key)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Failed to encode RSA key on shorten\n");
+ "Failed to encode ECC key on shorten\n");
return;
}
- gph = GNUNET_malloc (sizeof (struct GetPseuAuthorityHandle));
- gph->key = GNUNET_CRYPTO_rsa_decode_key ((const char*) pb_key, ntohs (pb_key->len));
+ gph = GNUNET_new (struct GetPseuAuthorityHandle);
+ gph->key = GNUNET_CRYPTO_ecc_decode_key ((const char*) pb_key,
+ ntohs (pb_key->size),
+ GNUNET_YES);
GNUNET_free (pb_key);
if (NULL == gph->key)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
- "Failed to decode RSA key on shorten\n");
+ "Failed to decode ECC key on shorten\n");
GNUNET_free (gph);
return;
}
GNUNET_CRYPTO_short_hash (&pkey,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+ sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
&gph->our_zone);
gph->auth = GNUNET_malloc (sizeof (struct AuthorityChain));
memcpy (gph->auth, auth, sizeof (struct AuthorityChain));
shorten_authority_chain (gph);
}
+
/**
* Initialize the resolver
*
return GNUNET_OK;
}
-
-/**
- * Cleanup ns tasks
- *
- * @param cls closure to iterator
- * @param node heap nodes
- * @param element the namestorebgtask
- * @param cost heap cost
- * @return always GNUNET_YES
- */
-static int
-cleanup_pending_ns_tasks (void* cls,
- struct GNUNET_CONTAINER_HeapNode *node,
- void *element,
- GNUNET_CONTAINER_HeapCostType cost)
-{
- 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);
- return GNUNET_YES;
-}
-
-
/**
* finish lookup
*
const struct GNUNET_NAMESTORE_RecordData *rd);
-/**
- * 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
- * @param element the resolver handle
- * @param cost heap cost
- * @return always GNUNET_YES
- */
-static int
-cleanup_pending_background_queries (void* cls,
- struct GNUNET_CONTAINER_HeapNode *node,
- void *element,
- GNUNET_CONTAINER_HeapCostType cost)
-{
- struct ResolverHandle *rh = element;
-
- 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 (0 == GNUNET_CONTAINER_heap_get_size (dht_lookup_heap))
- {
- GNUNET_CONTAINER_heap_iterate (ns_task_heap,
- &cleanup_pending_ns_tasks,
- NULL);
- }
- return GNUNET_YES;
-}
-
-
/**
* Helper function to free resolver handle
*
if (NULL == rh)
return;
- ac = rh->authority_chain_head;
-
- while (NULL != ac)
+ ac_next = rh->authority_chain_head;
+ while (NULL != (ac = ac_next))
{
ac_next = ac->next;
GNUNET_free (ac);
- ac = ac_next;
}
if (NULL != rh->get_handle)
GNUNET_DHT_get_stop (rh->get_handle);
-
if (NULL != rh->dns_raw_packet)
GNUNET_free (rh->dns_raw_packet);
-
if (NULL != rh->namestore_task)
+ {
GNUNET_NAMESTORE_cancel (rh->namestore_task);
- rh->namestore_task = NULL;
-
+ rh->namestore_task = NULL;
+ }
if (GNUNET_SCHEDULER_NO_TASK != rh->dns_read_task)
GNUNET_SCHEDULER_cancel (rh->dns_read_task);
-
if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
GNUNET_SCHEDULER_cancel (rh->timeout_task);
-
if (NULL != rh->dns_sock)
GNUNET_NETWORK_socket_close (rh->dns_sock);
if (NULL != rh->dns_resolver_handle)
GNUNET_RESOLVER_request_cancel (rh->dns_resolver_handle);
-
if (NULL != rh->rd.data)
GNUNET_free ((void*)(rh->rd.data));
+ if (NULL != rh->dht_heap_node)
+ GNUNET_CONTAINER_heap_remove_node (rh->dht_heap_node);
GNUNET_free (rh);
}
void
gns_resolver_cleanup ()
{
- unsigned int s;
struct GetPseuAuthorityHandle *tmp;
+ struct ResolverHandle *rh;
+ struct NamestoreBGTask *nbg;
while (NULL != (tmp = gph_head))
{
finish_get_auth (nah_head, nah_head->proc_cls);
}
- 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,
- NULL);
- else if (0 != GNUNET_CONTAINER_heap_get_size (ns_task_heap))
+ while (NULL != (rh = GNUNET_CONTAINER_heap_remove_root(dht_lookup_heap)))
+ {
+ GNUNET_free (rh);
+ }
+ GNUNET_CONTAINER_heap_destroy (dht_lookup_heap);
+ dht_lookup_heap = NULL;
+
+ while (NULL != (nbg = GNUNET_CONTAINER_heap_remove_root(ns_task_heap)))
{
- GNUNET_CONTAINER_heap_iterate (ns_task_heap,
- &cleanup_pending_ns_tasks,
- NULL);
+ GNUNET_NAMESTORE_cancel (nbg->qe);
+ GNUNET_free (nbg);
}
+ GNUNET_CONTAINER_heap_destroy (ns_task_heap);
+ ns_task_heap = NULL;
+
}
handle_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ResolverHandle *rh = cls;
-
+
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Lookup timeout for request %llu triggered\n",
+ rh->id);
if (NULL != rh->timeout_cont)
rh->timeout_cont (rh->timeout_cont_cls, tc);
}
{
struct ResolverHandle *rh = cls;
struct RecordLookupHandle *rlh = rh->proc_cls;
- char new_name[MAX_DNS_NAME_LENGTH];
+ char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: dht lookup for query %s (%llus)timed out.\n",
+ "GNS_PHASE_REC-%llu: dht lookup for query %s (%llus) timed out.\n",
rh->id, rh->name, rh->timeout.rel_value);
/**
* Start resolution in bg
*/
- GNUNET_snprintf (new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
+ GNUNET_snprintf (new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
rh->name, GNUNET_GNS_TLD);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
enum GNUNET_BLOCK_Type type,
size_t size, const void *data)
{
- struct ResolverHandle *rh;
- struct RecordLookupHandle *rlh;
- struct GNSNameRecordBlock *nrb;
+ struct ResolverHandle *rh = cls;
+ struct RecordLookupHandle *rlh = rh->proc_cls;
+ const struct GNSNameRecordBlock *nrb = data;
uint32_t num_records;
- char* name = NULL;
- char* rd_data = (char*)data;
- int i;
- int rd_size;
+ const char* name;
+ const char* rd_data;
+ uint32_t i;
+ size_t 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);
-
- rlh = (struct RecordLookupHandle *) rh->proc_cls;
- nrb = (struct GNSNameRecordBlock*)data;
-
/* stop 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);
rh->dht_heap_node = NULL;
}
-
if (rh->timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (rh->timeout_task);
rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
-
rh->get_handle = NULL;
- name = (char*)&nrb[1];
+ name = (const char*) &nrb[1];
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_data = &name[strlen (name) + 1];
rd_size = size - strlen (name) - 1 - sizeof (struct GNSNameRecordBlock);
-
- if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
- rd_data,
- num_records,
- rd))
+ 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);
rh->proc (rh->proc_cls, rh, 0, NULL);
return;
}
-
for (i = 0; i < num_records; i++)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
namestore_bg_task->node = GNUNET_CONTAINER_heap_insert (ns_task_heap,
namestore_bg_task,
GNUNET_TIME_absolute_get().abs_value);
-
-
if (0 < rh->answered)
rh->proc (rh->proc_cls, rh, num_records, rd);
else
rh->proc (rh->proc_cls, rh, 0, NULL);
}
-
}
static void
resolve_record_dht (struct ResolverHandle *rh)
{
+ struct RecordLookupHandle *rlh = rh->proc_cls;
uint32_t xquery;
struct GNUNET_HashCode lookup_key;
- struct RecordLookupHandle *rlh = rh->proc_cls;
struct ResolverHandle *rh_heap_root;
GNUNET_GNS_get_key_for_record (rh->name, &rh->authority, &lookup_key);
if (GNUNET_SCHEDULER_NO_TASK == rh->timeout_task)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC-%llu: Adjusting timeout\n", rh->id);
+ "GNS_PHASE_REC-%llu: Adjusting timeout to %s/2\n",
+ rh->id,
+ GNUNET_STRINGS_relative_time_to_string (rh->timeout, GNUNET_YES));
/*
* Set timeout for authority lookup phase to 1/2
*/
*/
static void
process_record_result_ns (void* cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *key,
struct GNUNET_TIME_Absolute expiration,
const char *name, unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
- struct ResolverHandle *rh;
- struct RecordLookupHandle *rlh;
+ struct ResolverHandle *rh = cls;
+ struct RecordLookupHandle *rlh = rh->proc_cls;
struct GNUNET_TIME_Relative remaining_time;
struct GNUNET_CRYPTO_ShortHashCode zone;
struct GNUNET_TIME_Absolute et;
unsigned int i;
- rh = cls;
- rlh = rh->proc_cls;
-
rh->namestore_task = NULL;
GNUNET_CRYPTO_short_hash (key,
- sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
- &zone);
+ sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
+ &zone);
remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
-
-
-
rh->status = 0;
-
if (NULL != name)
{
rh->status |= RSL_RECORD_EXISTS;
-
if (remaining_time.rel_value == 0)
rh->status |= RSL_RECORD_EXPIRED;
}
-
- if (rd_count == 0)
+ if (0 == rd_count)
{
/**
* Lookup terminated and no results
}
+#ifndef WINDOWS
/**
* VPN redirect result callback
*
rh->id);
rh->proc (rh->proc_cls, rh, 0, NULL);
}
+#endif
/**
/* results found yay */
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_VPN-%llu: Record resolved from VPN!", rh->id);
+ "GNS_PHASE_REC_VPN-%llu: Record resolved from VPN!\n",
+ rh->id);
finish_lookup(rh, rlh, rd_count, rd);
}
/**
- * Read DNS udp packet from socket
+ * Read DNS packet from UDP socket and process the reply.
*
* @param cls the resolver handle
* @param tc task context
finish_lookup (rh, rlh, 0, NULL);
return;
}
-
- packet = GNUNET_DNSPARSER_parse (buf, r);
-
- if (NULL == packet)
+ if (NULL == (packet = GNUNET_DNSPARSER_parse (buf, r)))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Failed to parse DNS reply!\n");
for (i = 0; i < packet->num_answers; i++)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Got record type %d (want %d)\n",
- packet->answers[i].type,
- rlh->record_type);
+ "Got record type %d (want %d)\n",
+ packet->answers[i].type,
+ rlh->record_type);
/* http://tools.ietf.org/html/rfc1034#section-3.6.2 */
- if (packet->answers[i].type == GNUNET_GNS_RECORD_CNAME)
+ if (GNUNET_GNS_RECORD_CNAME == packet->answers[i].type)
{
+ struct GNUNET_DNSPARSER_Query query;
+ struct GNUNET_DNSPARSER_Packet npacket;
+ struct GNUNET_DNSPARSER_Flags flags;
+
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "CNAME... restarting query with %s\n",
- packet->answers[i].data.hostname
- );
- strcpy (rh->dns_name, packet->answers[i].data.hostname);
+ "CNAME record, restarting query with `%s'\n",
+ packet->answers[i].data.hostname);
+ strcpy (rh->dns_name,
+ packet->answers[i].data.hostname);
found_cname = GNUNET_YES;
+ query.name = rh->dns_name;
+ query.type = rlh->record_type;
+ query.class = GNUNET_DNSPARSER_CLASS_INTERNET;
+ memset (&flags, 0, sizeof (flags));
+ flags.recursion_desired = 1;
+ flags.checking_disabled = 1;
+ npacket.queries = &query;
+ npacket.answers = NULL;
+ npacket.authority_records = NULL;
+ npacket.num_queries = 1;
+ npacket.num_answers = 0;
+ npacket.num_authority_records = 0;
+ npacket.num_additional_records = 0;
+ npacket.flags = flags;
+ npacket.id = rh->id;
+ GNUNET_free_non_null (rh->dns_raw_packet);
+ rh->dns_raw_packet = NULL;
+ if (GNUNET_OK != GNUNET_DNSPARSER_pack (&npacket,
+ UINT16_MAX,
+ &rh->dns_raw_packet,
+ &rh->dns_raw_packet_size))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_REC_DNS-%llu: Creating raw dns packet!\n",
+ rh->id);
+ GNUNET_NETWORK_socket_close (rh->dns_sock);
+ finish_lookup (rh, rlh, 0, NULL);
+ return;
+ }
continue;
}
if (GNUNET_YES == found_cname)
{
- zone_offset = strlen (rh->dns_name) - strlen (rh->dns_zone) - 1;
-
+ zone_offset = strlen (rh->dns_name) - strlen (rh->dns_zone) - 1;
if (0 > zone_offset)
zone_offset = 0;
/* restart query with CNAME */
- if (0 == strcmp (rh->dns_name+zone_offset, rh->dns_zone))
+ if (0 == strcmp (rh->dns_name + zone_offset, rh->dns_zone))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Asking same server for %s\n", rh->dns_name);
+ "Asking DNS server for `%s'\n",
+ rh->dns_name);
+
send_dns_packet (rh);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Trying system resolver for %s\n", rh->dns_name);
+ "Trying system resolver for `%s'\n", rh->dns_name);
resolve_dns_name (rh);
}
}
for (i = 0; i < packet->num_authority_records; i++)
- {
-
+ {
if (packet->authority_records[i].type == GNUNET_GNS_RECORD_NS)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Nothing useful in DNS reply!\n");
finish_lookup (rh, rlh, 0, NULL);
GNUNET_DNSPARSER_free_packet (packet);
- return;
}
static void
send_dns_packet (struct ResolverHandle *rh)
{
- struct GNUNET_NETWORK_FDSet *rset = GNUNET_NETWORK_fdset_create ();
- GNUNET_NETWORK_fdset_set (rset, rh->dns_sock);
+ struct GNUNET_NETWORK_FDSet *rset;
+ rset = GNUNET_NETWORK_fdset_create ();
+ GNUNET_NETWORK_fdset_set (rset, rh->dns_sock);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Sending %dbyte DNS query\n",
- rh->dns_raw_packet_size);
+ "Sending %d byte DNS query\n",
+ (int) rh->dns_raw_packet_size);
if (GNUNET_SYSERR ==
GNUNET_NETWORK_socket_sendto (rh->dns_sock,
NULL,
&read_dns_response,
rh);
-
GNUNET_NETWORK_fdset_destroy (rset);
-
}
*/
static void
resolve_record_dns (struct ResolverHandle *rh,
- int rd_count,
+ unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
+ struct RecordLookupHandle *rlh = rh->proc_cls;
struct GNUNET_DNSPARSER_Query query;
struct GNUNET_DNSPARSER_Packet packet;
struct GNUNET_DNSPARSER_Flags flags;
struct in_addr dnsip;
struct sockaddr_in addr;
struct sockaddr *sa;
- int i;
- struct RecordLookupHandle *rlh = rh->proc_cls;
+ unsigned int i;
memset (&packet, 0, sizeof (struct GNUNET_DNSPARSER_Packet));
memset (rh->dns_name, 0, sizeof (rh->dns_name));
}
/* The glue */
if (GNUNET_GNS_RECORD_A == rd[i].record_type)
- /* need to use memcpy as .data may be unaligned */
- memcpy (&dnsip, rd[i].data, sizeof (dnsip));
+ /* need to use memcpy as .data may be unaligned */
+ memcpy (&dnsip, rd[i].data, sizeof (dnsip));
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_DNS-%llu: Looking up %s from %s\n",
+ "GNS_PHASE_REC_DNS-%llu: Looking up `%s' from `%s'\n",
rh->id,
rh->dns_name,
inet_ntoa (dnsip));
sizeof (struct sockaddr_in)))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_REC_DNS-%llu: Error binding udp socket for dns!\n",
+ "GNS_PHASE_REC_DNS-%llu: Error binding UDP socket for DNS lookup!\n",
rh->id);
finish_lookup (rh, rlh, 0, NULL);
return;
#if HAVE_SOCKADDR_IN_SIN_LEN
rh->dns_addr.sin_len = (u_char) sizeof (struct sockaddr_in);
#endif
-
send_dns_packet (rh);
}
*/
static void
resolve_record_vpn (struct ResolverHandle *rh,
- int rd_count,
+ unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
struct RecordLookupHandle *rlh = rh->proc_cls;
}
vpn = (struct vpn_data*)rd->data;
-
-
GNUNET_CRYPTO_hash ((char*)&vpn[1],
strlen ((char*)&vpn[1]) + 1,
&serv_desc);
af = AF_INET;
else
af = AF_INET6;
+#ifndef WINDOWS
if (NULL == vpn_handle)
{
vpn_handle = GNUNET_VPN_connect (cfg);
GNUNET_TIME_UNIT_FOREVER_ABS, //FIXME
&process_record_result_vpn,
rh);
+#else
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Error connecting to VPN (not available on W32 yet)\n");
+ finish_lookup (rh, rh->proc_cls, 0, NULL);
+#endif
}
static void
resolve_record_ns(struct ResolverHandle *rh)
{
- struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls;
+ struct RecordLookupHandle *rlh = rh->proc_cls;
/* We cancel here as to not include the ns lookup in the timeout */
if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
* @param tc the task context
*/
static void
-dht_authority_lookup_timeout(void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+dht_authority_lookup_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct ResolverHandle *rh = cls;
struct RecordLookupHandle *rlh = rh->proc_cls;
- char new_name[MAX_DNS_NAME_LENGTH];
+ char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_DHT-%llu: dht lookup for query %s (%llus)timed out.\n",
- rh->id, rh->authority_name, rh->timeout.rel_value);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "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;
if (NULL != rh->get_handle)
+ {
GNUNET_DHT_get_stop (rh->get_handle);
-
- rh->get_handle = NULL;
- if (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)
+ rh->get_handle = NULL;
+ }
+ if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_DHT-%llu: Got shutdown\n",
- rh->id);
- rh->proc(rh->proc_cls, rh, 0, NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_DHT-%llu: Got shutdown\n",
+ rh->id);
+ rh->proc (rh->proc_cls, rh, 0, NULL);
return;
}
-
- if (0 == strcmp(rh->name, ""))
+ if (0 == strcmp (rh->name, ""))
{
/*
* promote authority back to name and try to resolve record
*/
- strcpy(rh->name, rh->authority_name);
- rh->proc(rh->proc_cls, rh, 0, NULL);
+ strcpy (rh->name, rh->authority_name);
+ rh->proc (rh->proc_cls, rh, 0, NULL);
return;
}
/**
* Start resolution in bg
*/
- 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);
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_DHT-%llu: Starting background query for %s type %d\n",
- rh->id, rh->name, rlh->record_type);
-
+ GNUNET_snprintf (new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
+ "%s.%s.%s",
+ rh->name, rh->authority_name, GNUNET_GNS_TLD);
+ strcpy (rh->name, new_name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "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,
GNUNET_NO,
&background_lookup_result_processor,
NULL);
- rh->proc(rh->proc_cls, rh, 0, NULL);
+ rh->proc (rh->proc_cls, rh, 0, NULL);
}
*
* @param rh the pending gns query
*/
-static void resolve_delegation_dht(struct ResolverHandle *rh);
+static void
+resolve_delegation_dht (struct ResolverHandle *rh);
/**
*
* @param rh the resolver handle
*/
-static void resolve_delegation_ns(struct ResolverHandle *rh);
+static void
+resolve_delegation_ns (struct ResolverHandle *rh);
/**
* @param rd record data (always NULL)
*/
static void
-handle_delegation_ns(void* cls, struct ResolverHandle *rh,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd);
+handle_delegation_ns (void* cls, struct ResolverHandle *rh,
+ unsigned int rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd);
/**
*/
static void
process_pkey_revocation_result_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_EccPublicKeyBinaryEncoded *key,
+ struct GNUNET_TIME_Absolute expiration,
+ const char *name,
+ unsigned int rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ResolverHandle *rh = cls;
struct GNUNET_TIME_Relative remaining_time;
* @param data the record data
*/
static void
-process_delegation_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_delegation_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 = cls;
- struct GNSNameRecordBlock *nrb;
+ const struct GNSNameRecordBlock *nrb = data;
+ const char* rd_data;
uint32_t num_records;
- char* name = NULL;
- char* rd_data = (char*) data;
+ const char* name;
uint32_t i;
int rd_size;
struct GNUNET_CRYPTO_ShortHashCode zone;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_DHT-%llu: Got DHT result\n", rh->id);
-
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_DHT-%llu: Got DHT result\n",
+ rh->id);
if (data == NULL)
return;
-
- nrb = (struct GNSNameRecordBlock*)data;
-
- /* stop dht lookup and timeout task */
+ /* stop dht lookup and timeout task */
GNUNET_DHT_get_stop (rh->get_handle);
rh->get_handle = NULL;
if (rh->dht_heap_node != NULL)
}
num_records = ntohl(nrb->rd_count);
- name = (char*)&nrb[1];
+ name = (const char*) &nrb[1];
{
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 = name + strlen(name) + 1;
+ rd_size = size - strlen(name) - 1 - sizeof (struct GNSNameRecordBlock);
if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size,
rd_data,
num_records,
rh->id, name, rh->authority_name);
for (i=0; i<num_records; i++)
{
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_DHT-%llu: Got name: %s (wanted %s)\n",
- rh->id, name, rh->authority_name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_DHT-%llu: Got name: %s (wanted %s)\n",
+ rh->id, name, rh->authority_name);
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_DHT-%llu: Got type: %d (wanted %d)\n",
rh->id, rd[i].record_type, GNUNET_GNS_RECORD_PKEY);
if (0 == strcmp(rh->name, ""))
strcpy(rh->name, rh->authority_name);
else
- GNUNET_snprintf(rh->name, MAX_DNS_NAME_LENGTH, "%s.%s",
+ GNUNET_snprintf(rh->name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
rh->name, rh->authority_name); //FIXME ret
rh->answered = 1;
break;
/* Check for key revocation and delegate */
rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
&rh->authority,
- "+",
+ GNUNET_GNS_MASTERZONE_STR,
GNUNET_GNS_RECORD_REV,
&process_pkey_revocation_result_ns,
rh);
if (0 == strcmp(rh->name, ""))
strcpy(rh->name, rh->authority_name);
else
- GNUNET_snprintf(rh->name, MAX_DNS_NAME_LENGTH, "%s.%s",
+ GNUNET_snprintf(rh->name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
rh->name, rh->authority_name); //FIXME ret
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
//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
+ +(GNUNET_DNSPARSER_MAX_NAME_LENGTH*2)
+#define MAX_MX_LENGTH sizeof(uint16_t)+GNUNET_DNSPARSER_MAX_NAME_LENGTH
+#define MAX_SRV_LENGTH (sizeof(uint16_t)*3)+GNUNET_DNSPARSER_MAX_NAME_LENGTH
/**
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- int i;
- char new_rr_data[MAX_DNS_NAME_LENGTH];
+ unsigned int i;
+ char new_rr_data[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
char new_mx_data[MAX_MX_LENGTH];
char new_soa_data[MAX_SOA_LENGTH];
char new_srv_data[MAX_SRV_LENGTH];
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_POSTPROCESS: Postprocessing\n");
- if (0 == strcmp(rh->name, "+"))
+ if (0 == strcmp(rh->name, GNUNET_GNS_MASTERZONE_STR))
repl_string = rlh->name;
else
repl_string = rlh->name+strlen(rh->name)+1;
* @param rd record data
*/
static void
-handle_record_dht(void* cls, struct ResolverHandle *rh,
- unsigned int rd_count,
- const struct GNUNET_NAMESTORE_RecordData *rd)
+handle_record_dht (void* cls, struct ResolverHandle *rh,
+ unsigned int rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd)
{
struct RecordLookupHandle* rlh = cls;
check_dht = GNUNET_NO;
}
- if ((0 != strcmp (rh->name, "+")) && (GNUNET_YES == is_srv (rh->name)))
+ if ((0 != strcmp (rh->name, GNUNET_GNS_MASTERZONE_STR)) && (GNUNET_YES == is_srv (rh->name)))
check_dht = GNUNET_NO;
if (GNUNET_YES == rh->only_cached)
* Move one level up in the domain hierarchy and return the
* passed top level domain.
*
+ * FIXME: funky API: not only 'dest' is updated, so is 'name'!
+ *
* @param name the domain
* @param dest the destination where the tld will be put
*/
-void
-pop_tld(char* name, char* dest)
+static void
+pop_tld (char* name, char* dest)
{
uint32_t len;
if (GNUNET_YES == is_canonical (name))
{
- strcpy(dest, name);
- strcpy(name, "");
+ strcpy (dest, name);
+ strcpy (name, "");
return;
}
//Was canonical?
if (0 == len)
return;
-
name[len] = '\0';
-
- strcpy(dest, (name+len+1));
-}
-
-
-/**
- * Checks if name is in tld
- *
- * @param name the name to check
- * @param tld the TLD to check for
- * @return GNUNET_YES or GNUNET_NO
- */
-int
-is_tld(const char* name, const char* tld)
-{
- int offset = 0;
-
- if (strlen(name) <= strlen(tld))
- return GNUNET_NO;
-
- offset = strlen(name)-strlen(tld);
- if (0 != strcmp(name+offset, tld))
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "%s is not in .%s TLD\n", name, tld);
- return GNUNET_NO;
- }
- return GNUNET_YES;
+ strcpy (dest, (name+len+1));
}
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct RecordLookupHandle* rlh;
- rlh = cls;
+ struct RecordLookupHandle* rlh = cls;
-
if (0 == strcmp(rh->name, ""))
{
if (GNUNET_GNS_RECORD_PKEY == rlh->record_type)
* @param rh the pending gns query
*/
static void
-resolve_delegation_dht(struct ResolverHandle *rh)
+resolve_delegation_dht (struct ResolverHandle *rh)
{
uint32_t xquery;
struct GNUNET_HashCode lookup_key;
struct ResolverHandle *rh_heap_root;
- pop_tld(rh->name, rh->authority_name);
-
- GNUNET_GNS_get_key_for_record (rh->authority_name, &rh->authority, &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_cont = &dht_authority_lookup_timeout;
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,
- "GNS_PHASE_DELEGATE_DHT-%llu: Replacing oldest background query for %s\n",
- rh->id, rh_heap_root->authority_name);
-
- rh_heap_root->proc(rh_heap_root->proc_cls,
- rh_heap_root,
- 0,
- NULL);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_DHT-%llu: Replacing oldest background query for %s\n",
+ rh->id,
+ rh_heap_root->authority_name);
+ 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(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_DEMULTIPLEX_EVERYWHERE,
- &xquery,
- sizeof(xquery),
- &process_delegation_result_dht,
- rh);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Beginning DHT lookup for %s in zone %s for request %llu\n",
+ rh->authority_name,
+ GNUNET_short_h2s (&rh->authority),
+ rh->id);
+ xquery = htonl (GNUNET_GNS_RECORD_PKEY);
+ 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_delegation_result_dht,
+ rh);
+}
+
+
+/**
+ * Checks if "name" ends in ".tld"
+ *
+ * @param name the name to check
+ * @param tld the TLD to check for
+ * @return GNUNET_YES or GNUNET_NO
+ */
+int
+is_tld (const char* name, const char* tld)
+{
+ size_t offset = 0;
+
+ if (strlen (name) <= strlen (tld))
+ return GNUNET_NO;
+ offset = strlen (name) - strlen (tld);
+ if (0 != strcmp (name + offset, tld))
+ return GNUNET_NO;
+ return GNUNET_YES;
}
unsigned int rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct RecordLookupHandle* rlh;
- rlh = cls;
- int check_dht = GNUNET_YES;
- int s_len = 0;
+ struct RecordLookupHandle* rlh = cls;
+ int check_dht;
+ size_t s_len;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Resolution status: %d.\n",
- rh->id, rh->status);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Resolution status: %d.\n",
+ rh->id, rh->status);
if (rh->status & RSL_PKEY_REVOKED)
{
{
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->id);
- finish_lookup(rh, rlh, rd_count, rd);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Resolved queried NSRR in NS.\n",
+ rh->id);
+ finish_lookup (rh, rlh, rd_count, rd);
return;
- }
-
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: NS delegation starting.\n",
- rh->id);
+ }
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: NS delegation starting.\n",
+ rh->id);
GNUNET_assert (NULL != rd);
rh->proc = &handle_record_ns;
resolve_record_dns (rh, rd_count, rd);
* or we are authority
**/
+ check_dht = GNUNET_YES;
if ((rh->status & RSL_RECORD_EXISTS) &&
!(rh->status & RSL_RECORD_EXPIRED))
check_dht = GNUNET_NO;
*/
static void
process_delegation_result_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_EccPublicKeyBinaryEncoded *key,
+ struct GNUNET_TIME_Absolute expiration,
+ const char *name,
+ unsigned int rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd,
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
- struct ResolverHandle *rh;
+ struct ResolverHandle *rh = cls;
struct GNUNET_TIME_Relative remaining_time;
struct GNUNET_CRYPTO_ShortHashCode zone;
- char new_name[MAX_DNS_NAME_LENGTH];
+ char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
unsigned int i;
struct GNUNET_TIME_Absolute et;
+ struct AuthorityChain *auth;
- rh = (struct ResolverHandle *)cls;
rh->namestore_task = NULL;
+ GNUNET_CRYPTO_short_hash (key,
+ sizeof (struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded),
+ &zone);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup\n",
- rh->id, rd_count);
+ "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup for `%s' in zone %s\n",
+ rh->id, rd_count,
+ name,
+ GNUNET_short_h2s (&zone));
- GNUNET_CRYPTO_short_hash (key,
- sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
- &zone);
remaining_time = GNUNET_TIME_absolute_get_remaining (expiration);
rh->status = 0;
- if (name != NULL)
+ if (NULL != name)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Records with name %s exist.\n",
- rh->id, name);
+ "GNS_PHASE_DELEGATE_NS-%llu: Records with name `%s' exist in zone %s.\n",
+ rh->id, name,
+ GNUNET_short_h2s (&zone));
rh->status |= RSL_RECORD_EXISTS;
- if (remaining_time.rel_value == 0)
+ if (0 == remaining_time.rel_value)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n",
/**
* No authority found in namestore.
*/
- if (rd_count == 0)
+ if (0 == rd_count)
{
/**
* We did not find an authority in the namestore
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Adding %s back to %s\n",
rh->id, rh->authority_name, rh->name);
- GNUNET_snprintf (new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
+ GNUNET_snprintf (new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
rh->name, rh->authority_name);
strcpy (rh->name, new_name);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
*/
for (i=0; i < rd_count;i++)
{
-
- /**
- * A CNAME. Like regular DNS this means the is no other record for this
- * name.
- */
- if (rd[i].record_type == GNUNET_GNS_RECORD_CNAME)
+ switch (rd[i].record_type)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: CNAME found.\n",
- rh->id);
+ case GNUNET_GNS_RECORD_CNAME:
+ /* Like in regular DNS this should mean that there is no other
+ * record for this name. */
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: CNAME `%.*s' found.\n",
+ rh->id,
+ (int) rd[i].data_size,
+ rd[i].data);
rh->status |= RSL_CNAME_FOUND;
rh->proc (rh->proc_cls, rh, rd_count, rd);
return;
- }
-
- /**
- * Redirect via VPN
- */
- if (rd[i].record_type == GNUNET_GNS_RECORD_VPN)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: VPN found.\n",
- rh->id);
+ case GNUNET_GNS_RECORD_VPN:
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: VPN found.\n",
+ rh->id);
rh->status |= RSL_DELEGATE_VPN;
rh->proc (rh->proc_cls, rh, rd_count, rd);
return;
- }
-
- /**
- * Redirect via NS
- * FIXME make optional
- */
- if (rd[i].record_type == GNUNET_GNS_RECORD_NS)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: NS found.\n",
- rh->id);
+ case GNUNET_GNS_RECORD_NS:
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: NS `%.*s' found.\n",
+ rh->id,
+ (int) rd[i].data_size,
+ rd[i].data);
rh->status |= RSL_DELEGATE_NS;
rh->proc (rh->proc_cls, rh, rd_count, rd);
return;
- }
-
- if (rd[i].record_type != GNUNET_GNS_RECORD_PKEY)
- continue;
-
- rh->status |= RSL_DELEGATE_PKEY;
-
- if ((ignore_pending_records != 0) &&
- (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: PKEY for %s is pending user confirmation.\n",
- rh->id,
- name);
- continue;
- }
-
- GNUNET_break (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
- et.abs_value = rd[i].expiration_time;
- if ((GNUNET_TIME_absolute_get_remaining (et)).rel_value
- == 0)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
- rh->id);
- if (remaining_time.rel_value == 0)
+ case GNUNET_GNS_RECORD_PKEY:
+ rh->status |= RSL_DELEGATE_PKEY;
+ if ((ignore_pending_records != 0) &&
+ (rd[i].flags & GNUNET_NAMESTORE_RF_PENDING))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
- rh->id);
- rh->authority_chain_head->fresh = 0;
- rh->proc (rh->proc_cls, rh, 0, NULL);
- return;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: PKEY for %s is pending user confirmation.\n",
+ rh->id,
+ name);
+ continue;
+ }
+ GNUNET_break (0 == (rd[i].flags & GNUNET_NAMESTORE_RF_RELATIVE_EXPIRATION));
+ et.abs_value = rd[i].expiration_time;
+ if (0 == (GNUNET_TIME_absolute_get_remaining (et)).rel_value)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
+ rh->id);
+ if (remaining_time.rel_value == 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
+ rh->id);
+ rh->authority_chain_head->fresh = 0;
+ rh->proc (rh->proc_cls, rh, 0, NULL);
+ return;
+ }
+ continue;
}
-
- continue;
+ /* Resolve rest of query with new authority */
+ memcpy (&rh->authority, rd[i].data,
+ sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+ auth = GNUNET_malloc(sizeof (struct AuthorityChain));
+ auth->zone = rh->authority;
+ memset (auth->name, 0, strlen (rh->authority_name)+1);
+ strcpy (auth->name, rh->authority_name);
+ GNUNET_CONTAINER_DLL_insert (rh->authority_chain_head,
+ rh->authority_chain_tail,
+ auth);
+ if (NULL != rh->rd.data)
+ GNUNET_free ((void*)(rh->rd.data));
+ memcpy (&rh->rd, &rd[i], sizeof (struct GNUNET_NAMESTORE_RecordData));
+ rh->rd.data = GNUNET_malloc (rd[i].data_size);
+ memcpy ((void*)rh->rd.data, rd[i].data, rd[i].data_size);
+ rh->rd_count = 1;
+ /* Check for key revocation and delegate */
+ rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
+ &rh->authority,
+ GNUNET_GNS_MASTERZONE_STR,
+ GNUNET_GNS_RECORD_REV,
+ &process_pkey_revocation_result_ns,
+ rh);
+ return;
+ default:
+ /* ignore, move to next result */
+ break;
}
-
- /**
- * Resolve rest of query with new authority
- */
- GNUNET_assert (rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
- memcpy (&rh->authority, rd[i].data,
- sizeof (struct GNUNET_CRYPTO_ShortHashCode));
- struct AuthorityChain *auth = GNUNET_malloc(sizeof (struct AuthorityChain));
- auth->zone = rh->authority;
- memset (auth->name, 0, strlen (rh->authority_name)+1);
- strcpy (auth->name, rh->authority_name);
- GNUNET_CONTAINER_DLL_insert (rh->authority_chain_head,
- rh->authority_chain_tail,
- auth);
- if (NULL != rh->rd.data)
- GNUNET_free ((void*)(rh->rd.data));
-
- memcpy (&rh->rd, &rd[i], sizeof (struct GNUNET_NAMESTORE_RecordData));
- rh->rd.data = GNUNET_malloc (rd[i].data_size);
- memcpy ((void*)rh->rd.data, rd[i].data, rd[i].data_size);
- rh->rd_count = 1;
- /* Check for key revocation and delegate */
- rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
- &rh->authority,
- "+",
- GNUNET_GNS_RECORD_REV,
- &process_pkey_revocation_result_ns,
- rh);
- return;
-
}
- /**
- * no answers found
- */
+ /* no answers that would cause delegation were found */
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Authority lookup and no PKEY...\n", rh->id);
+ "GNS_PHASE_DELEGATE_NS-%llu: Authority lookup failed (no PKEY record)\n",
+ rh->id);
/**
* If we have found some records for the LAST label
- * we return the results. Else null.
+ * we return the results. Else NULL.
*/
- if (strcmp (rh->name, "") == 0)
+ if (0 == strcmp (rh->name, ""))
{
/* Start shortening */
if ((rh->priv_key != NULL) &&
}
else
{
- GNUNET_snprintf (new_name, MAX_DNS_NAME_LENGTH,
+ GNUNET_snprintf (new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
"%s.%s", rh->name, rh->authority_name);
strcpy (rh->name, new_name);
rh->proc (rh->proc_cls, rh, 0, NULL);
/**
* Resolve the delegation chain for the request in our namestore
+ * (as in, find the respective authority for the leftmost label).
*
* @param rh the resolver handle
*/
static void
resolve_delegation_ns (struct ResolverHandle *rh)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Resolving delegation for %s\n",
- rh->id, rh->name);
- pop_tld(rh->name, rh->authority_name);
- rh->namestore_task = GNUNET_NAMESTORE_lookup_record(namestore_handle,
- &rh->authority,
- rh->authority_name,
- GNUNET_GNS_RECORD_ANY,
- &process_delegation_result_ns,
- rh);
-
+ pop_tld (rh->name, rh->authority_name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Finding authority for `%s' by looking up `%s' in GADS zone `%s'\n",
+ rh->id,
+ rh->name,
+ rh->authority_name,
+ GNUNET_short_h2s (&rh->authority));
+ rh->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle,
+ &rh->authority,
+ rh->authority_name,
+ GNUNET_GNS_RECORD_ANY,
+ &process_delegation_result_ns,
+ rh);
}
struct GNUNET_CRYPTO_ShortHashCode pzone,
uint32_t record_type,
const char* name,
- struct GNUNET_CRYPTO_RsaPrivateKey *key,
+ struct GNUNET_CRYPTO_EccPrivateKey *key,
struct GNUNET_TIME_Relative timeout,
int only_cached,
RecordLookupProcessor proc,
{
struct ResolverHandle *rh;
struct RecordLookupHandle* rlh;
- char string_hash[MAX_DNS_LABEL_LENGTH];
- char nzkey[MAX_DNS_LABEL_LENGTH];
+ char string_hash[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
+ char nzkey[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
char* nzkey_ptr = nzkey;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Starting resolution for %s (type=%d)!\n",
- name, record_type);
+ "Starting resolution for `%s' (type=%d) with timeout %s!\n",
+ name, record_type,
+ GNUNET_STRINGS_relative_time_to_string (timeout, GNUNET_YES));
-
if ((is_canonical ((char*)name) == GNUNET_YES) &&
(strcmp(GNUNET_GNS_TLD, name) != 0))
{
rlh = GNUNET_malloc (sizeof(struct RecordLookupHandle));
rh = GNUNET_malloc (sizeof (struct ResolverHandle));
-
- memset (rh, 0, sizeof (struct ResolverHandle));
rh->authority = zone;
- rh->id = rid++;
+ rh->id = rid_gen++;
rh->proc_cls = rlh;
rh->priv_key = key;
rh->timeout = timeout;
- rh->get_handle = NULL;
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);
* Set timeout for authority lookup phase to 1/2
*/
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Timeout for lookup set to %ds\n", rh->timeout.rel_value);
- rh->timeout_task = GNUNET_SCHEDULER_add_delayed(
+ "Timeout for lookup set to %s/2\n",
+ GNUNET_STRINGS_relative_time_to_string (rh->timeout, GNUNET_YES));
+ rh->timeout_task = GNUNET_SCHEDULER_add_delayed (
GNUNET_TIME_relative_divide(timeout, 2),
&handle_lookup_timeout,
rh);
if (strcmp(GNUNET_GNS_TLD, name) == 0)
{
/**
- * Only 'gnunet' given
+ * Only '.gads' given
*/
- strcpy(rh->name, "\0");
+ strcpy (rh->name, "\0");
}
else
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Checking for TLD...\n");
if (is_zkey_tld(name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY));
memcpy(rh->name, name,
strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY) - 1);
- pop_tld(rh->name, string_hash);
+ pop_tld (rh->name, string_hash);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"ZKEY is %s!\n", string_hash);
}
}
- else if (is_gnunet_tld (name) == GNUNET_YES)
+ else if (is_gads_tld (name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "TLD is gnunet\n");
+ "TLD is gads\n");
/**
- * Presumably GNUNET tld
+ * Presumably GADS tld
*/
- memset (rh->name, 0,
- strlen(name)-strlen(GNUNET_GNS_TLD));
memcpy (rh->name, name,
- strlen(name)-strlen(GNUNET_GNS_TLD) - 1);
+ strlen (name) - strlen(GNUNET_GNS_TLD) - 1);
+ rh->name[strlen (name) - strlen(GNUNET_GNS_TLD) - 1] = '\0';
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- "Cannot handle this TLD %s\n", string_hash);
-
+ _("Not a GADS TLD: `%s'\n"),
+ name);
if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task)
GNUNET_SCHEDULER_cancel (rh->timeout_task);
GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh);
/**
* Initialize authority chain
*/
- rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain));
- rh->authority_chain_head->prev = NULL;
- rh->authority_chain_head->next = NULL;
+ rh->authority_chain_head = GNUNET_malloc (sizeof(struct AuthorityChain));
rh->authority_chain_tail = rh->authority_chain_head;
rh->authority_chain_head->zone = rh->authority;
strcpy (rh->authority_chain_head->name, "");
rlh->proc_cls = cls;
rh->proc = &handle_delegation_ns;
- resolve_delegation_ns(rh);
+ resolve_delegation_ns (rh);
}
/******** END Record Resolver ***********/
*/
static void
process_zone_to_name_shorten_root (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
struct GNUNET_TIME_Absolute expire,
const char *name,
unsigned int rd_len,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature);
+ const struct GNUNET_CRYPTO_EccSignature *signature);
/**
*/
static void
process_zone_to_name_shorten_shorten (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
struct GNUNET_TIME_Absolute expire,
const char *name,
unsigned int rd_len,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
- struct ResolverHandle *rh = (struct ResolverHandle *)cls;
- struct NameShortenHandle* nsh = (struct NameShortenHandle*)rh->proc_cls;
+ struct ResolverHandle *rh = cls;
+ struct NameShortenHandle* nsh = rh->proc_cls;
struct AuthorityChain *next_authority;
- char result[MAX_DNS_NAME_LENGTH];
- char tmp_name[MAX_DNS_NAME_LENGTH];
+ char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+ char tmp_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
size_t answer_len;
rh->namestore_task = NULL;
if (0 == strcmp (rh->name, ""))
strcpy (tmp_name, next_authority->name);
else
- GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
+ GNUNET_snprintf(tmp_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
"%s.%s", rh->name, next_authority->name);
strcpy(rh->name, tmp_name);
*/
static void
process_zone_to_name_shorten_private (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
struct GNUNET_TIME_Absolute expire,
const char *name,
unsigned int rd_len,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
- struct ResolverHandle *rh = (struct ResolverHandle *)cls;
- struct NameShortenHandle* nsh = (struct NameShortenHandle*)rh->proc_cls;
+ struct ResolverHandle *rh = cls;
+ struct NameShortenHandle* nsh = rh->proc_cls;
struct AuthorityChain *next_authority;
- char result[MAX_DNS_NAME_LENGTH];
- char tmp_name[MAX_DNS_NAME_LENGTH];
+ char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+ char tmp_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
size_t answer_len;
rh->namestore_task = NULL;
if (0 == strcmp (rh->name, ""))
strcpy (tmp_name, next_authority->name);
else
- GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
+ GNUNET_snprintf(tmp_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
"%s.%s", rh->name, next_authority->name);
strcpy(rh->name, tmp_name);
*/
static void
process_zone_to_name_shorten_root (void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
struct GNUNET_TIME_Absolute expire,
const char *name,
unsigned int rd_len,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
- struct ResolverHandle *rh = (struct ResolverHandle *)cls;
- struct NameShortenHandle* nsh = (struct NameShortenHandle*)rh->proc_cls;
+ struct ResolverHandle *rh = cls;
+ struct NameShortenHandle* nsh = rh->proc_cls;
struct AuthorityChain *next_authority;
-
- char result[MAX_DNS_NAME_LENGTH];
- char tmp_name[MAX_DNS_NAME_LENGTH];
+ char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
+ char tmp_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
size_t answer_len;
rh->namestore_task = NULL;
if (0 == strcmp (rh->name, ""))
strcpy (tmp_name, next_authority->name);
else
- GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH,
+ GNUNET_snprintf(tmp_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH,
"%s.%s", rh->name, next_authority->name);
strcpy(rh->name, tmp_name);
const struct GNUNET_NAMESTORE_RecordData *rd)
{
struct NameShortenHandle *nsh;
- char result[MAX_DNS_NAME_LENGTH];
+ char result[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
nsh = (struct NameShortenHandle *)cls;
rh->namestore_task = NULL;
*/
static void
process_zone_to_name_zkey(void *cls,
- const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key,
+ const struct GNUNET_CRYPTO_EccPublicKeyBinaryEncoded *zone_key,
struct GNUNET_TIME_Absolute expire,
const char *name,
unsigned int rd_len,
const struct GNUNET_NAMESTORE_RecordData *rd,
- const struct GNUNET_CRYPTO_RsaSignature *signature)
+ const struct GNUNET_CRYPTO_EccSignature *signature)
{
struct ResolverHandle *rh = cls;
struct NameShortenHandle *nsh = rh->proc_cls;
- char new_name[MAX_DNS_NAME_LENGTH];
+ char new_name[GNUNET_DNSPARSER_MAX_NAME_LENGTH];
rh->namestore_task = NULL;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"No name found for zkey %s returning verbatim!\n", nsh->result);
/*if (strcmp(rh->name, "") != 0)
- GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s.%s",
+ GNUNET_snprintf(new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s.%s",
rh->name, enc, GNUNET_GNS_TLD_ZKEY);
else
- GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
+ GNUNET_snprintf(new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
enc, GNUNET_GNS_TLD_ZKEY);
strcpy (nsh->result, new_name);*/
}
if (strcmp(rh->name, "") != 0)
- GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
+ GNUNET_snprintf(new_name, GNUNET_DNSPARSER_MAX_NAME_LENGTH, "%s.%s",
rh->name, name);
else
strcpy(new_name, name);
{
struct ResolverHandle *rh;
struct NameShortenHandle *nsh;
- char string_hash[MAX_DNS_LABEL_LENGTH];
+ char string_hash[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
struct GNUNET_CRYPTO_ShortHashCode zkey;
- char nzkey[MAX_DNS_LABEL_LENGTH];
+ char nzkey[GNUNET_DNSPARSER_MAX_LABEL_LENGTH];
char* nzkey_ptr = nzkey;
-
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting shorten for %s!\n", name);
rh = GNUNET_malloc (sizeof (struct ResolverHandle));
rh->authority = *zone;
- rh->id = rid++;
- rh->priv_key = NULL;
- rh->namestore_task = NULL;
+ rh->id = rid_gen++;
rh->proc = &handle_delegation_ns_shorten;
rh->proc_cls = nsh;
- rh->id = rid++;
rh->private_local_zone = *zone;
GNUNET_CONTAINER_DLL_insert (nsh_head, nsh_tail, rh);
return;
}
- else if (is_gnunet_tld (name) == GNUNET_YES)
+ else if (is_gads_tld (name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"TLD is gnunet\n");
rh->authority_chain_tail = rh->authority_chain_head;
rh->authority_chain_head->zone = *zone;
-
/* Start delegation resolution in our namestore */
resolve_delegation_ns (rh);
}
free_resolver_handle (rh);
}
+
/**
* Process result from namestore delegation lookup
* for get authority operation
strcpy(nah->result, "");
finish_get_auth (rh, nah);
}
-
-
}
nah = GNUNET_malloc(sizeof (struct GetNameAuthorityHandle));
rh = GNUNET_malloc(sizeof (struct ResolverHandle));
rh->authority = zone;
- rh->id = rid++;
+ rh->id = rid_gen++;
rh->private_local_zone = pzone;
- rh->namestore_task = NULL;
GNUNET_CONTAINER_DLL_insert (nah_head, nah_tail, rh);
projects / oweals / gnunet.git / blobdiff