#include "gns.h"
#include "gnunet-service-gns_resolver.h"
+/**
+ * Default DHT timeout
+ */
#define DHT_LOOKUP_TIMEOUT DHT_OPERATION_TIMEOUT
+
+/**
+ * DHT replication level
+ */
#define DHT_GNS_REPLICATION_LEVEL 5
+
+/**
+ * Maximum label length of DNS names
+ */
#define MAX_DNS_LABEL_LENGTH 63
/**
* a resolution identifier pool variable
- * FIXME overflow?
* This is a non critical identifier useful for debugging
*/
static unsigned long long rid = 0;
process_pseu_result (gph, NULL);
}
+
/**
* Function called when we find a PSEU entry in the DHT
*
process_pseu_result (gph, NULL);
}
+
/**
* Process PSEU discovery for shorten via namestore
*
process_pseu_result (gph, NULL);
}
+
/**
* Callback called by namestore for a zone to name
* result
}
+/**
+ * Start shortening algorithm using auth as
+ * authority chain
+ *
+ * @param auth the authorities that were resolved
+ * @param key the private key for PKEY import
+ */
static void
start_shorten (struct AuthorityChain *auth,
const struct GNUNET_CRYPTO_RsaPrivateKey *key)
static void
finish_shorten (struct ResolverHandle *rh,
struct NameShortenHandle *nsh);
+
+
/**
* finish get auth
*
}
-
-
/**
* Callback when record data is put into namestore
*
}
+/**
+ * Lookup timeout task
+ *
+ * @param cls the ResolverHandle for the task that timed out
+ * @param tc the task context
+ */
static void
handle_lookup_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != rh->timeout_cont)
rh->timeout_cont (rh->timeout_cont_cls, tc);
- /* FIXME: does this leak memory? */
}
rd_count);
}
+
/**
* Handle timeout for DHT requests
*
"GNS_PHASE_REC-%llu: starting dht lookup for %s with key: %s\n",
rh->id, rh->name, GNUNET_h2s (&lookup_key));
- //rh->timeout_task = GNUNET_SCHEDULER_NO_TASK;
rh->dht_heap_node = NULL;
if (GNUNET_TIME_UNIT_FOREVER_REL.rel_value != rh->timeout.rel_value)
}
-
-
/**
* Process VPN lookup result for record
*
send_dns_packet (struct ResolverHandle *rh);
+/**
+ * Read DNS response
+ *
+ * @param cls the ResolverHandle for this lookup
+ * @param addr the sockaddr
+ * @param addrlen the socket address length
+ */
static void
handle_dns_resolver (void *cls,
const struct sockaddr *addr,
return;
}
+
/**
* Sends a UDP dns query to a nameserver specified in the rh
*
}
+
/**
* The final phase of resoution.
* We found a NS RR and want to resolve via DNS
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.
}
-
/**
* Handle timeout for DHT requests
*
rh->proc(rh->proc_cls, rh, 0, NULL);
}
-/* Prototype */
+
+/**
+ * Start DHT lookup for a name -> PKEY (compare NS) record in
+ * rh->authority's zone
+ *
+ * @param rh the pending gns query
+ */
static void resolve_delegation_dht(struct ResolverHandle *rh);
-/* Prototype */
+
+/**
+ * Resolve the delegation chain for the request in our namestore
+ *
+ * @param rh the resolver handle
+ */
static void resolve_delegation_ns(struct ResolverHandle *rh);
"GNS_NS: Error putting records into namestore: %s\n", emsg);
}
+
/**
* Function called when we get a result from the dht
* for our query. Recursively tries to resolve authorities
#define MAX_SRV_LENGTH (sizeof(uint16_t)*3)+MAX_DNS_NAME_LENGTH
+/**
+ * Exands a name ending in .+ with the zone of origin.
+ * FIXME: funky api: 'dest' must be large enough to hold
+ * the result; this is a bit yucky...
+ *
+ * @param dest destination buffer
+ * @param src the .+ name
+ * @param repl the string to replace the + with
+ */
static void
-expand_plus(char* dest, char* src, char* repl)
+expand_plus (char* dest,
+ const char* src,
+ const char* repl)
{
char* pos;
- unsigned int s_len = strlen(src)+1;
+ size_t s_len = strlen (src) + 1;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_POSTPROCESS: Got %s to expand with %s\n", src, repl);
//Eh? I guess this is at least strlen ('x.+') == 3 FIXME
if (3 > s_len)
{
+ /* no postprocessing */
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_POSTPROCESS: %s too short\n", src);
-
- /* no postprocessing */
- memcpy(dest, src, s_len+1);
+ memcpy (dest, src, s_len);
return;
}
-
- if (0 == strcmp(src+s_len-3, ".+"))
+ if (0 == strcmp (src + s_len - 3, ".+"))
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_POSTPROCESS: Expanding .+ in %s\n", src);
- memset(dest, 0, s_len+strlen(repl)+strlen(GNUNET_GNS_TLD));
- strcpy(dest, src);
- pos = dest+s_len-2;
- strcpy(pos, repl);
- pos += strlen(repl);
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_POSTPROCESS: Expanded to %s\n", dest);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_POSTPROCESS: Expanding .+ in %s\n",
+ src);
+ memset (dest, 0, s_len + strlen (repl) + strlen(GNUNET_GNS_TLD));
+ strcpy (dest, src);
+ pos = dest + s_len - 2;
+ strcpy (pos, repl);
+ pos += strlen (repl);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_POSTPROCESS: Expanded to %s\n",
+ dest);
}
else
{
- memcpy(dest, src, s_len+1);
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_POSTPROCESS: No postprocessing for %s\n", src);
+ memcpy (dest, src, s_len);
}
}
+
/**
* finish lookup
*/
if (GNUNET_GNS_RECORD_MX == rd[i].record_type)
{
memcpy (new_mx_data, (char*)rd[i].data, sizeof(uint16_t));
- offset = sizeof(uint16_t);
- pos = new_mx_data+offset;
- expand_plus(pos, (char*)rd[i].data+sizeof(uint16_t),
- repl_string);
- offset += strlen(new_mx_data+sizeof(uint16_t))+1;
+ offset = sizeof (uint16_t);
+ pos = new_mx_data + offset;
+ // FIXME: how do we know that 'pos' has enough space for the new name?
+ expand_plus (pos, (char*)rd[i].data+sizeof(uint16_t),
+ repl_string);
+ offset += strlen(new_mx_data+sizeof(uint16_t)) + 1;
p_rd[i].data = new_mx_data;
p_rd[i].data_size = offset;
}
new_srv->prio = old_srv->prio;
new_srv->weight = old_srv->weight;
new_srv->port = old_srv->port;
+ // FIXME: how do we know that '&new_srv[1]' has enough space for the new name?
expand_plus((char*)&new_srv[1], (char*)&old_srv[1],
repl_string);
p_rd[i].data = new_srv_data;
old_soa = (struct soa_data*)rd[i].data;
new_soa = (struct soa_data*)new_soa_data;
memcpy (new_soa, old_soa, sizeof (struct soa_data));
+ // FIXME: how do we know that 'new_soa[1]' has enough space for the new name?
expand_plus((char*)&new_soa[1], (char*)&old_soa[1], repl_string);
offset = strlen ((char*)&new_soa[1]) + 1;
+ // FIXME: how do we know that 'new_soa[1]' has enough space for the new name?
expand_plus((char*)&new_soa[1] + offset,
(char*)&old_soa[1] + strlen ((char*)&old_soa[1]) + 1,
repl_string);
else
{
pos = new_rr_data;
+ // FIXME: how do we know that 'rd[i].data' has enough space for the new name?
expand_plus(pos, (char*)rd[i].data, repl_string);
p_rd[i].data_size = strlen(new_rr_data)+1;
p_rd[i].data = new_rr_data;
free_resolver_handle (rh);
}
+
/**
* Process DHT lookup result for record.
*
}
-
-
/**
* Process namestore lookup result for record.
*
strcpy(dest, (name+len+1));
}
+
/**
* Checks if name is in tld
*
return GNUNET_YES;
}
+
/**
* DHT resolution for delegation finished. Processing result.
*
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)
{
* No PSEU found.
* continue with next authority if exists
*/
- if ((rh->authority_chain_head->next == NULL))
+ if (NULL == rh->authority_chain_head->next)
{
finish_shorten (rh, nsh);
return;
rh);
}
+
/**
* Callback calles by namestore for a zone to name
* result
* No PSEU found.
* continue with next authority if exists
*/
- if ((rh->authority_chain_head->next == NULL))
+ if (NULL == rh->authority_chain_head->next)
{
finish_shorten (rh, nsh);
return;
}
}
+
/**
* Callback calles by namestore for a zone to name
* result
* No PSEU found.
* continue with next authority if exists
*/
- if ((rh->authority_chain_head->next == NULL))
+ if (NULL == rh->authority_chain_head->next)
{
finish_shorten (rh, nsh);
return;
}
nsh = GNUNET_malloc (sizeof (struct NameShortenHandle));
-
nsh->proc = proc;
nsh->proc_cls = proc_cls;
nsh->root_zone = zone;
strcpy (nsh->shorten_zone_name, shorten_zone_name);
strcpy (nsh->result, name);
-
rh = GNUNET_malloc (sizeof (struct ResolverHandle));
rh->authority = *zone;
rh->id = rid++;
rh->private_local_zone = *zone;
GNUNET_CONTAINER_DLL_insert (nsh_head, nsh_tail, rh);
-
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Checking for TLD...\n");
+ "Checking for TLD...\n");
if (is_zkey_tld (name) == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
proc (proc_cls, name);
return;
}
-
rh->namestore_task = GNUNET_NAMESTORE_zone_to_name (namestore_handle,
zone, //ours
&zkey,
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Unknown TLD in %s\n", name);
+ GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh);
GNUNET_free (rh);
GNUNET_free (nsh);
- GNUNET_CONTAINER_DLL_remove (nsh_head, nsh_tail, rh);
proc (proc_cls, name);
return;
}
uint32_t rd_count,
const struct GNUNET_NAMESTORE_RecordData *rd)
{
- struct GetNameAuthorityHandle* nah;
+ struct GetNameAuthorityHandle* nah = rh->proc_cls;
size_t answer_len;
- nah = (struct GetNameAuthorityHandle*) rh->proc_cls;
-
/**
* At this point rh->name contains the part of the name
* that we do not have a PKEY in our namestore to resolve.
projects / oweals / gnunet.git / blobdiff