X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fgns%2Fgnunet-service-gns_resolver.c;h=7258f97a145db1d532cbae4ff7b4955ebdffe7c2;hb=9062e2e68f6675e65d45a1cc0d4cf7beac1ab007;hp=41c2c0de0c7b5a03c89ec48e806957ba8b7c7de9;hpb=00da095d9d83afea982baa79b8075a35d41be834;p=oweals%2Fgnunet.git diff --git a/src/gns/gnunet-service-gns_resolver.c b/src/gns/gnunet-service-gns_resolver.c index 41c2c0de0..7258f97a1 100644 --- a/src/gns/gnunet-service-gns_resolver.c +++ b/src/gns/gnunet-service-gns_resolver.c @@ -19,8 +19,6 @@ */ /** - * - * * @file gns/gnunet-service-gns_resolver.c * @brief GNUnet GNS resolver logic * @author Martin Schanzenbach @@ -31,14 +29,16 @@ #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 "../dns/dnsparser.h" #include "gnunet_gns_service.h" #include "block_gns.h" #include "gns.h" #include "gnunet-service-gns_resolver.h" -#define DHT_OPERATION_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 3) #define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT #define DHT_GNS_REPLICATION_LEVEL 5 #define MAX_DNS_LABEL_LENGTH 63 @@ -49,11 +49,194 @@ */ static struct GNUNET_NAMESTORE_Handle *namestore_handle; +/** + * Our handle to the vpn service + */ +static struct GNUNET_VPN_Handle *vpn_handle; + /** * Resolver handle to the dht */ static struct GNUNET_DHT_Handle *dht_handle; +/** + * Heap for parallel DHT lookups + */ +static struct GNUNET_CONTAINER_Heap *dht_lookup_heap; + +/** + * Heap for namestore queues + */ +static struct GNUNET_CONTAINER_Heap *ns_task_heap; + +/** + * Maximum amount of parallel queries in background + */ +static unsigned long long max_allowed_background_queries; + +/** + * Maximum amount of parallel namestore tasks in background + */ +static unsigned long long max_allowed_ns_tasks; + +/** + * Wheather or not to ignore pending records + */ +static int ignore_pending_records; + +/** + * Our local zone + */ +static struct GNUNET_CRYPTO_ShortHashCode local_zone; + +/** + * Background shortening handles + */ +static struct GetPseuAuthorityHandle *gph_head; + +/** + * Background shortening handles + */ +static struct GetPseuAuthorityHandle *gph_tail; + +/** + * Resolver lookup list + */ +static struct ResolverHandle *rlh_head; + +/** + * Resolver lookup list + */ +static struct ResolverHandle *rlh_tail; + +/** + * Resolver shorten list + */ +static struct ResolverHandle *nsh_head; + +/** + * Resolver shorten list + */ +static struct ResolverHandle *nsh_tail; + +/** + * Resolver get auth list + */ +static struct ResolverHandle *nah_head; + +/** + * Resolver get auth list + */ +static struct ResolverHandle *nah_tail; + +/** + * Global configuration. + */ +static const struct GNUNET_CONFIGURATION_Handle *cfg; + +/** + * a resolution identifier pool variable + * FIXME overflow? + * This is a non critical identifier useful for debugging + */ +static unsigned long long rid = 0; + +/* + * Check if name is in srv format (_x._y.xxx) + * + * @param name + * @return GNUNET_YES if true + */ +static int +is_srv (char* name) +{ + char* ndup; + int ret = GNUNET_YES; + + if (*name != '_') + return GNUNET_NO; + if (NULL == strstr (name, "._")) + return GNUNET_NO; + + 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; +} + +/** + * Determine if this name is canonical. + * i.e. + * a.b.gnunet = not canonical + * a = canonical + * + * @param name the name to test + * @return GNUNET_YES if canonical + */ +static int +is_canonical (char* name) +{ + char* ndup; + char* tok; + + ndup = GNUNET_strdup (name); + strtok (ndup, "."); + + for (tok = strtok (NULL, "."); tok != NULL; tok = strtok (NULL, ".")) + { + /* + * probably srv + */ + if (*tok == '_') + continue; + GNUNET_free (ndup); + return GNUNET_NO; + } + GNUNET_free (ndup); + return GNUNET_YES; +} + + +/** + * Callback that shortens authorities + * + * @param gph the handle containing the name to shorten + */ +static void +shorten_authority_chain (struct GetPseuAuthorityHandle *gph); + + +static void +create_pseu_cont (void* cls, int32_t success, const char* emsg) +{ + //FIXME do sth with error + struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls; + struct AuthorityChain *iter; + + gph->namestore_task = NULL; + do + { + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + } while (iter != NULL); + GNUNET_CRYPTO_rsa_key_free (gph->key); + GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph); + GNUNET_free (gph); +} + + /** * Namestore calls this function if we have record for this name. * (or with rd_count=0 to indicate no matches) @@ -67,7 +250,7 @@ static struct GNUNET_DHT_Handle *dht_handle; * @param signature the signature of the authority for the record data */ static void -process_pseu_lookup_ns(void* cls, +process_pseu_lookup_ns (void* cls, const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key, struct GNUNET_TIME_Absolute expiration, const char *name, unsigned int rd_count, @@ -76,51 +259,71 @@ process_pseu_lookup_ns(void* cls, { struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls; struct GNUNET_NAMESTORE_RecordData new_pkey; + struct AuthorityChain *iter; + gph->namestore_task = NULL; if (rd_count > 0) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Name %s already taken in NS!\n", name); - if (0 == strcmp(gph->name, name)) + "GNS_AUTO_PSEU: Name %s already taken in NS!\n", name); + if (0 == strcmp (gph->name, name)) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Intelligent replacement not implemented\n", name); - GNUNET_free(gph->new_name); - GNUNET_free(gph->name); - GNUNET_free(gph); + if (gph->ahead->next != NULL) + { + if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone, + &gph->our_zone)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n"); + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + shorten_authority_chain (gph); + return; + } + } + + /* Clean up */ + do + { + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + } while (iter != NULL); + GNUNET_CRYPTO_rsa_key_free (gph->key); + GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph); + GNUNET_free (gph); return; } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Trying delegated name %s\n", gph->name); - gph->new_name = gph->name; - GNUNET_NAMESTORE_lookup_record(namestore_handle, - &gph->zone, - gph->new_name, - GNUNET_GNS_RECORD_PSEU, - &process_pseu_lookup_ns, - gph); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_AUTO_PSEU: Trying delegated name %s\n", gph->name); + memcpy (gph->test_name, gph->name, strlen (gph->name)+1); + gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle, + &gph->our_zone, + gph->test_name, + GNUNET_NAMESTORE_TYPE_ANY, + &process_pseu_lookup_ns, + gph); return; } - /** name is free */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Name %s not taken in NS! Adding\n", gph->new_name); + /* name is free */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_AUTO_PSEU: Name %s not taken in NS! Adding\n", gph->test_name); - new_pkey.expiration = GNUNET_TIME_absolute_get_forever (); - new_pkey.data_size = sizeof(GNUNET_HashCode); - new_pkey.data = &gph->new_zone; + new_pkey.expiration_time = UINT64_MAX; + new_pkey.data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode); + new_pkey.data = &gph->ahead->zone; new_pkey.record_type = GNUNET_GNS_RECORD_PKEY; - GNUNET_NAMESTORE_record_create (namestore_handle, + new_pkey.flags = GNUNET_NAMESTORE_RF_AUTHORITY + | GNUNET_NAMESTORE_RF_PRIVATE + | GNUNET_NAMESTORE_RF_PENDING; + gph->namestore_task = GNUNET_NAMESTORE_record_create (namestore_handle, gph->key, - gph->new_name, + gph->test_name, &new_pkey, - NULL, //cont - NULL); //cls - GNUNET_free(gph->new_name); - GNUNET_free(gph->name); - GNUNET_free(gph); - + &create_pseu_cont, //cont + gph); //cls } /** @@ -130,31 +333,30 @@ process_pseu_lookup_ns(void* cls, * @param name the pseu result or NULL */ static void -process_pseu_result(struct GetPseuAuthorityHandle* gph, char* name) +process_pseu_result (struct GetPseuAuthorityHandle* gph, char* name) { if (NULL == name) { - gph->new_name = GNUNET_malloc(strlen(gph->name)+1); - memcpy(gph->new_name, name, strlen(gph->name)+1); + memcpy (gph->test_name, gph->ahead->name, strlen (gph->ahead->name)+1); } else { - gph->new_name = GNUNET_malloc(strlen(name)+1); - memcpy(gph->new_name, name, strlen(name)+1); + memcpy (gph->test_name, name, strlen(name)+1); } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Checking %s for collision in NS\n", gph->new_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_AUTO_PSEU: Checking %s for collision in NS\n", + gph->test_name); /** * Check for collision */ - GNUNET_NAMESTORE_lookup_record(namestore_handle, - &gph->zone, - gph->new_name, - GNUNET_GNS_RECORD_PSEU, - &process_pseu_lookup_ns, - gph); + gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle, + &gph->our_zone, + gph->test_name, + GNUNET_NAMESTORE_TYPE_ANY, + &process_pseu_lookup_ns, + gph); } /** @@ -168,11 +370,28 @@ handle_auth_discovery_timeout(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls; + struct AuthorityChain *iter; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "dht lookup for query PSEU timed out.\n"); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_GET_AUTH: dht lookup for query PSEU timed out.\n"); GNUNET_DHT_get_stop (gph->get_handle); - process_pseu_result(gph, NULL); + gph->get_handle = NULL; + + if (gph->ahead->next != NULL) + { + if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone, + &gph->our_zone)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n"); + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + shorten_authority_chain (gph); + return; + } + } + + process_pseu_result (gph, NULL); } /** @@ -192,7 +411,7 @@ handle_auth_discovery_timeout(void *cls, static void process_auth_discovery_dht_result(void* cls, struct GNUNET_TIME_Absolute exp, - const GNUNET_HashCode * key, + const struct GNUNET_HashCode * key, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, @@ -201,6 +420,7 @@ process_auth_discovery_dht_result(void* cls, size_t size, const void *data) { struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls; + struct AuthorityChain *iter; struct GNSNameRecordBlock *nrb; char* rd_data = (char*)data; char* name; @@ -208,63 +428,183 @@ process_auth_discovery_dht_result(void* cls, size_t rd_size; int i; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "got dht result (size=%d)\n", size); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_GET_AUTH: got dht result (size=%d)\n", size); + + /* stop lookup and timeout task */ + GNUNET_DHT_get_stop (gph->get_handle); + gph->get_handle = NULL; + GNUNET_SCHEDULER_cancel (gph->timeout); + if (data == NULL) { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "got dht result null!\n", size); - GNUNET_break(0); - GNUNET_free(gph->new_name); - GNUNET_free(gph->name); - GNUNET_free(gph); + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "GNS_GET_AUTH: got dht result null!\n", size); + + do + { + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + } while (iter != NULL); + GNUNET_CRYPTO_rsa_key_free (gph->key); + GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph); + GNUNET_free (gph); return; } nrb = (struct GNSNameRecordBlock*)data; - /* stop lookup and timeout task */ - GNUNET_DHT_get_stop (gph->get_handle); - GNUNET_SCHEDULER_cancel(gph->dht_timeout); - gph->get_handle = NULL; nrb = (struct GNSNameRecordBlock*)data; name = (char*)&nrb[1]; - num_records = ntohl(nrb->rd_count); + num_records = ntohl (nrb->rd_count); { struct GNUNET_NAMESTORE_RecordData rd[num_records]; - rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock); - rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock); + rd_data += strlen (name) + 1 + sizeof (struct GNSNameRecordBlock); + rd_size = size - strlen (name) - 1 - sizeof (struct GNSNameRecordBlock); if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size, rd_data, num_records, rd)) { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error deserializing data!\n"); - GNUNET_break(0); - GNUNET_free(gph->new_name); - GNUNET_free(gph->name); - GNUNET_free(gph); - return; + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "GNS_GET_AUTH: Error deserializing data!\n"); } - - for (i=0; iahead->next != NULL) + { + if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone, + &gph->our_zone)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n"); + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + shorten_authority_chain (gph); + return; + } + } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_GET_AUTH: finished shorten, no results!\n"); + process_pseu_result (gph, NULL); +} + +/** + * Process PSEU discovery for shorten via namestore + * + * @param cls the GetPseuAuthorityHandle + * @param key the public key + * @param expiration recorddata expiration + * @param name the looked up name + * @param rd_count number of records in set + * @param rd record data + * @param signature the signature + */ +static void +process_auth_discovery_ns_result(void* cls, + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key, + struct GNUNET_TIME_Absolute expiration, + const char *name, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) +{ + uint32_t xquery; + 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; + struct AuthorityChain *iter; + + gph->namestore_task = NULL; + /* no pseu found */ + if (rd_count == 0) + { + /** + * check dht + */ + GNUNET_CRYPTO_short_hash ("+", strlen ("+"), &name_hash); + GNUNET_CRYPTO_short_hash_double (&name_hash, &name_hash_double); + GNUNET_CRYPTO_short_hash_double (&gph->ahead->zone, &zone_hash_double); + GNUNET_CRYPTO_hash_xor (&name_hash_double, &zone_hash_double, &lookup_key); + GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_AUTO_PSEU: starting dht lookup for %s with key: %s\n", + "+", (char*)&lookup_key_string); + + gph->timeout = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT, + &handle_auth_discovery_timeout, gph); + + xquery = htonl (GNUNET_GNS_RECORD_PSEU); + + GNUNET_assert (gph->get_handle == NULL); + + gph->get_handle = GNUNET_DHT_get_start(dht_handle, + GNUNET_BLOCK_TYPE_GNS_NAMERECORD, + &lookup_key, + DHT_GNS_REPLICATION_LEVEL, + GNUNET_DHT_RO_NONE, + &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; + } + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: no pseu in namestore!\n"); + + if (gph->ahead->next != NULL) + { + if (GNUNET_CRYPTO_short_hash_cmp (&gph->ahead->next->zone, + &gph->our_zone)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GNS_GET_AUTH: trying next!\n"); + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + shorten_authority_chain (gph); + return; + } + } + + process_pseu_result (gph, NULL); } /** @@ -280,7 +620,7 @@ process_auth_discovery_dht_result(void* cls, * @param signature the signature for the record data */ static void -process_zone_to_name_discover(void *cls, +process_zone_to_name_discover (void *cls, const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, struct GNUNET_TIME_Absolute expire, const char *name, @@ -289,87 +629,99 @@ process_zone_to_name_discover(void *cls, const struct GNUNET_CRYPTO_RsaSignature *signature) { struct GetPseuAuthorityHandle* gph = (struct GetPseuAuthorityHandle*)cls; - + struct AuthorityChain *iter; + + gph->namestore_task = NULL; /* we found a match in our own zone */ if (rd_len != 0) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "name for zone in our root %d\n", strlen(name)); - GNUNET_free(gph->new_name); - GNUNET_free(gph->name); - GNUNET_free(gph); + "GNS_AUTO_PSEU: name for zone in our root %s\n", name); + + iter = gph->ahead; + do + { + iter = gph->ahead->next; + GNUNET_free (gph->ahead); + gph->ahead = iter; + } while (iter != NULL); + GNUNET_CRYPTO_rsa_key_free (gph->key); + GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, gph); + GNUNET_free (gph); } else { - /** - * No name found. - * check dht - */ - uint32_t xquery; - GNUNET_HashCode name_hash; - GNUNET_HashCode lookup_key; - struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string; - - GNUNET_CRYPTO_hash("+", strlen("+"), &name_hash); - GNUNET_CRYPTO_hash_xor(&name_hash, &gph->new_zone, &lookup_key); - GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string); - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "starting dht lookup for %s with key: %s\n", - "+", (char*)&lookup_key_string); - - gph->dht_timeout = GNUNET_SCHEDULER_add_delayed(DHT_LOOKUP_TIMEOUT, - &handle_auth_discovery_timeout, gph); - - xquery = htonl(GNUNET_GNS_RECORD_PSEU); - - gph->get_handle = GNUNET_DHT_get_start(dht_handle, - DHT_OPERATION_TIMEOUT, - GNUNET_BLOCK_TYPE_GNS_NAMERECORD, - &lookup_key, - DHT_GNS_REPLICATION_LEVEL, - GNUNET_DHT_RO_NONE, - &xquery, - sizeof(xquery), - &process_auth_discovery_dht_result, - gph); + gph->namestore_task = GNUNET_NAMESTORE_lookup_record (namestore_handle, + &gph->ahead->zone, + "+", + GNUNET_GNS_RECORD_PSEU, + &process_auth_discovery_ns_result, + gph); } + } /** - * Callback for new authories + * Callback that shortens authorities * - * @param name the name given by delegation - * @param zone the authority - * @param the private key of our authority + * @param gph the handle to the shorten request */ -static void process_discovered_authority(char* name, GNUNET_HashCode zone, - GNUNET_HashCode our_zone, - struct GNUNET_CRYPTO_RsaPrivateKey *key) +static void +shorten_authority_chain (struct GetPseuAuthorityHandle *gph) +{ + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_AUTO_PSEU: New authority %s discovered\n", + gph->ahead->name); + + gph->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + &gph->our_zone, + &gph->ahead->zone, + &process_zone_to_name_discover, + gph); + +} + +static void +start_shorten (struct AuthorityChain *atail, + struct GNUNET_CRYPTO_RsaPrivateKey *key) { + struct AuthorityChain *new_head = NULL; + struct AuthorityChain *new_tail = NULL; + struct AuthorityChain *iter; + struct AuthorityChain *acopy; struct GetPseuAuthorityHandle *gph; - size_t namelen; + struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey; + struct GNUNET_CRYPTO_RsaPrivateKeyBinaryEncoded *pb_key; + + /* First copy the authority chain in reverse order */ + for (iter = atail; iter != NULL; iter = iter->prev) + { + acopy = GNUNET_malloc (sizeof (struct AuthorityChain)); + memcpy (acopy, iter, sizeof (struct AuthorityChain)); + acopy->next = NULL; + acopy->prev = NULL; + GNUNET_CONTAINER_DLL_insert (new_head, new_tail, acopy); + } - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "New authority %s discovered\n", - name); + gph = GNUNET_malloc (sizeof (struct GetPseuAuthorityHandle)); - gph = GNUNET_malloc(sizeof(struct GetPseuAuthorityHandle)); - namelen = strlen(name) + 1; - gph->name = GNUNET_malloc(namelen); - memcpy(gph->name, name, namelen); + GNUNET_CRYPTO_rsa_key_get_public (key, &pkey); + pb_key = GNUNET_CRYPTO_rsa_encode_key (key); + gph->key = GNUNET_CRYPTO_rsa_decode_key ((char*)pb_key, ntohs (pb_key->len)); + //gph->key = key;//GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_RsaPrivateKey)); + //memcpy (gph->key, key, sizeof (struct GNUNET_CRYPTO_RsaPrivateKey)); - gph->new_zone = zone; - gph->zone = our_zone; - gph->key = key; + GNUNET_CRYPTO_short_hash (&pkey, + sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), + &gph->our_zone); + gph->ahead = new_head; - GNUNET_NAMESTORE_zone_to_name (namestore_handle, - &our_zone, - &gph->new_zone, - &process_zone_to_name_discover, - gph); + GNUNET_CONTAINER_DLL_insert (gph_head, gph_tail, gph); + shorten_authority_chain (gph); } /** @@ -377,52 +729,287 @@ static void process_discovered_authority(char* name, GNUNET_HashCode zone, * * @param nh the namestore handle * @param dh the dht handle + * @param lz the local zone's hash + * @param c configuration handle + * @param max_bg_queries maximum number of parallel background queries in dht + * @param ignore_pending ignore records that still require user confirmation + * on lookup * @return GNUNET_OK on success */ int -gns_resolver_init(struct GNUNET_NAMESTORE_Handle *nh, - struct GNUNET_DHT_Handle *dh) +gns_resolver_init (struct GNUNET_NAMESTORE_Handle *nh, + struct GNUNET_DHT_Handle *dh, + struct GNUNET_CRYPTO_ShortHashCode lz, + const struct GNUNET_CONFIGURATION_Handle *c, + unsigned long long max_bg_queries, + int ignore_pending) { + cfg = c; namestore_handle = nh; dht_handle = dh; + local_zone = lz; + dht_lookup_heap = + GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); + ns_task_heap = + GNUNET_CONTAINER_heap_create(GNUNET_CONTAINER_HEAP_ORDER_MIN); + max_allowed_background_queries = max_bg_queries; + max_allowed_ns_tasks = GNUNET_GNS_MAX_NS_TASKS; + + ignore_pending_records = ignore_pending; + + gph_head = NULL; + gph_tail = NULL; + rlh_head = NULL; + rlh_tail = NULL; + nsh_head = NULL; + nsh_tail = NULL; + nah_head = NULL; + nah_tail = NULL; + + GNUNET_RESOLVER_connect (cfg); + + if ((namestore_handle != NULL) && (dht_handle != NULL)) { return GNUNET_OK; } + return GNUNET_SYSERR; } /** - * Helper function to free resolver handle + * Cleanup ns tasks * - * @rh the handle to free + * @param cls closure to iterator + * @param node heap nodes + * @param element the namestorebgtask + * @param cost heap cost + * @return always GNUNET_YES */ -static void -free_resolver_handle(struct ResolverHandle* rh) +static int +cleanup_pending_ns_tasks(void* cls, + struct GNUNET_CONTAINER_HeapNode *node, + void *element, + GNUNET_CONTAINER_HeapCostType cost) { - struct AuthorityChain *ac; + struct NamestoreBGTask *nbg = (struct NamestoreBGTask *)element; + ResolverCleanupContinuation cont = cls; + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_CLEANUP: Terminating ns task\n"); + GNUNET_NAMESTORE_cancel (nbg->qe); + + GNUNET_CONTAINER_heap_remove_node(node); + + if (GNUNET_CONTAINER_heap_get_size(ns_task_heap) == 0) + cont(); + + return GNUNET_YES; +} + + +/** + * finish lookup + * + * @param rh resolver handle + * @param rlh record lookup handle + * @param rd_count number of results + * @param rd results + */ +static void +finish_lookup (struct ResolverHandle *rh, + struct RecordLookupHandle* rlh, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd); + + +/** + * Cleanup background lookups FIXME get rid of this?? + * + * @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 = (struct ResolverHandle *)element; + ResolverCleanupContinuation cont = cls; + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_CLEANUP-%llu: Terminating background lookup for %s\n", + rh->id, rh->name); + + //finish_lookup (rh, rh->proc_cls, 0, NULL); + //rh->get_handle = NULL; + //rh->proc(rh->proc_cls, rh, 0, NULL); + + GNUNET_CONTAINER_heap_remove_node(node); + + if (GNUNET_CONTAINER_heap_get_size(dht_lookup_heap) == 0) + { + if (GNUNET_CONTAINER_heap_get_size(ns_task_heap) == 0) + cont(); + else + { + GNUNET_CONTAINER_heap_iterate (ns_task_heap, + &cleanup_pending_ns_tasks, + cont); + } + } + + + return GNUNET_YES; +} + + +/** + * Helper function to free resolver handle + * + * @param rh the handle to free + */ +static void +free_resolver_handle (struct ResolverHandle* rh) +{ + struct AuthorityChain *ac; struct AuthorityChain *ac_next; if (NULL == rh) return; - GNUNET_free_non_null (rh->name); - GNUNET_free_non_null (rh->authority_name); - ac = rh->authority_chain_head; while (NULL != ac) { ac_next = ac->next; - GNUNET_free_non_null (ac->name); 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; + + 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)); GNUNET_free(rh); } +/** + * finish shorten + * + * @param rh resolver handle + * @param nsh name shorten handle + */ +static void +finish_shorten (struct ResolverHandle *rh, + struct NameShortenHandle *nsh); +/** + * finish get auth + * + * @param rh resolver handle + * @param nah get name authority handle + */ +static void +finish_get_auth (struct ResolverHandle *rh, + struct GetNameAuthorityHandle* rlh); +/** + * Shutdown resolver + */ +void +gns_resolver_cleanup (ResolverCleanupContinuation cont) +{ + unsigned int s; + struct GetPseuAuthorityHandle *tmp; + struct AuthorityChain *iter; + + + tmp = gph_head; + for (tmp = gph_head; tmp != NULL; tmp = gph_head) + { + if (tmp->get_handle != NULL) + GNUNET_DHT_get_stop (tmp->get_handle); + tmp->get_handle = NULL; + if (tmp->timeout != GNUNET_SCHEDULER_NO_TASK) + GNUNET_SCHEDULER_cancel (tmp->timeout); + tmp->timeout = GNUNET_SCHEDULER_NO_TASK; + + if (NULL != tmp->namestore_task) + GNUNET_NAMESTORE_cancel (tmp->namestore_task); + tmp->namestore_task = NULL; + + iter = tmp->ahead; + do + { + iter = tmp->ahead->next; + GNUNET_free (tmp->ahead); + tmp->ahead = iter; + } while (iter != NULL); + + GNUNET_CRYPTO_rsa_key_free (tmp->key); + GNUNET_CONTAINER_DLL_remove (gph_head, gph_tail, tmp); + GNUNET_free (tmp); + } + + while (NULL != rlh_head) + { + finish_lookup (rlh_head, rlh_head->proc_cls, 0, NULL); + } + + while (NULL != nsh_head) + { + finish_shorten (nsh_head, nsh_head->proc_cls); + } + + while (NULL != nah_head) + { + finish_get_auth (nah_head, nah_head->proc_cls); + } + + s = GNUNET_CONTAINER_heap_get_size(dht_lookup_heap); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_CLEANUP: %d pending background queries to terminate\n", s); + if (0 != s) + GNUNET_CONTAINER_heap_iterate (dht_lookup_heap, + &cleanup_pending_background_queries, + cont); + else if (0 != GNUNET_CONTAINER_heap_get_size(ns_task_heap)) + { + GNUNET_CONTAINER_heap_iterate (ns_task_heap, + &cleanup_pending_ns_tasks, + cont); + } + else + cont(); +} + + + + /** * Callback when record data is put into namestore * @@ -435,22 +1022,54 @@ on_namestore_record_put_result(void *cls, int32_t success, const char *emsg) { + struct NamestoreBGTask *nbg = cls; + + GNUNET_CONTAINER_heap_remove_node (nbg->node); + GNUNET_free (nbg); + if (GNUNET_NO == success) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "records already in namestore\n"); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_NS: records already in namestore\n"); return; } else if (GNUNET_YES == success) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "records successfully put in namestore\n"); + "GNS_NS: records successfully put in namestore\n"); return; } GNUNET_log(GNUNET_ERROR_TYPE_ERROR, - "Error putting records into namestore: %s\n", emsg); + "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) + rh->timeout_cont(rh->timeout_cont_cls, tc); } +/** + * Processor for background lookups in the DHT + * + * @param cls closure (NULL) + * @param rd_count number of records found (not 0) + * @param rd record data + */ +static void +background_lookup_result_processor(void *cls, + uint32_t rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd) +{ + //We could do sth verbose/more useful here but it doesn't make any difference + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_BG: background dht lookup finished. (%d results)\n", + rd_count); +} /** * Handle timeout for DHT requests @@ -462,12 +1081,37 @@ static void dht_lookup_timeout(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct ResolverHandle *rh = cls; + struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls; + char new_name[MAX_DNS_NAME_LENGTH]; GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "dht lookup for query %s timed out.\n", - rh->name); + "GNS_PHASE_REC-%llu: dht lookup for query %s (%llus)timed out.\n", + rh->id, rh->name, rh->timeout.rel_value); + /** + * Start resolution in bg + */ + //strcpy(new_name, rh->name); + //memcpy(new_name+strlen(new_name), GNUNET_GNS_TLD, strlen(GNUNET_GNS_TLD)); + GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s", + rh->name, GNUNET_GNS_TLD); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Starting background lookup for %s type %d\n", + rh->id, new_name, rlh->record_type); + + gns_resolver_lookup_record(rh->authority, + rh->private_local_zone, + rlh->record_type, + new_name, + NULL, + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_NO, + &background_lookup_result_processor, + NULL); + rh->timeout_task = GNUNET_SCHEDULER_NO_TASK; GNUNET_DHT_get_stop (rh->get_handle); + rh->get_handle = NULL; rh->proc(rh->proc_cls, rh, 0, NULL); } @@ -489,14 +1133,14 @@ dht_lookup_timeout(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) */ static void process_record_result_dht(void* cls, - struct GNUNET_TIME_Absolute exp, - const 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 GNUNET_TIME_Absolute exp, + const struct GNUNET_HashCode * key, + const struct GNUNET_PeerIdentity *get_path, + unsigned int get_path_length, + const struct GNUNET_PeerIdentity *put_path, + unsigned int put_path_length, + enum GNUNET_BLOCK_Type type, + size_t size, const void *data) { struct ResolverHandle *rh; struct RecordLookupHandle *rlh; @@ -506,71 +1150,95 @@ process_record_result_dht(void* cls, char* rd_data = (char*)data; int i; int rd_size; - - GNUNET_HashCode zone, name_hash; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "got dht result (size=%d)\n", size); - - if (data == NULL) - return; - //FIXME maybe check expiration here, check block type - rh = (struct ResolverHandle *)cls; + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: got dht result (size=%d)\n", rh->id, size); + + //FIXME maybe check expiration here, check block type + + rlh = (struct RecordLookupHandle *) rh->proc_cls; nrb = (struct GNSNameRecordBlock*)data; - + /* stop lookup and timeout task */ GNUNET_DHT_get_stop (rh->get_handle); - GNUNET_SCHEDULER_cancel(rh->dht_timeout_task); - + 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]; num_records = ntohl(nrb->rd_count); { struct GNUNET_NAMESTORE_RecordData rd[num_records]; + struct NamestoreBGTask *ns_heap_root; + struct NamestoreBGTask *namestore_bg_task; rd_data += strlen(name) + 1 + sizeof(struct GNSNameRecordBlock); rd_size = size - strlen(name) - 1 - sizeof(struct GNSNameRecordBlock); - + if (GNUNET_SYSERR == GNUNET_NAMESTORE_records_deserialize (rd_size, rd_data, num_records, rd)) { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error deserializing data!\n"); + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "GNS_PHASE_REC-%llu: Error deserializing data!\n", rh->id); return; } for (i=0; iname); + "GNS_PHASE_REC-%llu: Got name: %s (wanted %s)\n", + rh->id, name, rh->name); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got type: %d\n", - rd[i].record_type); + "GNS_PHASE_REC-%llu: Got type: %d (wanted %d)\n", + rh->id, rd[i].record_type, rlh->record_type); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got data length: %d\n", rd[i].data_size); + "GNS_PHASE_REC-%llu: Got data length: %d\n", + rh->id, rd[i].data_size); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got flag %d\n", rd[i].flags); - - if ((strcmp(name, rh->name) == 0) && - (rd[i].record_type == rlh->record_type)) + "GNS_PHASE_REC-%llu: Got flag %d\n", + rh->id, rd[i].flags); + + if ((strcmp(name, rh->name) == 0) && + (rd[i].record_type == rlh->record_type)) { rh->answered++; } } - GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); - GNUNET_CRYPTO_hash_xor(key, &name_hash, &zone); - /** * FIXME check pubkey against existing key in namestore? * https://gnunet.org/bugs/view.php?id=2179 */ + if (max_allowed_ns_tasks <= + GNUNET_CONTAINER_heap_get_size (ns_task_heap)) + { + ns_heap_root = GNUNET_CONTAINER_heap_remove_root (ns_task_heap); + GNUNET_NAMESTORE_cancel (ns_heap_root->qe); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Replacing oldest background ns task\n", + rh->id); + } + /* Save to namestore */ - GNUNET_NAMESTORE_record_put (namestore_handle, + namestore_bg_task = GNUNET_malloc (sizeof (struct NamestoreBGTask)); + namestore_bg_task->qe = GNUNET_NAMESTORE_record_put (namestore_handle, &nrb->public_key, name, exp, @@ -578,12 +1246,17 @@ process_record_result_dht(void* cls, rd, &nrb->signature, &on_namestore_record_put_result, //cont - NULL); //cls + namestore_bg_task); + + namestore_bg_task->node = GNUNET_CONTAINER_heap_insert (ns_task_heap, + namestore_bg_task, + GNUNET_TIME_absolute_get().abs_value); + if (rh->answered) - rh->proc(rh->proc_cls, rh, num_records, rd); - else - rh->proc(rh->proc_cls, rh, 0, NULL); + rh->proc(rh->proc_cls, rh, num_records, rd); + else + rh->proc(rh->proc_cls, rh, 0, NULL); } } @@ -596,36 +1269,89 @@ process_record_result_dht(void* cls, * @param rh the pending gns query context */ static void -resolve_record_dht(struct ResolverHandle *rh) +resolve_record_dht (struct ResolverHandle *rh) { uint32_t xquery; - GNUNET_HashCode name_hash; - GNUNET_HashCode lookup_key; + struct GNUNET_CRYPTO_ShortHashCode name_hash; + struct GNUNET_HashCode lookup_key; + struct GNUNET_HashCode name_hash_double; + struct GNUNET_HashCode zone_hash_double; struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string; struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls; - - GNUNET_CRYPTO_hash(rh->name, strlen(rh->name), &name_hash); - GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key); + struct ResolverHandle *rh_heap_root; + + GNUNET_CRYPTO_short_hash(rh->name, strlen(rh->name), &name_hash); + GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double); + GNUNET_CRYPTO_short_hash_double(&rh->authority, &zone_hash_double); + GNUNET_CRYPTO_hash_xor(&name_hash_double, &zone_hash_double, &lookup_key); GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string); - + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "starting dht lookup for %s with key: %s\n", - rh->name, (char*)&lookup_key_string); + "GNS_PHASE_REC-%llu: starting dht lookup for %s with key: %s\n", + rh->id, rh->name, (char*)&lookup_key_string); + + //rh->timeout_task = GNUNET_SCHEDULER_NO_TASK; + rh->dht_heap_node = NULL; + + if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value) + { + /** + * Update timeout if necessary + */ + if (rh->timeout_task == GNUNET_SCHEDULER_NO_TASK) + { - rh->dht_timeout_task = GNUNET_SCHEDULER_add_delayed(DHT_LOOKUP_TIMEOUT, - &dht_lookup_timeout, rh); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Adjusting timeout\n", rh->id); + /* + * Set timeout for authority lookup phase to 1/2 + */ + rh->timeout_task = GNUNET_SCHEDULER_add_delayed( + GNUNET_TIME_relative_divide(rh->timeout, 2), + &handle_lookup_timeout, + rh); + } + //rh->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT, + // &dht_lookup_timeout, + // rh); + rh->timeout_cont = &dht_lookup_timeout; + rh->timeout_cont_cls = rh; + } + else + { + if (max_allowed_background_queries <= + GNUNET_CONTAINER_heap_get_size (dht_lookup_heap)) + { + rh_heap_root = GNUNET_CONTAINER_heap_remove_root (dht_lookup_heap); + GNUNET_DHT_get_stop(rh_heap_root->get_handle); + rh_heap_root->get_handle = NULL; + rh_heap_root->dht_heap_node = NULL; + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Replacing oldest background query for %s\n", + rh->id, rh_heap_root->name); + rh_heap_root->proc(rh_heap_root->proc_cls, + rh_heap_root, + 0, + NULL); + } + rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap, + rh, + GNUNET_TIME_absolute_get().abs_value); + } xquery = htonl(rlh->record_type); + + GNUNET_assert(rh->get_handle == NULL); rh->get_handle = GNUNET_DHT_get_start(dht_handle, - DHT_OPERATION_TIMEOUT, - GNUNET_BLOCK_TYPE_GNS_NAMERECORD, - &lookup_key, - DHT_GNS_REPLICATION_LEVEL, - GNUNET_DHT_RO_NONE, - &xquery, - sizeof(xquery), - &process_record_result_dht, - rh); + GNUNET_BLOCK_TYPE_GNS_NAMERECORD, + &lookup_key, + DHT_GNS_REPLICATION_LEVEL, + GNUNET_DHT_RO_NONE, + &xquery, + sizeof(xquery), + &process_record_result_dht, + rh); } @@ -643,48 +1369,55 @@ resolve_record_dht(struct ResolverHandle *rh) * @param signature the signature of the authority for the record data */ static void -process_record_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) +process_record_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) { struct ResolverHandle *rh; struct RecordLookupHandle *rlh; struct GNUNET_TIME_Relative remaining_time; - GNUNET_HashCode zone; + struct GNUNET_CRYPTO_ShortHashCode zone; + struct GNUNET_TIME_Absolute et; + unsigned int i; rh = (struct ResolverHandle *) cls; rlh = (struct RecordLookupHandle *)rh->proc_cls; - GNUNET_CRYPTO_hash(key, - sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), - &zone); + + rh->namestore_task = NULL; + 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) { - rh->status |= EXISTS; - } - - if (remaining_time.rel_value == 0) - { - rh->status |= EXPIRED; + rh->status |= RSL_RECORD_EXISTS; + + if (remaining_time.rel_value == 0) + { + rh->status |= RSL_RECORD_EXPIRED; + } } - + if (rd_count == 0) { /** * Lookup terminated and no results */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Namestore lookup for %s terminated without results\n", name); + "GNS_PHASE_REC-%llu: Namestore lookup for %s terminated without results\n", + rh->id, name); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Record %s unknown in namestore\n", - rh->name); + "GNS_PHASE_REC-%llu: Record %s unknown in namestore\n", + rh->id, rh->name); /** * Our zone and no result? Cannot resolve TT */ @@ -694,41 +1427,50 @@ process_record_result_ns(void* cls, } else { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Processing additional result %s from namestore\n", name); - int i; + "GNS_PHASE_REC-%llu: Processing additional result %s from namestore\n", + rh->id, name); for (i=0; irecord_type) continue; - - if ((GNUNET_TIME_absolute_get_remaining (rd[i].expiration)).rel_value + + 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; + } + + 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, - "This record is expired. Skipping\n"); + "GNS_PHASE_REC-%llu: This record is expired. Skipping\n", + rh->id); continue; } - rh->answered++; - } - + /** * no answers found */ if (rh->answered == 0) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "No answers found. This is odd!\n"); + "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, "Found %d answer(s) to query!\n", - 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); } @@ -736,61 +1478,856 @@ process_record_result_ns(void* cls, /** - * The final phase of resolution. - * rh->name is a name that is canonical and we do not have a delegation. - * Query namestore for this record - * - * @param rh the pending lookup - */ -static void -resolve_record_ns(struct ResolverHandle *rh) -{ - struct RecordLookupHandle *rlh = (struct RecordLookupHandle *)rh->proc_cls; - - /** - * Try to resolve this record in our namestore. - * The name to resolve is now in rh->authority_name - * since we tried to resolve it to an authority - * and failed. - **/ - GNUNET_NAMESTORE_lookup_record(namestore_handle, - &rh->authority, - rh->name, - rlh->record_type, - &process_record_result_ns, - rh); -} - - -/** - * Handle timeout for DHT requests + * VPN redirect result callback * - * @param cls the request handle as closure - * @param tc the task context + * @param cls the resolver handle + * @param af the requested address family + * @param address in_addr(6) respectively */ static void -dht_authority_lookup_timeout(void *cls, - const struct GNUNET_SCHEDULER_TaskContext *tc) +process_record_result_vpn (void* cls, int af, const void *address) { struct ResolverHandle *rh = cls; + struct RecordLookupHandle *rlh; + struct GNUNET_NAMESTORE_RecordData rd; - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "dht lookup for query %s timed out.\n", - rh->name); + rlh = (struct RecordLookupHandle *)rh->proc_cls; - GNUNET_DHT_get_stop (rh->get_handle); - if (strcmp(rh->name, "") == 0) + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_VPN-%llu: Got answer from VPN to query!\n", + rh->id); + if (af == AF_INET) { - /* - * promote authority back to name and try to resolve record - */ - strcpy(rh->name, rh->authority_name); - } - rh->proc(rh->proc_cls, rh, 0, NULL); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Answer is IPv4!\n", + rh->id); + if (rlh->record_type != GNUNET_GNS_RECORD_A) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Requested record is not IPv4!\n", + rh->id); + rh->proc (rh->proc_cls, rh, 0, NULL); + return; + } + rd.record_type = GNUNET_GNS_RECORD_A; + rd.expiration_time = UINT64_MAX; /* FIXME: should probably pick something shorter... */ + rd.data = address; + rd.data_size = sizeof (struct in_addr); + rd.flags = 0; + rh->proc (rh->proc_cls, rh, 1, &rd); + return; + } + else if (af == AF_INET6) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Answer is IPv6!\n", + rh->id); + if (rlh->record_type != GNUNET_GNS_RECORD_AAAA) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Requested record is not IPv6!\n", + rh->id); + rh->proc (rh->proc_cls, rh, 0, NULL); + return; + } + rd.record_type = GNUNET_GNS_RECORD_AAAA; + rd.expiration_time = UINT64_MAX; /* FIXME: should probably pick something shorter... */ + rd.data = address; + rd.data_size = sizeof (struct in6_addr); + rd.flags = 0; + rh->proc (rh->proc_cls, rh, 1, &rd); + return; + } + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Got garbage from VPN!\n", + rh->id); + rh->proc (rh->proc_cls, rh, 0, NULL); } -/* Prototype */ -static void resolve_delegation_dht(struct ResolverHandle *rh); + + + +/** + * Process VPN lookup result for record + * + * @param cls the record lookup handle + * @param rh resolver handle + * @param rd_count number of results (1) + * @param rd record data containing the result + */ +static void +handle_record_vpn (void* cls, struct ResolverHandle *rh, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd) +{ + struct RecordLookupHandle* rlh = (struct RecordLookupHandle*) cls; + + if (rd_count == 0) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_VPN-%llu: VPN returned no records. (status: %d)!\n", + rh->id, + rh->status); + /* give up, cannot resolve */ + finish_lookup(rh, rlh, 0, NULL); + return; + } + + /* results found yay */ + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_VPN-%llu: Record resolved from VPN!", rh->id); + + finish_lookup(rh, rlh, rd_count, rd); +} + + +/** + * Sends a UDP dns query to a nameserver specified in the rh + * + * @param rh the resolver handle + */ +static void +send_dns_packet (struct ResolverHandle *rh); + + +static void +handle_dns_resolver (void *cls, + const struct sockaddr *addr, + socklen_t addrlen) +{ + struct ResolverHandle *rh = cls; + struct RecordLookupHandle *rlh = rh->proc_cls; + struct GNUNET_NAMESTORE_RecordData rd; + struct sockaddr_in *sai; + struct sockaddr_in6 *sai6; + + if (NULL == addr) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "No address found in DNS!\n"); + finish_lookup (rh, rlh, 0, NULL); + return; + } + + if (addrlen == sizeof (struct sockaddr_in)) + { + 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 + { + sai6 = (struct sockaddr_in6*) addr; + rd.record_type = GNUNET_GNS_RECORD_AAAA; + rd.data_size = sizeof (struct in6_addr); + rd.data = &sai6->sin6_addr; + } + + rd.expiration_time = UINT64_MAX; /* FIXME: should probably pick something shorter */ + rd.flags = 0; + + finish_lookup (rh, rlh, 1, &rd); + +} + +/** + * Resolve DNS name via local stub resolver + * + * @param rh the resolver handle + */ +static void +resolve_dns_name (struct ResolverHandle *rh) +{ + struct RecordLookupHandle *rlh = rh->proc_cls; + int af; + + if ((rlh->record_type != GNUNET_GNS_RECORD_A) && + (rlh->record_type != GNUNET_GNS_RECORD_AAAA)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Can only resolve A/AAAA via stub... abort\n"); + finish_lookup (rh, rlh, 0, NULL); + return; + } + + if (rlh->record_type == GNUNET_GNS_RECORD_A) + 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, + &handle_dns_resolver, + rh); +} + + +/** + * Read DNS udp packet from socket + * + * @param cls the resolver handle + * @param tc task context + */ +static void +read_dns_response (void *cls, + const struct GNUNET_SCHEDULER_TaskContext *tc) +{ + struct ResolverHandle *rh = cls; + struct RecordLookupHandle *rlh = rh->proc_cls; + char buf[UINT16_MAX]; + ssize_t r; + struct sockaddr_in addr; + socklen_t addrlen; + struct GNUNET_DNSPARSER_Packet *packet; + struct GNUNET_NAMESTORE_RecordData rd; + int found_delegation = GNUNET_NO; + int found_cname = GNUNET_NO; + char* delegation_name = NULL; + int zone_offset = 0; + int i; + + rh->dns_read_task = GNUNET_SCHEDULER_NO_TASK; + if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) + { + /* timeout or shutdown */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Terminating DNS query %d\n", tc->reason); + finish_lookup (rh, rlh, 0, NULL); + return; + } + + addrlen = sizeof (addr); + r = GNUNET_NETWORK_socket_recvfrom (rh->dns_sock, + buf, sizeof (buf), + (struct sockaddr*) &addr, + &addrlen); + + if (-1 == r) + { + GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "recvfrom"); + finish_lookup (rh, rlh, 0, NULL); + return; + } + + packet = GNUNET_DNSPARSER_parse (buf, r); + + if (NULL == packet) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Failed to parse DNS reply!\n"); + finish_lookup (rh, rlh, 0, NULL); + return; + } + + for (i = 0; i < packet->num_answers; i++) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Got record type %d (want %d)\n", + packet->answers[i].type, + rlh->record_type); + /* http://tools.ietf.org/html/rfc1034#section-3.6.2 */ + if (packet->answers[i].type == GNUNET_GNS_RECORD_CNAME) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "CNAME... restarting query with %s\n", + packet->answers[i].data.hostname + ); + strcpy (rh->dns_name, packet->answers[i].data.hostname); + found_cname = GNUNET_YES; + //send_dns_packet (rh); + //GNUNET_DNSPARSER_free_packet (packet); + continue; + } + + if ((packet->answers[i].type == rlh->record_type) && + (0 == strcmp (packet->answers[i].name, rh->dns_name))) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found record!\n"); + rd.data = packet->answers[i].data.raw.data; + rd.data_size = packet->answers[i].data.raw.data_len; + rd.record_type = packet->answers[i].type; + rd.flags = 0; + rd.expiration_time = packet->answers[i].expiration_time.abs_value; + finish_lookup (rh, rlh, 1, &rd); + GNUNET_DNSPARSER_free_packet (packet); + return; + } + } + + if (GNUNET_YES == found_cname) + { + zone_offset = strlen (rh->dns_name) - strlen (rh->dns_zone) - 1; + + if (0 > zone_offset) + zone_offset = 0; + + /* restart query with CNAME */ + if (0 == strcmp (rh->dns_name+zone_offset, rh->dns_zone)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Asking same server for %s\n", rh->dns_name); + send_dns_packet (rh); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Trying system resolver for %s\n", rh->dns_name); + resolve_dns_name (rh); + } + + GNUNET_DNSPARSER_free_packet (packet); + return; + } + + for (i = 0; i < packet->num_authority_records; i++) + { + + if (packet->authority_records[i].type == GNUNET_GNS_RECORD_NS) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Found NS delegation!\n"); + found_delegation = GNUNET_YES; + delegation_name = packet->authority_records[i].data.hostname; + break; + } + } + + for (i = 0; i < packet->num_additional_records; i++) + { + if (found_delegation == GNUNET_NO) + break; + + if ((packet->additional_records[i].type == GNUNET_GNS_RECORD_A) && + (0 == strcmp (packet->additional_records[i].name, delegation_name))) + { + GNUNET_assert (sizeof (struct in_addr) == + packet->authority_records[i].data.raw.data_len); + + rh->dns_addr.sin_addr = + *((struct in_addr*)packet->authority_records[i].data.raw.data); + send_dns_packet (rh); + GNUNET_DNSPARSER_free_packet (packet); + return; + } + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Nothing useful in DNS reply!\n"); + finish_lookup (rh, rlh, 0, NULL); + GNUNET_DNSPARSER_free_packet (packet); + return; +} + +/** + * Sends a UDP dns query to a nameserver specified in the rh + * + * @param rh the request handle + */ +static void +send_dns_packet (struct ResolverHandle *rh) +{ + struct GNUNET_NETWORK_FDSet *rset = 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); + + 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)); + + rh->dns_read_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT, + rh->timeout, //FIXME less? + rset, + NULL, + &read_dns_response, + rh); + + GNUNET_NETWORK_fdset_destroy (rset); + +} + +/** + * The final phase of resoution. + * We found a NS RR and want to resolve via DNS + * + * @param rh the pending lookup handle + * @param rd_count length of record data + * @param rd record data containing VPN RR + */ +static void +resolve_record_dns (struct ResolverHandle *rh, + int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd) +{ + 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; + + memset (&packet, 0, sizeof (struct GNUNET_DNSPARSER_Packet)); + + /* We cancel here as to not include the ns lookup in the timeout */ + if (rh->timeout_task != GNUNET_SCHEDULER_NO_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)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_DNS-%llu: Trying to shorten authority chain\n", + rh->id); + start_shorten (rh->authority_chain_tail, + rh->priv_key); + } + + for (i = 0; i < rd_count; i++) + { + /* Synthesize dns name */ + if (rd[i].record_type == GNUNET_GNS_RECORD_NS) + { + strcpy (rh->dns_zone, (char*)rd[i].data); + if (0 == strcmp (rh->name, "")) + strcpy (rh->dns_name, (char*)rd[i].data); + else + sprintf (rh->dns_name, "%s.%s", rh->name, (char*)rd[i].data); + } + /* The glue */ + if (rd[i].record_type == GNUNET_GNS_RECORD_A) + dnsip = *((struct in_addr*)rd[i].data); + } + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_DNS-%llu: Looking up %s from %s\n", + rh->id, + rh->dns_name, + inet_ntoa (dnsip)); + rh->dns_sock = GNUNET_NETWORK_socket_create (AF_INET, SOCK_DGRAM, 0); + if (rh->dns_sock == NULL) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_DNS-%llu: Error creating udp socket for dns!\n", + rh->id); + finish_lookup (rh, rlh, 0, NULL); + return; + } + + memset (&addr, 0, sizeof (struct sockaddr_in)); + sa = (struct sockaddr *) &addr; + sa->sa_family = AF_INET; + if (GNUNET_OK != GNUNET_NETWORK_socket_bind (rh->dns_sock, + sa, + sizeof (struct sockaddr_in))) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_DNS-%llu: Error binding udp socket for dns!\n", + rh->id); + 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; + memset (&flags, 0, sizeof (flags)); + flags.recursion_desired = 1; + flags.checking_disabled = 1; + packet.queries = &query; + packet.answers = NULL; + packet.authority_records = NULL; + packet.num_queries = 1; + packet.num_answers = 0; + packet.num_authority_records = 0; + packet.num_additional_records = 0; + packet.flags = flags; + packet.id = rh->id; + if (GNUNET_OK != GNUNET_DNSPARSER_pack (&packet, + 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; + } + + rh->dns_addr.sin_family = AF_INET; + rh->dns_addr.sin_port = htons (53); //domain + rh->dns_addr.sin_addr = dnsip; +#if HAVE_SOCKADDR_IN_SIN_LEN + rh->dns_addr.sin_len = (u_char) sizeof (struct sockaddr_in); +#endif + + send_dns_packet (rh); +} + + +/** + * The final phase of resoution. + * We found a VPN RR and want to request an IPv4/6 address + * + * @param rh the pending lookup handle + * @param rd_count length of record data + * @param rd record data containing VPN RR + */ +static void +resolve_record_vpn (struct ResolverHandle *rh, + int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd) +{ + struct RecordLookupHandle *rlh = rh->proc_cls; + struct GNUNET_HashCode serv_desc; + struct vpn_data* vpn; + int af; + + /* We cancel here as to not include the ns lookup in the timeout */ + if (rh->timeout_task != GNUNET_SCHEDULER_NO_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)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_VPN-%llu: Trying to shorten authority chain\n", + rh->id); + start_shorten (rh->authority_chain_tail, + rh->priv_key); + } + + vpn = (struct vpn_data*)rd->data; + + + GNUNET_CRYPTO_hash ((char*)&vpn[1], + strlen ((char*)&vpn[1]) + 1, + &serv_desc); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_VPN-%llu: proto %hu peer %s!\n", + rh->id, + ntohs (vpn->proto), + GNUNET_h2s (&vpn->peer)); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_VPN-%llu: service %s -> %s!\n", + rh->id, + (char*)&vpn[1], + GNUNET_h2s (&serv_desc)); + rh->proc = &handle_record_vpn; + + if (NULL == vpn_handle) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC_VPN-%llu: VPN not connected!\n", + rh->id); + finish_lookup (rh, rh->proc_cls, 0, NULL); + return; + } + + if (rlh->record_type == GNUNET_GNS_RECORD_A) + af = AF_INET; + else + af = AF_INET6; + + //FIXME timeout?? + if (NULL == vpn_handle) + { + vpn_handle = GNUNET_VPN_connect (cfg); + if (NULL == vpn_handle) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_INIT: Error connecting to VPN!\n"); + finish_lookup (rh, rh->proc_cls, 0, NULL); + return; + } + } + + + rh->vpn_handle = GNUNET_VPN_redirect_to_peer (vpn_handle, + af, ntohs (vpn->proto), + (struct GNUNET_PeerIdentity *)&vpn->peer, + &serv_desc, + GNUNET_NO, //nac + GNUNET_TIME_UNIT_FOREVER_ABS, //FIXME + &process_record_result_vpn, + rh); + +} + +/** + * The final phase of resolution. + * rh->name is a name that is canonical and we do not have a delegation. + * Query namestore for this record + * + * @param rh the pending lookup handle + */ +static void +resolve_record_ns(struct ResolverHandle *rh) +{ + 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) + { + 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)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Trying to shorten authority chain\n", + rh->id); + start_shorten (rh->authority_chain_tail, + rh->priv_key); + } + + /** + * Try to resolve this record in our namestore. + * The name to resolve is now in rh->authority_name + * since we tried to resolve it to an authority + * and failed. + **/ + rh->namestore_task = GNUNET_NAMESTORE_lookup_record(namestore_handle, + &rh->authority, + rh->name, + rlh->record_type, + &process_record_result_ns, + rh); +} + + + +/** + * Handle timeout for DHT requests + * + * @param cls the request handle as closure + * @param tc the task context + */ +static void +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]; + + 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) + { + 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 (strcmp(rh->name, "") == 0) + { + /* + * promote authority back to name and try to resolve record + */ + strcpy(rh->name, rh->authority_name); + rh->proc(rh->proc_cls, rh, 0, NULL); + return; + } + + /** + * 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)); + + 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, + new_name, + NULL, + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_NO, + &background_lookup_result_processor, + NULL); + + rh->proc(rh->proc_cls, rh, 0, NULL); +} + +/* Prototype */ +static void resolve_delegation_dht(struct ResolverHandle *rh); + +/* Prototype */ +static void resolve_delegation_ns(struct ResolverHandle *rh); + + +/** + * Namestore resolution for delegation finished. Processing result. + * + * @param cls the closure + * @param rh resolver handle + * @param rd_count number of results (always 0) + * @param rd record data (always NULL) + */ +static void +handle_delegation_ns(void* cls, struct ResolverHandle *rh, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd); + + +/** + * This is a callback function that checks for key revocation + * + * @param cls the pending query + * @param key the key of the zone we did the lookup + * @param expiration expiration date of the record data set in the namestore + * @param name the name for which we need an authority + * @param rd_count the number of records with 'name' + * @param rd the record data + * @param signature the signature of the authority for the record data + */ +static void +process_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) +{ + struct ResolverHandle *rh = cls; + struct GNUNET_TIME_Relative remaining_time; + int i; + + rh->namestore_task = NULL; + remaining_time = GNUNET_TIME_absolute_get_remaining (expiration); + + for (i = 0; i < rd_count; i++) + { + if (rd[i].record_type == GNUNET_GNS_RECORD_REV) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_REV-%llu: Zone has been revoked.\n", + rh->id); + rh->status |= RSL_PKEY_REVOKED; + rh->proc (rh->proc_cls, rh, 0, NULL); + return; + } + } + + if ((name == NULL) || + (remaining_time.rel_value == 0)) + { + 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) + { + 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); + + gns_resolver_lookup_record(rh->authority, + rh->private_local_zone, + GNUNET_GNS_RECORD_REV, + GNUNET_GNS_TLD, + NULL, + GNUNET_TIME_UNIT_FOREVER_REL, + GNUNET_NO, + &background_lookup_result_processor, + NULL); + } + } + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_REV-%llu: Revocation check passed\n", + rh->id); + /** + * We are done with PKEY resolution if name is empty + * else resolve again with new authority + */ + if (strcmp (rh->name, "") == 0) + rh->proc (rh->proc_cls, rh, rh->rd_count, &rh->rd); + else + resolve_delegation_ns (rh); + + return; +} + + +/** + * Callback when record data is put into namestore + * + * @param cls the closure + * @param success GNUNET_OK on success + * @param emsg the error message. NULL if SUCCESS==GNUNET_OK + */ +void +on_namestore_delegation_put_result(void *cls, + int32_t success, + const char *emsg) +{ + struct NamestoreBGTask *nbg = cls; + + GNUNET_CONTAINER_heap_remove_node (nbg->node); + GNUNET_free (nbg); + + if (GNUNET_NO == success) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_NS: records already in namestore\n"); + return; + } + else if (GNUNET_YES == success) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_NS: records successfully put in namestore\n"); + return; + } + + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "GNS_NS: Error putting records into namestore: %s\n", emsg); +} /** * Function called when we get a result from the dht @@ -811,7 +2348,7 @@ static void resolve_delegation_dht(struct ResolverHandle *rh); static void process_delegation_result_dht(void* cls, struct GNUNET_TIME_Absolute exp, - const GNUNET_HashCode * key, + const struct GNUNET_HashCode * key, const struct GNUNET_PeerIdentity *get_path, unsigned int get_path_length, const struct GNUNET_PeerIdentity *put_path, @@ -826,27 +2363,36 @@ process_delegation_result_dht(void* cls, char* rd_data = (char*) data; int i; int rd_size; - GNUNET_HashCode zone, name_hash; + 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, "Got DHT result\n"); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_DHT-%llu: Got DHT result\n", rh->id); if (data == NULL) return; - //FIXME check expiration? - - rh = (struct ResolverHandle *)cls; nrb = (struct GNSNameRecordBlock*)data; /* stop dht lookup and timeout task */ GNUNET_DHT_get_stop (rh->get_handle); - GNUNET_SCHEDULER_cancel(rh->dht_timeout_task); rh->get_handle = NULL; + + if (rh->dht_heap_node != NULL) + { + GNUNET_CONTAINER_heap_remove_node(rh->dht_heap_node); + rh->dht_heap_node = NULL; + } + num_records = ntohl(nrb->rd_count); name = (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); @@ -856,69 +2402,119 @@ process_delegation_result_dht(void* cls, num_records, rd)) { - GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Error deserializing data!\n"); + GNUNET_log(GNUNET_ERROR_TYPE_ERROR, + "GNS_PHASE_DELEGATE_DHT-%llu: Error deserializing data!\n", + rh->id); return; } GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got name: %s (wanted %s)\n", name, rh->authority_name); + "GNS_PHASE_DELEGATE_DHT-%llu: Got name: %s (wanted %s)\n", + rh->id, name, rh->authority_name); for (i=0; iauthority_name); + "GNS_PHASE_DELEGATE_DHT-%llu: Got name: %s (wanted %s)\n", + rh->id, name, rh->authority_name); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got type: %d (wanted %d)\n", - rd[i].record_type, GNUNET_GNS_RECORD_PKEY); + "GNS_PHASE_DELEGATE_DHT-%llu: Got type: %d (wanted %d)\n", + rh->id, rd[i].record_type, GNUNET_GNS_RECORD_PKEY); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got data length: %d\n", rd[i].data_size); + "GNS_PHASE_DELEGATE_DHT-%llu: Got data length: %d\n", + rh->id, rd[i].data_size); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got flag %d\n", rd[i].flags); + "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)) + { + /** + * This is a VPN,NS,CNAME entry. Let namestore handle this after caching + */ + if (strcmp(rh->name, "") == 0) + strcpy(rh->name, rh->authority_name); + else + GNUNET_snprintf(rh->name, MAX_DNS_NAME_LENGTH, "%s.%s", + rh->name, rh->authority_name); //FIXME ret + rh->answered = 1; + break; + } if ((strcmp(name, rh->authority_name) == 0) && (rd[i].record_type == GNUNET_GNS_RECORD_PKEY)) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Authority found in DHT\n"); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_DHT-%llu: Authority found in DHT\n", + rh->id); rh->answered = 1; - memcpy(&rh->authority, rd[i].data, sizeof(GNUNET_HashCode)); + memcpy(&rh->authority, rd[i].data, sizeof(struct GNUNET_CRYPTO_ShortHashCode)); struct AuthorityChain *auth = GNUNET_malloc(sizeof(struct AuthorityChain)); auth->zone = rh->authority; - auth->name = GNUNET_malloc(strlen(rh->authority_name)+1); 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); - /** call process new authority */ - if (rh->priv_key) - process_discovered_authority(name, auth->zone, - rh->authority_chain_tail->zone, - rh->priv_key); + if (NULL != rh->rd.data) + GNUNET_free ((void*)rh->rd.data); + + memcpy (&rh->rd, &rd[i], sizeof (struct GNUNET_NAMESTORE_RecordData)); + rh->rd.data = GNUNET_malloc (rd[i].data_size); + memcpy ((void*)(rh->rd.data), rd[i].data, rd[i].data_size); + rh->rd_count = 1; + + /** try to import pkey if private key available */ + //if (rh->priv_key && is_canonical (rh->name)) + // process_discovered_authority(name, auth->zone, + // rh->authority_chain_tail->zone, + // rh->priv_key); } } - GNUNET_CRYPTO_hash(name, strlen(name), &name_hash); - GNUNET_CRYPTO_hash_xor(key, &name_hash, &zone); + GNUNET_CRYPTO_short_hash(name, strlen(name), &name_hash); + GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double); + GNUNET_CRYPTO_hash_xor(key, &name_hash_double, &zone_hash_double); + GNUNET_CRYPTO_short_hash_from_truncation (&zone_hash_double, &zone); /* Save to namestore */ - if (0 != GNUNET_CRYPTO_hash_cmp(&rh->authority_chain_tail->zone, &zone)) + if (0 != GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_tail->zone, + &zone)) { - GNUNET_NAMESTORE_record_put (namestore_handle, + if (max_allowed_ns_tasks <= + GNUNET_CONTAINER_heap_get_size (ns_task_heap)) + { + ns_heap_root = GNUNET_CONTAINER_heap_remove_root (ns_task_heap); + GNUNET_NAMESTORE_cancel (ns_heap_root->qe); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_REC-%llu: Replacing oldest background ns task\n", + rh->id); + } + + namestore_bg_task = GNUNET_malloc (sizeof (struct NamestoreBGTask)); + + namestore_bg_task->node = GNUNET_CONTAINER_heap_insert (ns_task_heap, + namestore_bg_task, + GNUNET_TIME_absolute_get().abs_value); + namestore_bg_task->qe = GNUNET_NAMESTORE_record_put (namestore_handle, &nrb->public_key, name, exp, num_records, rd, &nrb->signature, - &on_namestore_record_put_result, //cont - NULL); //cls + &on_namestore_delegation_put_result, //cont + namestore_bg_task); //cls } } - + if (rh->answered) { rh->answered = 0; @@ -926,20 +2522,221 @@ process_delegation_result_dht(void* cls, * delegate * FIXME in this case. should we ask namestore again? */ + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "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) - rh->proc(rh->proc_cls, rh, 0, NULL); + { + /* Start shortening */ + if ((rh->priv_key != NULL) && + (is_canonical (rh->name) == GNUNET_YES)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_DHT-%llu: Trying to shorten authority chain\n", + rh->id); + start_shorten (rh->authority_chain_tail, + rh->priv_key); + } + } else - resolve_delegation_dht(rh); + rh->proc = &handle_delegation_ns; + + + /* 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 pkey but name exists + * promote back */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "DHT authority lookup found no match!\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) + strcpy(rh->name, rh->authority_name); + else + GNUNET_snprintf(rh->name, MAX_DNS_NAME_LENGTH, "%s.%s", + rh->name, rh->authority_name); //FIXME ret + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_DHT-%llu: %s restored\n", rh->id, rh->name); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_DHT-%llu: DHT authority lookup found no match!\n", + rh->id); rh->proc(rh->proc_cls, rh, 0, NULL); } +#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 + + +static void +expand_plus(char* dest, char* src, char* repl) +{ + char* pos; + unsigned int s_len = strlen(src)+1; + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_POSTPROCESS: Got %s to expand with %s\n", src, repl); + + if (s_len < 3) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_POSTPROCESS: %s to short\n", src); + + /* no postprocessing */ + memcpy(dest, src, s_len+1); + return; + } + + if (0 == strcmp(src+s_len-3, ".+")) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_POSTPROCESS: Expanding .+ in %s\n", src); + memset(dest, 0, s_len+strlen(repl)+strlen(GNUNET_GNS_TLD)); + strcpy(dest, src); + pos = dest+s_len-2; + strcpy(pos, repl); + pos += strlen(repl); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_POSTPROCESS: Expanded to %s\n", dest); + } + else + { + memcpy(dest, src, s_len+1); + } +} + +/** + * finish lookup + */ +static void +finish_lookup (struct ResolverHandle *rh, + struct RecordLookupHandle* rlh, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd) +{ + int i; + char new_rr_data[MAX_DNS_NAME_LENGTH]; + char new_mx_data[MAX_MX_LENGTH]; + char new_soa_data[MAX_SOA_LENGTH]; + char new_srv_data[MAX_SRV_LENGTH]; + struct srv_data *old_srv; + struct srv_data *new_srv; + struct soa_data *old_soa; + struct soa_data *new_soa; + struct GNUNET_NAMESTORE_RecordData p_rd[rd_count]; + char* repl_string; + char* pos; + unsigned int offset; + + if (rh->timeout_task != GNUNET_SCHEDULER_NO_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) + 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) + { + p_rd[i].data = rd[i].data; + continue; + } + + /** + * for all those records we 'should' + * also try to resolve the A/AAAA records (RFC1035) + * This is a feature and not important + */ + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_POSTPROCESS: Postprocessing\n"); + + if (strcmp(rh->name, "+") == 0) + repl_string = rlh->name; + else + repl_string = rlh->name+strlen(rh->name)+1; + + offset = 0; + if (rd[i].record_type == GNUNET_GNS_RECORD_MX) + { + memcpy (new_mx_data, (char*)rd[i].data, sizeof(uint16_t)); + offset = sizeof(uint16_t); + pos = new_mx_data+offset; + expand_plus(pos, (char*)rd[i].data+sizeof(uint16_t), + repl_string); + offset += strlen(new_mx_data+sizeof(uint16_t))+1; + p_rd[i].data = new_mx_data; + p_rd[i].data_size = offset; + } + else if (rd[i].record_type == GNUNET_GNS_RECORD_SRV) + { + /* + * Prio, weight and port + */ + new_srv = (struct srv_data*)new_srv_data; + old_srv = (struct srv_data*)rd[i].data; + new_srv->prio = old_srv->prio; + new_srv->weight = old_srv->weight; + new_srv->port = old_srv->port; + expand_plus((char*)&new_srv[1], (char*)&old_srv[1], + repl_string); + p_rd[i].data = new_srv_data; + p_rd[i].data_size = sizeof (struct srv_data) + strlen ((char*)&new_srv[1]) + 1; + } + else if (rd[i].record_type == GNUNET_GNS_RECORD_SOA) + { + /* expand mname and rname */ + old_soa = (struct soa_data*)rd[i].data; + new_soa = (struct soa_data*)new_soa_data; + memcpy (new_soa, old_soa, sizeof (struct soa_data)); + expand_plus((char*)&new_soa[1], (char*)&old_soa[1], repl_string); + offset = strlen ((char*)&new_soa[1]) + 1; + expand_plus((char*)&new_soa[1] + offset, + (char*)&old_soa[1] + strlen ((char*)&old_soa[1]) + 1, + repl_string); + p_rd[i].data_size = sizeof (struct soa_data) + + offset + + strlen ((char*)&new_soa[1] + offset); + p_rd[i].data = new_soa_data; + } + else + { + pos = new_rr_data; + expand_plus(pos, (char*)rd[i].data, repl_string); + p_rd[i].data_size = strlen(new_rr_data)+1; + p_rd[i].data = new_rr_data; + } + + } + + rlh->proc(rlh->proc_cls, rd_count, p_rd); + GNUNET_free(rlh); + free_resolver_handle (rh); +} /** * Process DHT lookup result for record. @@ -955,31 +2752,29 @@ handle_record_dht(void* cls, struct ResolverHandle *rh, const struct GNUNET_NAMESTORE_RecordData *rd) { struct RecordLookupHandle* rlh; + rlh = (struct RecordLookupHandle*)cls; if (rd_count == 0) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "No records for %s found in DHT. Aborting\n", - rh->name); + "GNS_PHASE_REC-%llu: No records for %s found in DHT. Aborting\n", + rh->id, rh->name); /* give up, cannot resolve */ - rlh->proc(rlh->proc_cls, 0, NULL); - GNUNET_free(rlh->name); - GNUNET_free(rlh); - free_resolver_handle(rh); + finish_lookup(rh, rlh, 0, NULL); return; } /* results found yay */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Record resolved from DHT!"); - rlh->proc(rlh->proc_cls, rd_count, rd); - GNUNET_free(rlh->name); - GNUNET_free(rlh); - free_resolver_handle(rh); + "GNS_PHASE_REC-%llu: Record resolved from DHT!", rh->id); + + finish_lookup(rh, rlh, rd_count, rd); } + + /** * Process namestore lookup result for record. * @@ -989,65 +2784,68 @@ handle_record_dht(void* cls, struct ResolverHandle *rh, * @param rd record data */ static void -handle_record_ns(void* cls, struct ResolverHandle *rh, - unsigned int rd_count, - const struct GNUNET_NAMESTORE_RecordData *rd) +handle_record_ns (void* cls, struct ResolverHandle *rh, + unsigned int rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd) { struct RecordLookupHandle* rlh; rlh = (struct RecordLookupHandle*) cls; + int check_dht = GNUNET_YES; + if (rd_count == 0) { - /* ns entry expired and not ours. try dht */ - if (rh->status & (EXPIRED | !EXISTS) && - GNUNET_CRYPTO_hash_cmp(&rh->authority_chain_head->zone, - &rh->authority_chain_tail->zone)) + 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; + + + if (rh->only_cached == GNUNET_YES) + check_dht = GNUNET_NO; + + if (GNUNET_YES == check_dht) { rh->proc = &handle_record_dht; resolve_record_dht(rh); return; } /* give up, cannot resolve */ - rlh->proc(rlh->proc_cls, 0, NULL); - GNUNET_free(rlh->name); - GNUNET_free(rlh); - free_resolver_handle(rh); + finish_lookup(rh, rlh, 0, NULL); return; } /* results found yay */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Record resolved from namestore!"); - rlh->proc(rlh->proc_cls, rd_count, rd); - GNUNET_free(rlh->name); - GNUNET_free(rlh); - free_resolver_handle(rh); - -} + "GNS_PHASE_REC-%llu: Record resolved from namestore!\n", rh->id); + finish_lookup(rh, rlh, rd_count, rd); -/** - * Determine if this name is canonical. - * i.e. - * a.b.gnunet = not canonical - * a = canonical - * - * @param name the name to test - * @return 1 if canonical - */ -static int -is_canonical(char* name) -{ - uint32_t len = strlen(name); - int i; - for (i=0; iname, "") == 0) { + if ((rlh->record_type == GNUNET_GNS_RECORD_PKEY)) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_DHT-%llu: Resolved queried PKEY via DHT.\n", + rh->id); + finish_lookup(rh, rlh, rd_count, rd); + return; + } /* We resolved full name for delegation. resolving record */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Resolved full name for delegation via DHT. resolving record '' in ns\n"); + "GNS_PHASE_DELEGATE_DHT-%llu: Resolved full name for delegation via DHT.\n", + rh->id); + strcpy(rh->name, "+\0"); rh->proc = &handle_record_ns; resolve_record_ns(rh); return; @@ -1111,22 +2947,21 @@ handle_delegation_dht(void* cls, struct ResolverHandle *rh, /** * we still have some left **/ - if (is_canonical(rh->name)) + if (is_canonical (rh->name) == GNUNET_YES) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Resolving canonical record %s in ns\n", rh->name); + "GNS_PHASE_DELEGATE_DHT-%llu: Resolving canonical record %s in ns\n", + rh->id, + rh->name); rh->proc = &handle_record_ns; resolve_record_ns(rh); return; } /* give up, cannot resolve */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Cannot fully resolve delegation for %s via DHT!\n", - rh->name); - rlh->proc(rlh->proc_cls, 0, NULL); - GNUNET_free(rlh->name); - GNUNET_free(rlh); - free_resolver_handle(rh); + "GNS_PHASE_DELEGATE_DHT-%llu: Cannot fully resolve delegation for %s via DHT!\n", + rh->id, rh->name); + finish_lookup(rh, rlh, 0, NULL); } @@ -1140,22 +2975,59 @@ static void resolve_delegation_dht(struct ResolverHandle *rh) { uint32_t xquery; - GNUNET_HashCode name_hash; - GNUNET_HashCode lookup_key; + struct GNUNET_CRYPTO_ShortHashCode name_hash; + struct GNUNET_HashCode name_hash_double; + struct GNUNET_HashCode zone_hash_double; + struct GNUNET_HashCode lookup_key; + struct ResolverHandle *rh_heap_root; - GNUNET_CRYPTO_hash(rh->authority_name, + pop_tld(rh->name, rh->authority_name); + GNUNET_CRYPTO_short_hash(rh->authority_name, strlen(rh->authority_name), &name_hash); - GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key); - - rh->dht_timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT, - &dht_authority_lookup_timeout, - rh); + GNUNET_CRYPTO_short_hash_double(&name_hash, &name_hash_double); + GNUNET_CRYPTO_short_hash_double(&rh->authority, &zone_hash_double); + GNUNET_CRYPTO_hash_xor(&name_hash_double, &zone_hash_double, &lookup_key); + + rh->dht_heap_node = NULL; + if (rh->timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value) + { + //rh->timeout_task = GNUNET_SCHEDULER_add_delayed (DHT_LOOKUP_TIMEOUT, + // &dht_authority_lookup_timeout, + // rh); + rh->timeout_cont = &dht_authority_lookup_timeout; + rh->timeout_cont_cls = rh; + } + else + { + if (max_allowed_background_queries <= + GNUNET_CONTAINER_heap_get_size (dht_lookup_heap)) + { + /* terminate oldest lookup */ + rh_heap_root = GNUNET_CONTAINER_heap_remove_root (dht_lookup_heap); + 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); + } + rh->dht_heap_node = GNUNET_CONTAINER_heap_insert (dht_lookup_heap, + 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, - DHT_OPERATION_TIMEOUT, GNUNET_BLOCK_TYPE_GNS_NAMERECORD, &lookup_key, DHT_GNS_REPLICATION_LEVEL, @@ -1177,37 +3049,189 @@ resolve_delegation_dht(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) { struct RecordLookupHandle* rlh; rlh = (struct RecordLookupHandle*) cls; + int check_dht = GNUNET_YES; + int s_len = 0; + + 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) + { + finish_lookup (rh, rlh, 0, NULL); + return; + } if (strcmp(rh->name, "") == 0) { + /* We resolved full name for delegation. resolving record */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Resolved full name for delegation. resolving record ''\n"); + "GNS_PHASE_DELEGATE_NS-%llu: Resolved full name for delegation.\n", + rh->id); + if (rh->status & RSL_CNAME_FOUND) + { + if (rlh->record_type == GNUNET_GNS_RECORD_CNAME) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Resolved queried CNAME in NS.\n", + rh->id); + strcpy (rh->name, rh->authority_name); + finish_lookup (rh, rlh, rd_count, rd); + return; + } + + /* A .+ CNAME */ + if (is_tld ((char*)rd->data, GNUNET_GNS_TLD_PLUS)) + { + s_len = strlen (rd->data) - 2; + memcpy (rh->name, rd->data, s_len); + rh->name[s_len] = '\0'; + resolve_delegation_ns (rh); + return; + } + else if (is_tld ((char*)rd->data, GNUNET_GNS_TLD_ZKEY)) + { + gns_resolver_lookup_record (rh->authority, + rh->private_local_zone, + rlh->record_type, + (char*)rd->data, + rh->priv_key, + rh->timeout, + rh->only_cached, + rlh->proc, + rlh->proc_cls); + GNUNET_free (rlh); + GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh); + free_resolver_handle (rh); + return; + } + else + { + //Try DNS resolver + strcpy (rh->dns_name, (char*)rd->data); + resolve_dns_name (rh); + return; + } + + } + else if (rh->status & RSL_DELEGATE_VPN) + { + if (rlh->record_type == GNUNET_GNS_RECORD_VPN) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Resolved queried VPNRR in NS.\n", + rh->id); + finish_lookup(rh, rlh, rd_count, rd); + return; + } + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: VPN delegation starting.\n", + rh->id); + GNUNET_assert (NULL != rd); + rh->proc = &handle_record_vpn; + resolve_record_vpn (rh, rd_count, rd); + return; + } + else if (rh->status & RSL_DELEGATE_NS) + { + if (rlh->record_type == GNUNET_GNS_RECORD_NS) + { + 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_assert (NULL != rd); + rh->proc = &handle_record_ns; + resolve_record_dns (rh, rd_count, rd); + return; + } + else if (rh->status & RSL_DELEGATE_PKEY) + { + if (rh->status & RSL_PKEY_REVOKED) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Resolved PKEY is revoked.\n", + rh->id); + finish_lookup (rh, rlh, 0, NULL); + return; + } + else if (rlh->record_type == GNUNET_GNS_RECORD_PKEY) + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Resolved queried PKEY in NS.\n", + rh->id); + finish_lookup(rh, rlh, rd_count, rd); + return; + } + } + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Resolving record +\n", + rh->id); + strcpy(rh->name, "+\0"); rh->proc = &handle_record_ns; resolve_record_ns(rh); return; } - + + if (rh->status & RSL_DELEGATE_NS) + { + if (rlh->record_type == GNUNET_GNS_RECORD_NS) + { + 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_assert (NULL != rd); + rh->proc = &handle_record_ns; + resolve_record_dns (rh, rd_count, rd); + return; + } + /** * we still have some left * check if authority in ns is fresh * and exists * or we are authority **/ - if ((rh->status & (EXISTS | !EXPIRED)) || - !GNUNET_CRYPTO_hash_cmp(&rh->authority_chain_head->zone, - &rh->authority_chain_tail->zone)) + + if ((rh->status & RSL_RECORD_EXISTS) && + !(rh->status & RSL_RECORD_EXPIRED)) + 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 (rh->only_cached == GNUNET_YES) + check_dht = GNUNET_NO; + + if (check_dht == GNUNET_NO) { - if (is_canonical(rh->name)) + if (is_canonical (rh->name) == GNUNET_YES) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Resolving canonical record %s\n", rh->name); + "GNS_PHASE_DELEGATE_NS-%llu: Resolving canonical record %s\n", + rh->id, + rh->name); rh->proc = &handle_record_ns; resolve_record_ns(rh); } @@ -1215,23 +3239,22 @@ handle_delegation_ns(void* cls, struct ResolverHandle *rh, { /* give up, cannot resolve */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Cannot fully resolve delegation for %s!\n", - rh->name); - rlh->proc(rlh->proc_cls, 0, NULL); + "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); } return; } - + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Trying to resolve delegation for %s via DHT\n", - rh->name); + "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); } -/* Prototype */ -static void resolve_delegation_ns(struct ResolverHandle *rh); - /** * This is a callback function that should give us only PKEY @@ -1248,7 +3271,7 @@ static void resolve_delegation_ns(struct ResolverHandle *rh); * @param signature the signature of the authority for the record data */ static void -process_delegation_result_ns(void* cls, +process_delegation_result_ns (void* cls, const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *key, struct GNUNET_TIME_Absolute expiration, const char *name, @@ -1258,28 +3281,38 @@ process_delegation_result_ns(void* cls, { struct ResolverHandle *rh; struct GNUNET_TIME_Relative remaining_time; - GNUNET_HashCode zone; - char* new_name; - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Got %d records from authority lookup\n", - rd_count); - + struct GNUNET_CRYPTO_ShortHashCode zone; + char new_name[MAX_DNS_NAME_LENGTH]; + unsigned int i; + struct GNUNET_TIME_Absolute et; + rh = (struct ResolverHandle *)cls; - GNUNET_CRYPTO_hash(key, - sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded), - &zone); + rh->namestore_task = NULL; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup\n", + rh->id, rd_count); + + 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) { - rh->status |= EXISTS; - } + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Records with name %s exist.\n", + rh->id, name); + rh->status |= RSL_RECORD_EXISTS; - if (remaining_time.rel_value == 0) - { - rh->status |= EXPIRED; + if (remaining_time.rel_value == 0) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n", + rh->id, name); + rh->status |= RSL_RECORD_EXPIRED; + } } /** @@ -1296,29 +3329,29 @@ process_delegation_result_ns(void* cls, * Promote this authority back to a name maybe it is * our record. */ - if (strcmp(rh->name, "") == 0) + if (strcmp (rh->name, "") == 0) { /* simply promote back */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Promoting %s back to name\n", rh->authority_name); - strcpy(rh->name, rh->authority_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n", + rh->id, rh->authority_name); + strcpy (rh->name, rh->authority_name); } else { /* add back to existing name */ - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Adding %s back to %s\n", - rh->authority_name, rh->name); - new_name = GNUNET_malloc(strlen(rh->name) - + strlen(rh->authority_name) + 2); - memset(new_name, 0, strlen(rh->name) + strlen(rh->authority_name) + 2); - strcpy(new_name, rh->name); - strcpy(new_name+strlen(new_name)+1, "."); - strcpy(new_name+strlen(new_name)+2, rh->authority_name); - GNUNET_free(rh->name); - rh->name = new_name; + 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", + rh->name, rh->authority_name); + strcpy (rh->name, new_name); + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: %s restored\n", + rh->id, rh->name); } - rh->proc(rh->proc_cls, rh, 0, NULL); + + rh->proc (rh->proc_cls, rh, 0, NULL); return; } @@ -1327,23 +3360,81 @@ process_delegation_result_ns(void* cls, * move on with query * Note only 1 pkey should have been returned.. anything else would be strange */ - int i; - for (i=0; iid); + + 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); + 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); + 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; + } - if ((GNUNET_TIME_absolute_get_remaining (rd[i].expiration)).rel_value + 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, "This pkey is expired.\n"); + 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, - "This dht entry is expired.\n"); + 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); + rh->proc (rh->proc_cls, rh, 0, NULL); return; } @@ -1353,34 +3444,69 @@ process_delegation_result_ns(void* cls, /** * Resolve rest of query with new authority */ - GNUNET_assert(rd[i].record_type == GNUNET_GNS_RECORD_PKEY); - memcpy(&rh->authority, rd[i].data, sizeof(GNUNET_HashCode)); - struct AuthorityChain *auth = GNUNET_malloc(sizeof(struct AuthorityChain)); + 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; - auth->name = GNUNET_malloc(strlen(rh->authority_name)+1); - memset(auth->name, 0, strlen(rh->authority_name)+1); - strcpy(auth->name, rh->authority_name); + 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)); - /** - * We are done with PKEY resolution if name is empty - * else resolve again with new authority - */ - if (strcmp(rh->name, "") == 0) - rh->proc(rh->proc_cls, rh, 0, NULL); - else - resolve_delegation_ns(rh); + 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 */ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Authority lookup successful but no PKEY... never get here\n"); - rh->proc(rh->proc_cls, rh, 0, NULL); + "GNS_PHASE_DELEGATE_NS-%llu: Authority lookup and no PKEY...\n", rh->id); + /** + * If we have found some records for the LAST label + * we return the results. Else null. + */ + if (strcmp (rh->name, "") == 0) + { + /* Start shortening */ + if ((rh->priv_key != NULL) && + (is_canonical (rh->name) == GNUNET_YES)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Trying to shorten authority chain\n", + rh->id); + start_shorten (rh->authority_chain_tail, + rh->priv_key); + } + /* simply promote back */ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n", + rh->id, rh->authority_name); + strcpy (rh->name, rh->authority_name); + rh->proc (rh->proc_cls, rh, rd_count, rd); + } + else + { + GNUNET_snprintf (new_name, MAX_DNS_NAME_LENGTH, + "%s.%s", rh->name, rh->authority_name); + strcpy (rh->name, new_name); + rh->proc (rh->proc_cls, rh, 0, NULL); + } } @@ -1390,15 +3516,16 @@ process_delegation_result_ns(void* cls, * @param rh the resolver handle */ static void -resolve_delegation_ns(struct ResolverHandle *rh) +resolve_delegation_ns (struct ResolverHandle *rh) { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Resolving delegation for %s\n", rh->name); + "GNS_PHASE_DELEGATE_NS-%llu: Resolving delegation for %s\n", + rh->id, rh->name); pop_tld(rh->name, rh->authority_name); - GNUNET_NAMESTORE_lookup_record(namestore_handle, + rh->namestore_task = GNUNET_NAMESTORE_lookup_record(namestore_handle, &rh->authority, rh->authority_name, - GNUNET_GNS_RECORD_PKEY, + GNUNET_GNS_RECORD_ANY, &process_delegation_result_ns, rh); @@ -1410,78 +3537,443 @@ resolve_delegation_ns(struct ResolverHandle *rh) * calls lookup result processor on result * * @param zone the root zone + * @param pzone the private local zone * @param record_type the record type to look up * @param name the name to look up + * @param key a private key for use with PSEU import (can be NULL) + * @param timeout timeout for resolution + * @param only_cached GNUNET_NO to only check locally not DHT for performance * @param proc the processor to call on result * @param cls the closure to pass to proc */ -void -gns_resolver_lookup_record(GNUNET_HashCode zone, - uint32_t record_type, - const char* name, - struct GNUNET_CRYPTO_RsaPrivateKey *key, - RecordLookupProcessor proc, - void* cls) +void +gns_resolver_lookup_record (struct GNUNET_CRYPTO_ShortHashCode zone, + struct GNUNET_CRYPTO_ShortHashCode pzone, + uint32_t record_type, + const char* name, + struct GNUNET_CRYPTO_RsaPrivateKey *key, + struct GNUNET_TIME_Relative timeout, + int only_cached, + RecordLookupProcessor proc, + void* cls) +{ + struct ResolverHandle *rh; + struct RecordLookupHandle* rlh; + char string_hash[MAX_DNS_LABEL_LENGTH]; + char nzkey[MAX_DNS_LABEL_LENGTH]; + char* nzkey_ptr = nzkey; + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Starting resolution for %s (type=%d)!\n", + name, record_type); + + + if ((is_canonical ((char*)name) == GNUNET_YES) && + (strcmp(GNUNET_GNS_TLD, name) != 0)) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "%s is canonical and not gnunet -> cannot resolve!\n", name); + proc(cls, 0, NULL); + return; + } + + 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->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); + + if (NULL == key) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "No shorten key for resolution\n"); + } + + if (timeout.rel_value != GNUNET_TIME_UNIT_FOREVER_REL.rel_value) + { + /* + * 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( + GNUNET_TIME_relative_divide(timeout, 2), + &handle_lookup_timeout, + rh); + rh->timeout_cont = &dht_authority_lookup_timeout; + rh->timeout_cont_cls = rh; + } + else + { + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "No timeout for query!\n"); + rh->timeout_task = GNUNET_SCHEDULER_NO_TASK; + } + + if (strcmp(GNUNET_GNS_TLD, name) == 0) + { + /** + * Only 'gnunet' given + */ + 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, + "TLD is zkey\n"); + /** + * This is a zkey tld + * build hash and use as initial authority + */ + memset(rh->name, 0, + strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY)); + memcpy(rh->name, name, + strlen(name)-strlen(GNUNET_GNS_TLD_ZKEY) - 1); + pop_tld(rh->name, string_hash); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "ZKEY is %s!\n", string_hash); + + GNUNET_STRINGS_utf8_toupper(string_hash, &nzkey_ptr); + + if (GNUNET_OK != GNUNET_CRYPTO_short_hash_from_string(nzkey, + &rh->authority)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Cannot convert ZKEY %s to hash!\n", string_hash); + + GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh); + GNUNET_free (rh); + GNUNET_free (rlh); + proc (cls, 0, NULL); + return; + } + + } + else if (is_gnunet_tld (name) == GNUNET_YES) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "TLD is gnunet\n"); + /** + * Presumably GNUNET tld + */ + memset (rh->name, 0, + strlen(name)-strlen(GNUNET_GNS_TLD)); + memcpy (rh->name, name, + strlen(name)-strlen(GNUNET_GNS_TLD) - 1); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Cannot handle this TLD %s\n", string_hash); + + if (GNUNET_SCHEDULER_NO_TASK != rh->timeout_task) + GNUNET_SCHEDULER_cancel (rh->timeout_task); + GNUNET_CONTAINER_DLL_remove (rlh_head, rlh_tail, rh); + GNUNET_free (rh); + GNUNET_free (rlh); + proc (cls, 0, NULL); + return; + } + } + + /** + * 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_tail = rh->authority_chain_head; + rh->authority_chain_head->zone = rh->authority; + strcpy (rh->authority_chain_head->name, ""); + + /** + * Copy original query into lookup handle + */ + rlh->record_type = record_type; + memset(rlh->name, 0, strlen(name) + 1); + strcpy(rlh->name, name); + rlh->proc = proc; + rlh->proc_cls = cls; + + rh->proc = &handle_delegation_ns; + resolve_delegation_ns(rh); +} + +/******** END Record Resolver ***********/ + +static void +finish_shorten (struct ResolverHandle *rh, + struct NameShortenHandle *nsh) +{ + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Sending %s as shorten result\n", nsh->result); + nsh->proc (nsh->proc_cls, nsh->result); + GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh); + GNUNET_free (nsh); + free_resolver_handle (rh); +} + + +/** + * Callback calles by namestore for a zone to name + * result + * + * @param cls the closure + * @param zone_key the zone we queried + * @param expire the expiration time of the name + * @param name the name found or NULL + * @param rd_len number of records for the name + * @param rd the record data (PKEY) for the name + * @param signature the signature for the record data + */ +static void +process_zone_to_name_shorten_root (void *cls, + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_len, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature); + + +/** + * Callback called by namestore for a zone to name + * result + * + * @param cls the closure + * @param zone_key the zone we queried + * @param expire the expiration time of the name + * @param name the name found or NULL + * @param rd_len number of records for the name + * @param rd the record data (PKEY) for the name + * @param signature the signature for the record data + */ +static void +process_zone_to_name_shorten_shorten (void *cls, + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_len, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) +{ + struct ResolverHandle *rh = (struct ResolverHandle *)cls; + struct NameShortenHandle* nsh = (struct NameShortenHandle*)rh->proc_cls; + struct AuthorityChain *next_authority; + + char result[MAX_DNS_NAME_LENGTH]; + char tmp_name[MAX_DNS_NAME_LENGTH]; + size_t answer_len; + + rh->namestore_task = NULL; + /* we found a match in our own root zone */ + if (rd_len != 0) + { + answer_len = strlen(rh->name) + strlen(name) + strlen(GNUNET_GNS_TLD) + 3; + memset(result, 0, answer_len); + + if (strlen(rh->name) > 0) + { + sprintf (result, "%s.%s.%s.%s", + rh->name, name, + nsh->shorten_zone_name, + GNUNET_GNS_TLD); + } + else + { + sprintf (result, "%s.%s.%s", name, + nsh->shorten_zone_name, + GNUNET_GNS_TLD); + } + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Found shorten result %s\n", result); + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + } + else if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone, + nsh->shorten_zone) == 0) + { + /** + * This is our zone append .gnunet unless name is empty + * (it shouldn't be, usually FIXME what happens if we + * shorten to our zone to a "" record??) + */ + + sprintf (result, "%s.%s.%s", + rh->name, + nsh->shorten_zone_name, + GNUNET_GNS_TLD); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Our zone: Found %s as shorten result\n", result); + + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + //nsh->proc(nsh->proc_cls, result); + //GNUNET_free(nsh); + //free_resolver_handle(rh); + //return; + } + + + /** + * No PSEU found. + * continue with next authority if exists + */ + if ((rh->authority_chain_head->next == NULL)) + { + finish_shorten (rh, nsh); + return; + } + next_authority = rh->authority_chain_head; + + GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH, + "%s.%s", rh->name, next_authority->name); + + strcpy(rh->name, tmp_name); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "No PSEU found for authority %s. Promoting back: %s\n", + next_authority->name, rh->name); + + GNUNET_CONTAINER_DLL_remove(rh->authority_chain_head, + rh->authority_chain_tail, + next_authority); + + GNUNET_free (next_authority); + + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + &rh->authority_chain_tail->zone, + &rh->authority_chain_head->zone, + &process_zone_to_name_shorten_root, + rh); +} + +/** + * Callback calles by namestore for a zone to name + * result + * + * @param cls the closure + * @param zone_key the zone we queried + * @param expire the expiration time of the name + * @param name the name found or NULL + * @param rd_len number of records for the name + * @param rd the record data (PKEY) for the name + * @param signature the signature for the record data + */ +static void +process_zone_to_name_shorten_private (void *cls, + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_len, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) { - struct ResolverHandle *rh; - struct RecordLookupHandle* rlh; - - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "Starting resolution for %s (type=%d)!\n", - name, record_type); + struct ResolverHandle *rh = (struct ResolverHandle *)cls; + struct NameShortenHandle* nsh = (struct NameShortenHandle*)rh->proc_cls; + struct AuthorityChain *next_authority; + char result[MAX_DNS_NAME_LENGTH]; + char tmp_name[MAX_DNS_NAME_LENGTH]; + size_t answer_len; - if (is_canonical((char*)name) && (strcmp(GNUNET_GNS_TLD, name) != 0)) + rh->namestore_task = NULL; + /* we found a match in our own root zone */ + if (rd_len != 0) { - GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, - "%s is canonical and gnunet not our TLD!\n", name); - proc(cls, 0, NULL); - return; - } - - rlh = GNUNET_malloc(sizeof(struct RecordLookupHandle)); - rh = GNUNET_malloc(sizeof (struct ResolverHandle)); + answer_len = strlen(rh->name) + strlen(name) + strlen(GNUNET_GNS_TLD) + 3; + memset(result, 0, answer_len); - rh->authority = zone; - rh->proc_cls = rlh; - rh->priv_key = key; + if (strlen(rh->name) > 0) + { + sprintf (result, "%s.%s.%s", rh->name, name, GNUNET_GNS_TLD); + } + else + { + sprintf (result, "%s.%s", name, GNUNET_GNS_TLD); + } + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Found shorten result %s\n", result); + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + } + else if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone, + nsh->private_zone) == 0) + { + /** + * This is our zone append .gnunet unless name is empty + * (it shouldn't be, usually FIXME what happens if we + * shorten to our zone to a "" record??) + */ + + sprintf (result, "%s.%s.%s", + rh->name, nsh->private_zone_name, GNUNET_GNS_TLD); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Our private zone: Found %s as shorten result %s\n", result); + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + } - if (strcmp(GNUNET_GNS_TLD, name) == 0) + if (0 != strcmp (nsh->shorten_zone_name, "")) { - rh->name = GNUNET_malloc(2); - strcpy(rh->name, ""); + /* backtrack authorities for names in priv zone */ + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + nsh->shorten_zone, + &rh->authority_chain_head->zone, + &process_zone_to_name_shorten_shorten, + rh); } else { - rh->name = GNUNET_malloc(strlen(name) - - strlen(GNUNET_GNS_TLD)); - memset(rh->name, 0, - strlen(name)-strlen(GNUNET_GNS_TLD)); - memcpy(rh->name, name, - strlen(name)-strlen(GNUNET_GNS_TLD) - 1); - } - - rh->authority_name = GNUNET_malloc(sizeof(char)*MAX_DNS_LABEL_LENGTH); - rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain)); - rh->authority_chain_head->prev = NULL; - rh->authority_chain_head->next = NULL; - rh->authority_chain_tail = rh->authority_chain_head; - rh->authority_chain_head->zone = zone; + /** + * No PSEU found. + * continue with next authority if exists + */ + if ((rh->authority_chain_head->next == NULL)) + { + finish_shorten (rh, nsh); + return; + } + next_authority = rh->authority_chain_head; + + GNUNET_snprintf(tmp_name, MAX_DNS_NAME_LENGTH, + "%s.%s", rh->name, next_authority->name); + + strcpy(rh->name, tmp_name); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "No PSEU found for authority %s. Promoting back: %s\n", + next_authority->name, rh->name); + + GNUNET_CONTAINER_DLL_remove(rh->authority_chain_head, + rh->authority_chain_tail, + next_authority); - rlh->record_type = record_type; - rlh->name = GNUNET_malloc(strlen(name) + 1); - memset(rlh->name, 0, strlen(name) + 1); - strcpy(rlh->name, name); //FIXME - rlh->proc = proc; - rlh->proc_cls = cls; + GNUNET_free (next_authority); - rh->proc = &handle_delegation_ns; - resolve_delegation_ns(rh); + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + &rh->authority_chain_tail->zone, + &rh->authority_chain_head->zone, + &process_zone_to_name_shorten_root, + rh); + } } -/******** END Record Resolver ***********/ - - /** * Callback calles by namestore for a zone to name * result @@ -1495,7 +3987,7 @@ gns_resolver_lookup_record(GNUNET_HashCode zone, * @param signature the signature for the record data */ static void -process_zone_to_name_shorten(void *cls, +process_zone_to_name_shorten_root (void *cls, const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, struct GNUNET_TIME_Absolute expire, const char *name, @@ -1507,80 +3999,96 @@ process_zone_to_name_shorten(void *cls, struct NameShortenHandle* nsh = (struct NameShortenHandle*)rh->proc_cls; struct AuthorityChain *next_authority; - char* result; - char* next_authority_name; + char result[MAX_DNS_NAME_LENGTH]; + char tmp_name[MAX_DNS_NAME_LENGTH]; size_t answer_len; - /* we found a match in our own zone */ + rh->namestore_task = NULL; + /* we found a match in our own root zone */ if (rd_len != 0) { - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "result strlen %d\n", strlen(name)); answer_len = strlen(rh->name) + strlen(name) + strlen(GNUNET_GNS_TLD) + 3; - result = GNUNET_malloc(answer_len); memset(result, 0, answer_len); + if (strlen(rh->name) > 0) { - strcpy(result, rh->name); - strcpy(result+strlen(rh->name), "."); + sprintf (result, "%s.%s.%s", rh->name, name, GNUNET_GNS_TLD); + } + else + { + sprintf (result, "%s.%s", name, GNUNET_GNS_TLD); } - - strcpy(result+strlen(result), name); - strcpy(result+strlen(result), "."); - strcpy(result+strlen(result), GNUNET_GNS_TLD); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Sending shorten result %s\n", result); - - nsh->proc(nsh->proc_cls, result); - GNUNET_free(nsh); - free_resolver_handle(rh); - GNUNET_free(result); + "Found shorten result %s\n", result); + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); } - else if (GNUNET_CRYPTO_hash_cmp(&rh->authority_chain_head->zone, - &rh->authority_chain_tail->zone)) + else if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone, + nsh->root_zone) == 0) { - /* our zone, just append .gnunet */ - answer_len = strlen(rh->name) + strlen(GNUNET_GNS_TLD) + 2; - result = GNUNET_malloc(answer_len); - memset(result, 0, answer_len); - strcpy(result, rh->name); - strcpy(result+strlen(rh->name), "."); - strcpy(result+strlen(rh->name)+1, GNUNET_GNS_TLD); - - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Our zone: Sending name as shorten result %s\n", rh->name); + /** + * This is our zone append .gnunet unless name is empty + * (it shouldn't be, usually FIXME what happens if we + * shorten to our zone to a "" record??) + */ - nsh->proc(nsh->proc_cls, result); - GNUNET_free(nsh); - free_resolver_handle(rh); - GNUNET_free(result); + sprintf (result, "%s.%s", rh->name, GNUNET_GNS_TLD); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Our zone: Found %s as shorten result\n", result); + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + } + + if (NULL != nsh->private_zone) + { + /* backtrack authorities for names in priv zone */ + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + nsh->private_zone, + &rh->authority_chain_head->zone, + &process_zone_to_name_shorten_private, + rh); + } + else if (NULL != nsh->shorten_zone) + { + /* backtrack authorities for names in shorten zone */ + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + nsh->shorten_zone, + &rh->authority_chain_head->zone, + &process_zone_to_name_shorten_shorten, + rh); } else { /** * No PSEU found. - * continue with next authority + * continue with next authority if exists */ + if ((rh->authority_chain_head->next == NULL)) + { + finish_shorten (rh, nsh); + return; + } next_authority = rh->authority_chain_head; - next_authority_name = GNUNET_malloc(strlen(rh->name)+ - strlen(next_authority->name) + 2); - memset(next_authority_name, 0, strlen(rh->name)+ - strlen(next_authority->name) + 2); - strcpy(next_authority_name, rh->name); - strcpy(next_authority_name+strlen(rh->name)+1, "."); - strcpy(next_authority_name+strlen(rh->name)+2, next_authority->name); - - GNUNET_free(rh->name); - rh->name = next_authority_name; + + 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, + "No PSEU found for authority %s. Promoting back: %s\n", + next_authority->name, rh->name); + GNUNET_CONTAINER_DLL_remove(rh->authority_chain_head, rh->authority_chain_tail, next_authority); - GNUNET_NAMESTORE_zone_to_name (namestore_handle, + GNUNET_free (next_authority); + + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, &rh->authority_chain_tail->zone, &rh->authority_chain_head->zone, - &process_zone_to_name_shorten, + &process_zone_to_name_shorten_root, rh); } } @@ -1596,14 +4104,13 @@ process_zone_to_name_shorten(void *cls, * @param rd data (NULL) */ void -handle_delegation_ns_shorten(void* cls, +handle_delegation_ns_shorten (void* cls, struct ResolverHandle *rh, uint32_t rd_count, const struct GNUNET_NAMESTORE_RecordData *rd) { struct NameShortenHandle *nsh; - char* result; - size_t answer_len; + char result[MAX_DNS_NAME_LENGTH]; nsh = (struct NameShortenHandle *)cls; @@ -1616,98 +4123,310 @@ handle_delegation_ns_shorten(void* cls, GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "PKEY resolved as far as possible in ns up to %s!\n", rh->name); + memset(result, 0, sizeof (result)); - if (GNUNET_CRYPTO_hash_cmp(&rh->authority_chain_head->zone, - &rh->authority_chain_tail->zone) == 0) + if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone, + nsh->root_zone) == 0) { /** * This is our zone append .gnunet unless name is empty * (it shouldn't be, usually FIXME what happens if we * shorten to our zone to a "" record??) - **/ + */ - answer_len = strlen(rh->name) + strlen(GNUNET_GNS_TLD) + 2; - result = GNUNET_malloc(answer_len); - memset(result, 0, answer_len); - strcpy(result, rh->name); - strcpy(result+strlen(rh->name), "."); - strcpy(result+strlen(rh->name)+1, GNUNET_GNS_TLD); - + sprintf (result, "%s.%s", rh->name, GNUNET_GNS_TLD); GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Our zone: Sending name as shorten result %s\n", rh->name); + "Our zone: Found %s as shorten result\n", result); - nsh->proc(nsh->proc_cls, result); - GNUNET_free(nsh); - free_resolver_handle(rh); - GNUNET_free(result); - return; + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + + } + else if (NULL != nsh->private_zone) + { + /** + * This is our zone append .gnunet unless name is empty + * (it shouldn't be, usually FIXME what happens if we + * shorten to our zone to a "" record??) + */ + if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone, + nsh->private_zone) == 0) + { + + sprintf (result, "%s.%s.%s", + rh->name, nsh->private_zone_name, GNUNET_GNS_TLD); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Our zone: Found %s as shorten result in private zone %s\n", + result); + + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + } + } + else if (NULL != nsh->shorten_zone) + { + /** + * This is our zone append .gnunet unless name is empty + * (it shouldn't be, usually FIXME what happens if we + * shorten to our zone to a "" record??) + */ + if (GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone, + nsh->shorten_zone) == 0) + { + sprintf (result, "%s.%s.%s", + rh->name, nsh->private_zone_name, GNUNET_GNS_TLD); + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Our zone: Found %s as shorten result in shorten zone\n", + result); + + if (strlen (nsh->result) > strlen (result)) + strcpy (nsh->result, result); + } } + /* backtrack authorities for names */ - GNUNET_NAMESTORE_zone_to_name (namestore_handle, - &rh->authority_chain_tail->zone, //ours + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + nsh->root_zone, &rh->authority_chain_head->zone, - &process_zone_to_name_shorten, + &process_zone_to_name_shorten_root, rh); + +} + + +/** + * Callback calles by namestore for a zone to name + * result + * + * @param cls the closure + * @param zone_key the zone we queried + * @param expire the expiration time of the name + * @param name the name found or NULL + * @param rd_len number of records for the name + * @param rd the record data (PKEY) for the name + * @param signature the signature for the record data + */ +static void +process_zone_to_name_zkey(void *cls, + const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *zone_key, + struct GNUNET_TIME_Absolute expire, + const char *name, + unsigned int rd_len, + const struct GNUNET_NAMESTORE_RecordData *rd, + const struct GNUNET_CRYPTO_RsaSignature *signature) +{ + struct ResolverHandle *rh = cls; + struct NameShortenHandle *nsh = rh->proc_cls; + struct GNUNET_CRYPTO_ShortHashAsciiEncoded enc; + char new_name[MAX_DNS_NAME_LENGTH]; + + /* zkey not in our zone */ + if (name == NULL) + { + /** + * In this case we have not given this PKEY a name (yet) + * It is either just not in our zone or not even cached + * Since we do not know at this point we will not try to shorten + * because PKEY import will happen if the user follows the zkey + * link. + */ + GNUNET_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) + 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); + + finish_shorten (rh, nsh); + return; + } + + if (strcmp(rh->name, "") != 0) + GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s", + rh->name, name); + else + strcpy(new_name, name); + + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Continue shorten for %s!\n", new_name); + strcpy(rh->name, new_name); + + rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain)); + rh->authority_chain_tail = rh->authority_chain_head; + rh->authority_chain_head->zone = rh->authority; + + + /* Start delegation resolution in our namestore */ + resolve_delegation_ns (rh); } + /** * Shorten api from resolver * - * @param zone the zone to use + * @param zone the root zone to use + * @param pzone the private zone to use + * @param szone the shorten zone to use * @param name the name to shorten + * @param private_zone_name name of the private zone + * @param shorten_zone_name name of the shorten zone * @param proc the processor to call with result - * @param cls closure to pass to proc + * @param proc_cls closure to pass to proc */ void -gns_resolver_shorten_name(GNUNET_HashCode zone, - const char* name, - ShortenResultProcessor proc, - void* cls) +gns_resolver_shorten_name (struct GNUNET_CRYPTO_ShortHashCode *zone, + struct GNUNET_CRYPTO_ShortHashCode *pzone, + struct GNUNET_CRYPTO_ShortHashCode *szone, + const char* name, + const char* private_zone_name, + const char* shorten_zone_name, + ShortenResultProcessor proc, + void* proc_cls) { struct ResolverHandle *rh; struct NameShortenHandle *nsh; + char string_hash[MAX_DNS_LABEL_LENGTH]; + struct GNUNET_CRYPTO_ShortHashCode zkey; + char nzkey[MAX_DNS_LABEL_LENGTH]; + char* nzkey_ptr = nzkey; + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Starting shorten for %s!\n", name); - if (is_canonical((char*)name)) + if (is_canonical ((char*)name) == GNUNET_YES) { GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "%s is canonical. Returning verbatim\n", name); - proc(cls, name); + proc (proc_cls, name); return; } - nsh = GNUNET_malloc(sizeof (struct NameShortenHandle)); - + nsh = GNUNET_malloc (sizeof (struct NameShortenHandle)); nsh->proc = proc; - nsh->proc_cls = cls; + nsh->proc_cls = proc_cls; + nsh->root_zone = zone; + nsh->private_zone = pzone; + nsh->shorten_zone = szone; + strcpy (nsh->private_zone_name, private_zone_name); + strcpy (nsh->shorten_zone_name, shorten_zone_name); + strcpy (nsh->result, name); - rh = GNUNET_malloc(sizeof (struct ResolverHandle)); - rh->authority = zone; - rh->name = GNUNET_malloc(strlen(name) - - strlen(GNUNET_GNS_TLD)); - memset(rh->name, 0, - strlen(name)-strlen(GNUNET_GNS_TLD)); - memcpy(rh->name, name, - strlen(name)-strlen(GNUNET_GNS_TLD)-1); - - rh->authority_name = GNUNET_malloc(sizeof(char)*MAX_DNS_LABEL_LENGTH); - rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain)); - rh->authority_chain_tail = rh->authority_chain_head; - rh->authority_chain_head->zone = zone; + + rh = GNUNET_malloc (sizeof (struct ResolverHandle)); + rh->authority = *zone; + rh->id = rid++; + rh->priv_key = NULL; + rh->namestore_task = NULL; 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); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "Checking for TLD...\n"); + if (is_zkey_tld (name) == GNUNET_YES) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "TLD is zkey\n"); + /** + * This is a zkey tld + * build hash and use as initial authority + * FIXME sscanf + */ + memset (rh->name, 0, + strlen (name)-strlen (GNUNET_GNS_TLD_ZKEY)); + memcpy (rh->name, name, + strlen(name)-strlen (GNUNET_GNS_TLD_ZKEY) - 1); + pop_tld (rh->name, string_hash); + + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "ZKEY is %s!\n", string_hash); + + GNUNET_STRINGS_utf8_toupper (string_hash, &nzkey_ptr); + + if (GNUNET_OK != GNUNET_CRYPTO_short_hash_from_string (nzkey, + &zkey)) + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, + "Cannot convert ZKEY %s to hash!\n", nzkey); + GNUNET_free (rh); + GNUNET_free (nsh); + GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh); + proc (proc_cls, name); + return; + } + + rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle, + zone, //ours + &zkey, + &process_zone_to_name_zkey, + rh); + return; + + } + else if (is_gnunet_tld (name) == GNUNET_YES) + { + GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, + "TLD is gnunet\n"); + /** + * Presumably GNUNET tld + */ + memset (rh->name, 0, + strlen (name)-strlen (GNUNET_GNS_TLD)); + memcpy (rh->name, name, + strlen (name)-strlen (GNUNET_GNS_TLD) - 1); + } + else + { + GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unknown TLD in %s\n", name); + GNUNET_free (rh); + GNUNET_free (nsh); + GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh); + proc (proc_cls, name); + return; + } + + rh->authority_chain_head = GNUNET_malloc (sizeof (struct AuthorityChain)); + rh->authority_chain_tail = rh->authority_chain_head; + rh->authority_chain_head->zone = *zone; + /* Start delegation resolution in our namestore */ - resolve_delegation_ns(rh); + resolve_delegation_ns (rh); } /*********** END NAME SHORTEN ********************/ +/** + * Conclude get authority lookup + * + * @param rh resolver handle + * @param nah get authority lookup handle + */ +static void +finish_get_auth (struct ResolverHandle *rh, + struct GetNameAuthorityHandle *nah) +{ + GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, + "Got authority result %s\n", nah->result); + + nah->proc(nah->proc_cls, nah->result); + GNUNET_CONTAINER_DLL_remove (nah_head, nah_tail, rh); + GNUNET_free(nah); + free_resolver_handle(rh); +} /** * Process result from namestore delegation lookup @@ -1725,7 +4444,6 @@ handle_delegation_result_ns_get_auth(void* cls, const struct GNUNET_NAMESTORE_RecordData *rd) { struct GetNameAuthorityHandle* nah; - char* result; size_t answer_len; nah = (struct GetNameAuthorityHandle*) rh->proc_cls; @@ -1742,7 +4460,7 @@ handle_delegation_result_ns_get_auth(void* cls, GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Building response!\n"); - if (is_canonical(rh->name)) + if (is_canonical (rh->name) == GNUNET_YES) { /** * We successfully resolved the authority in the ns @@ -1759,27 +4477,17 @@ handle_delegation_result_ns_get_auth(void* cls, answer_len = strlen(nah->name) - strlen(rh->name) + strlen(GNUNET_GNS_TLD) + 1; - result = GNUNET_malloc(answer_len); - memset(result, 0, answer_len); - strcpy(result, nah->name + strlen(rh->name) + 1); + memset(nah->result, 0, answer_len); + strcpy(nah->result, nah->name + strlen(rh->name) + 1); - GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, - "Got authority result %s\n", result); - - nah->proc(nah->proc_cls, result); - GNUNET_free(nah->name); - GNUNET_free(nah); - free_resolver_handle(rh); - GNUNET_free(result); + finish_get_auth (rh, nah); } else { GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Unable to resolve authority for remaining %s!\n", rh->name); - nah->proc(nah->proc_cls, ""); - GNUNET_free(nah->name); - GNUNET_free(nah); - free_resolver_handle(rh); + strcpy(nah->result, ""); + finish_get_auth (rh, nah); } @@ -1791,15 +4499,17 @@ handle_delegation_result_ns_get_auth(void* cls, * in our namestore * * @param zone the root zone to look up for + * @param pzone the private local zone * @param name the name to lookup up * @param proc the processor to call when finished - * @param cls the closure to pass to the processor + * @param proc_cls the closure to pass to the processor */ void -gns_resolver_get_authority(GNUNET_HashCode zone, +gns_resolver_get_authority(struct GNUNET_CRYPTO_ShortHashCode zone, + struct GNUNET_CRYPTO_ShortHashCode pzone, const char* name, GetAuthorityResultProcessor proc, - void* cls) + void* proc_cls) { struct ResolverHandle *rh; struct GetNameAuthorityHandle *nah; @@ -1810,29 +4520,28 @@ gns_resolver_get_authority(GNUNET_HashCode zone, nah = GNUNET_malloc(sizeof (struct GetNameAuthorityHandle)); rh = GNUNET_malloc(sizeof (struct ResolverHandle)); rh->authority = zone; + rh->id = rid++; + rh->private_local_zone = pzone; + rh->namestore_task = NULL; + + GNUNET_CONTAINER_DLL_insert (nah_head, nah_tail, rh); if (strcmp(GNUNET_GNS_TLD, name) == 0) { - rh->name = GNUNET_malloc(2); - strcpy(rh->name, ""); + strcpy(rh->name, "\0"); } else { - rh->name = GNUNET_malloc(strlen(name) - - strlen(GNUNET_GNS_TLD)); memset(rh->name, 0, strlen(name)-strlen(GNUNET_GNS_TLD)); memcpy(rh->name, name, strlen(name)-strlen(GNUNET_GNS_TLD) - 1); } - nah->name = GNUNET_malloc(strlen(name)+1); memset(nah->name, 0, strlen(name)+1); strcpy(nah->name, name); - rh->authority_name = GNUNET_malloc(MAX_DNS_LABEL_LENGTH); - rh->authority_chain_head = GNUNET_malloc(sizeof(struct AuthorityChain)); rh->authority_chain_tail = rh->authority_chain_head; rh->authority_chain_head->zone = zone; @@ -1840,7 +4549,8 @@ gns_resolver_get_authority(GNUNET_HashCode zone, rh->proc_cls = (void*)nah; nah->proc = proc; - nah->proc_cls = cls; + nah->proc_cls = proc_cls; + strcpy (nah->result, ""); /* Start delegation resolution in our namestore */ resolve_delegation_ns(rh);