*/
static unsigned long long rid = 0;
+static int
+is_srv (char* name)
+{
+ char* ndup;
+ int ret = 1;
+
+ if (*name != '_')
+ return 0;
+ if (NULL == strstr (name, "._"))
+ return 0;
+
+ ndup = GNUNET_strdup (name);
+ strtok (ndup, ".");
+
+ if (NULL == strtok (NULL, "."))
+ ret = 0;
+
+ if (NULL == strtok (NULL, "."))
+ ret = 0;
+
+ if (NULL != strtok (NULL, "."))
+ ret = 0;
+
+ return ret;
+}
/**
* Determine if this name is canonical.
static int
is_canonical(char* name)
{
- uint32_t len = strlen(name);
- int i;
+ char* ndup;
+ char* tok;
+
+ ndup = GNUNET_strdup (name);
+ tok = strtok (ndup, ".");
- for (i=0; i<len; i++)
+ for (tok = strtok (NULL, "."); tok != NULL; tok = strtok (NULL, "."))
{
- if (*(name+i) == '.')
- return 0;
+ /*
+ * probably srv
+ */
+ if (*tok == '_')
+ continue;
+ GNUNET_free (ndup);
+ return 0;
}
+ GNUNET_free (ndup);
return 1;
}
* @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;
#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
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 GNUNET_NAMESTORE_RecordData p_rd[rd_count];
char* repl_string;
char* pos;
if (rd[i].record_type != GNUNET_GNS_RECORD_TYPE_NS &&
rd[i].record_type != GNUNET_GNS_RECORD_TYPE_CNAME &&
rd[i].record_type != GNUNET_GNS_RECORD_MX &&
- rd[i].record_type != GNUNET_GNS_RECORD_TYPE_SOA)
+ rd[i].record_type != GNUNET_GNS_RECORD_TYPE_SOA &&
+ rd[i].record_type != GNUNET_GNS_RECORD_TYPE_SRV)
{
p_rd[i].data = rd[i].data;
continue;
offset = 0;
if (rd[i].record_type == GNUNET_GNS_RECORD_MX)
{
- memcpy(new_mx_data, (char*)rd[i].data, sizeof(uint16_t));
+ 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),
p_rd[i].data = new_mx_data;
p_rd[i].data_size = offset;
}
+ else if (rd[i].record_type == GNUNET_GNS_RECORD_TYPE_SRV)
+ {
+ /*
+ * Prio, weight and port
+ */
+ memcpy (new_srv_data, (char*)rd[i].data, sizeof (uint16_t) * 3);
+ offset = sizeof (uint16_t) * 3;
+ pos = new_srv_data+offset;
+ expand_plus(&pos, (char*)rd[i].data+(sizeof(uint16_t)*3),
+ repl_string);
+ offset += strlen(new_srv_data+(sizeof(uint16_t)*3))+1;
+ p_rd[i].data = new_srv_data;
+ p_rd[i].data_size = offset;
+ }
else if (rd[i].record_type == GNUNET_GNS_RECORD_TYPE_SOA)
{
/* expand mname and rname */
{
struct RecordLookupHandle* rlh;
rlh = (struct RecordLookupHandle*) cls;
+ int check_dht = GNUNET_YES;
+
if (rd_count == 0)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
* 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) ) &&
- GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- &rh->private_local_zone) &&
- (strcmp(rh->name, "+") == 0) &&
- (rh->only_cached == GNUNET_NO))
+ 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) != 0))
+ 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);
{
uint32_t len;
- if (is_canonical(name))
+ if (is_canonical (name))
{
strcpy(dest, name);
strcpy(name, "");
{
struct RecordLookupHandle* rlh;
rlh = (struct RecordLookupHandle*) cls;
+ int check_dht = GNUNET_YES;
int s_len = 0;
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
* and exists
* or we are authority
**/
- if (((rh->status & RSL_RECORD_EXISTS) && (!(rh->status & RSL_RECORD_EXPIRED)))
- || !GNUNET_CRYPTO_short_hash_cmp(&rh->authority_chain_head->zone,
- &rh->private_local_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))
{
return;
}
- if (rh->only_cached == GNUNET_YES)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Only cache resolution, no result\n",
- rh->id, rh->name);
- finish_lookup(rh, rlh, rd_count, rd);
- return;
- }
-
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"GNS_PHASE_DELEGATE_NS-%llu: Trying to resolve delegation for %s via DHT\n",
rh->id, rh->name);
struct GNUNET_TIME_Absolute et;
rh = (struct ResolverHandle *)cls;
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Got %d records from authority lookup\n",
- rh->id, rd_count);
+ 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);
+ 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)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Records with name %s exist.\n",
- rh->id, name);
+ 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)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n",
- rh->id, name);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: Record set %s expired.\n",
+ rh->id, name);
rh->status |= RSL_RECORD_EXPIRED;
}
}
* 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,
- "GNS_PHASE_DELEGATE_NS-%llu: Promoting %s back to name\n",
- rh->id, 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,
- "GNS_PHASE_DELEGATE_NS-%llu: Adding %s back to %s\n",
- rh->id, rh->authority_name, rh->name);
- //memset(new_name, 0, strlen(rh->name) + strlen(rh->authority_name) + 2);
- GNUNET_snprintf(new_name, MAX_DNS_NAME_LENGTH, "%s.%s",
- rh->name, rh->authority_name);
- //strcpy(new_name, rh->name);
- //strcpy(new_name+strlen(new_name), ".");
- //strcpy(new_name+strlen(new_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);
+ 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;
}
* move on with query
* Note only 1 pkey should have been returned.. anything else would be strange
*/
- for (i=0; i<rd_count;i++)
+ for (i=0; i < rd_count;i++)
{
/**
rh->status |= RSL_DELEGATE_PKEY;
- if (ignore_pending_records &&
+ 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",
+ 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 (et)).rel_value
== 0)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
- rh->id);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "GNS_PHASE_DELEGATE_NS-%llu: This pkey is expired.\n",
+ rh->id);
if (remaining_time.rel_value == 0)
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
- "GNS_PHASE_DELEGATE_NS-%llu: This dht entry is expired.\n",
- rh->id);
+ 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;
}
/**
* Resolve rest of query with new authority
*/
- GNUNET_assert(rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
- memcpy(&rh->authority, rd[i].data,
- sizeof(struct GNUNET_CRYPTO_ShortHashCode));
- struct AuthorityChain *auth = GNUNET_malloc(sizeof(struct AuthorityChain));
+ GNUNET_assert (rd[i].record_type == GNUNET_GNS_RECORD_PKEY);
+ memcpy (&rh->authority, rd[i].data,
+ sizeof (struct GNUNET_CRYPTO_ShortHashCode));
+ struct AuthorityChain *auth = GNUNET_malloc(sizeof (struct AuthorityChain));
auth->zone = rh->authority;
- memset(auth->name, 0, strlen(rh->authority_name)+1);
- strcpy(auth->name, rh->authority_name);
+ 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);
--- /dev/null
+/*
+ This file is part of GNUnet.
+ (C) 2009 Christian Grothoff (and other contributing authors)
+
+ GNUnet is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published
+ by the Free Software Foundation; either version 3, or (at your
+ option) any later version.
+
+ GNUnet is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GNUnet; see the file COPYING. If not, write to the
+ Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+*/
+/**
+ * @file gns/test_gns_simple_srv_lookup.c
+ * @brief base testcase for testing GNS SRV lookups
+ *
+ */
+#include "platform.h"
+#include "gnunet_testing_lib.h"
+#include "gnunet_core_service.h"
+#include "block_dns.h"
+#include "gnunet_signatures.h"
+#include "gnunet_namestore_service.h"
+#include "../namestore/namestore.h"
+#include "gnunet_dnsparser_lib.h"
+#include "gnunet_gns_service.h"
+
+/* DEFINES */
+#define VERBOSE GNUNET_YES
+
+/* Timeout for entire testcase */
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 20)
+
+/* If number of peers not in config file, use this number */
+#define DEFAULT_NUM_PEERS 2
+
+/* test records to resolve */
+#define TEST_DOMAIN "_sip._tcp.bob.gnunet"
+#define TEST_IP "127.0.0.1"
+#define TEST_RECORD_NAME "sipserver"
+#define TEST_RECORD_NAME_SRV "_sip._tcp"
+#define TEST_SRV_NAME "sipserver.+"
+#define TEST_EXPECTED_SRV "sipserver.bob.gnunet"
+
+#define TEST_AUTHORITY_NAME "bob"
+
+#define KEYFILE_BOB "../namestore/zonefiles/HGU0A0VCU334DN7F2I9UIUMVQMM7JMSD142LIMNUGTTV9R0CF4EG.zkey"
+
+/* Globals */
+
+/**
+ * Directory to store temp data in, defined in config file
+ */
+static char *test_directory;
+
+static struct GNUNET_TESTING_PeerGroup *pg;
+
+/* Task handle to use to schedule test failure */
+GNUNET_SCHEDULER_TaskIdentifier die_task;
+
+/* Global return value (0 for success, anything else for failure) */
+static int ok;
+
+static struct GNUNET_NAMESTORE_Handle *namestore_handle;
+
+static struct GNUNET_GNS_Handle *gns_handle;
+
+const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+/**
+ * Check whether peers successfully shut down.
+ */
+void
+shutdown_callback (void *cls, const char *emsg)
+{
+ if (emsg != NULL)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error on shutdown! ret=%d\n", ok);
+ if (ok == 0)
+ ok = 2;
+ }
+
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "done(ret=%d)!\n", ok);
+}
+
+static void
+on_lookup_result(void *cls, uint32_t rd_count,
+ const struct GNUNET_NAMESTORE_RecordData *rd)
+{
+ int i;
+ uint16_t *srv_data;
+ char* srv;
+
+ if (rd_count == 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Lookup failed, rp_filtering?\n");
+ ok = 2;
+ }
+ else
+ {
+ ok = 1;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "name: %s\n", (char*)cls);
+ for (i=0; i<rd_count; i++)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "type: %d\n", rd[i].record_type);
+ if (rd[i].record_type == GNUNET_GNS_RECORD_TYPE_SRV)
+ {
+ srv_data = (uint16_t*)rd[i].data;
+ srv = (char*)&srv_data[3];
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "Got SRV %s with p=%d,w=%d,port=%d\n",
+ srv, srv_data, &srv_data[1], &srv_data[2]);
+ if (0 == strcmp(srv, TEST_EXPECTED_SRV))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "%s correctly resolved to %s!\n", TEST_DOMAIN,
+ TEST_EXPECTED_SRV);
+ ok = 0;
+ }
+ }
+ }
+ }
+
+ GNUNET_GNS_disconnect(gns_handle);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n");
+ GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
+}
+
+
+/**
+ * Function scheduled to be run on the successful start of services
+ * tries to look up the dns record for TEST_DOMAIN
+ */
+static void
+commence_testing (void *cls, int32_t success, const char *emsg)
+{
+ GNUNET_NAMESTORE_disconnect(namestore_handle, GNUNET_YES);
+
+ gns_handle = GNUNET_GNS_connect(cfg);
+
+ if (NULL == gns_handle)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+ "Failed to connect to GNS!\n");
+ }
+
+ GNUNET_GNS_lookup(gns_handle, TEST_DOMAIN, GNUNET_GNS_RECORD_TYPE_SRV,
+ GNUNET_NO,
+ NULL,
+ &on_lookup_result, TEST_DOMAIN);
+}
+
+/**
+ * Continuation for the GNUNET_DHT_get_stop call, so that we don't shut
+ * down the peers without freeing memory associated with GET request.
+ */
+static void
+end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+
+ if (pg != NULL)
+ GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+}
+
+/**
+ * Check if the get_handle is being used, if so stop the request. Either
+ * way, schedule the end_badly_cont function which actually shuts down the
+ * test.
+ */
+static void
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failing test with error: `%s'!\n",
+ (char *) cls);
+ GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
+ ok = 1;
+}
+
+GNUNET_NETWORK_STRUCT_BEGIN
+struct srv_data
+{
+ uint16_t prio GNUNET_PACKED;
+ uint16_t weight GNUNET_PACKED;
+ uint16_t port GNUNET_PACKED;
+};
+GNUNET_NETWORK_STRUCT_END
+
+static void
+do_lookup(void *cls, const struct GNUNET_PeerIdentity *id,
+ const struct GNUNET_CONFIGURATION_Handle *_cfg,
+ struct GNUNET_TESTING_Daemon *d, const char *emsg)
+{
+ struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
+ struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
+ struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
+ struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
+ struct GNUNET_CRYPTO_ShortHashCode bob_hash;
+ struct GNUNET_CRYPTO_RsaSignature *sig;
+ char* alice_keyfile;
+ struct srv_data *srv_data;
+ struct GNUNET_TIME_Absolute et;
+
+ cfg = _cfg;
+
+ GNUNET_SCHEDULER_cancel (die_task);
+
+ /* put records into namestore */
+ namestore_handle = GNUNET_NAMESTORE_connect(cfg);
+ if (NULL == namestore_handle)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
+ ok = -1;
+ return;
+ }
+
+ if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
+ "ZONEKEY",
+ &alice_keyfile))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
+ ok = -1;
+ return;
+ }
+
+ alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
+ bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
+
+ GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
+ GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
+
+ struct GNUNET_NAMESTORE_RecordData rd;
+ char* ip = TEST_IP;
+ struct in_addr *sipserver = GNUNET_malloc (sizeof (struct in_addr));
+ srv_data = GNUNET_malloc (sizeof (struct srv_data) + strlen (TEST_SRV_NAME) + 1);
+ uint16_t srv_weight = 60;
+ uint16_t srv_prio = 50;
+ uint16_t srv_port = 5060;
+
+ rd.expiration_time = UINT64_MAX;
+ GNUNET_assert(1 == inet_pton (AF_INET, ip, sipserver));
+
+ GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
+
+ rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
+ rd.data = &bob_hash;
+ rd.record_type = GNUNET_GNS_RECORD_PKEY;
+ rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
+
+ GNUNET_NAMESTORE_record_create (namestore_handle,
+ alice_key,
+ TEST_AUTHORITY_NAME,
+ &rd,
+ NULL,
+ NULL);
+
+ rd.data_size = sizeof (struct in_addr);
+ rd.data = sipserver;
+ rd.record_type = GNUNET_DNSPARSER_TYPE_A;
+ sig = GNUNET_NAMESTORE_create_signature(bob_key,
+ GNUNET_TIME_UNIT_FOREVER_ABS,
+ TEST_RECORD_NAME,
+ &rd, 1);
+ et.abs_value = rd.expiration_time;
+ GNUNET_NAMESTORE_record_put (namestore_handle,
+ &bob_pkey,
+ TEST_RECORD_NAME,
+ et,
+ 1,
+ &rd,
+ sig,
+ NULL,
+ NULL);
+
+ rd.data_size = sizeof (struct srv_data)+strlen(TEST_SRV_NAME)+1;
+ srv_data->port = srv_port;
+ srv_data->prio = srv_prio;
+ srv_data->weight = srv_weight;
+ strcpy((char*)&srv_data[1], TEST_SRV_NAME);
+ rd.data = srv_data;
+ rd.record_type = GNUNET_GNS_RECORD_TYPE_SRV;
+ sig = GNUNET_NAMESTORE_create_signature(bob_key,
+ GNUNET_TIME_UNIT_FOREVER_ABS,
+ TEST_RECORD_NAME_SRV,
+ &rd, 1);
+ et.abs_value = rd.expiration_time;
+ GNUNET_NAMESTORE_record_put (namestore_handle,
+ &bob_pkey,
+ TEST_RECORD_NAME_SRV,
+ et,
+ 1,
+ &rd,
+ sig,
+ &commence_testing,
+ NULL);
+ GNUNET_free(srv_data);
+ GNUNET_free(sipserver);
+ GNUNET_free(sig);
+ GNUNET_CRYPTO_rsa_key_free(bob_key);
+ GNUNET_CRYPTO_rsa_key_free(alice_key);
+}
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *c)
+{
+ cfg = c;
+ /* Get path from configuration file */
+ if (GNUNET_YES !=
+ GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
+ &test_directory))
+ {
+ ok = 404;
+ return;
+ }
+
+
+ /* Set up a task to end testing if peer start fails */
+ die_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly,
+ "didn't start all daemons in reasonable amount of time!!!");
+
+ /* Start alice */
+ pg = GNUNET_TESTING_daemons_start(cfg, 1, 1, 1, TIMEOUT,
+ NULL, NULL, &do_lookup, NULL,
+ NULL, NULL, NULL);
+}
+
+static int
+check ()
+{
+ int ret;
+
+ /* Arguments for GNUNET_PROGRAM_run */
+ char *const argv[] = { "test-gns-simple-mx-lookup", /* Name to give running binary */
+ "-c",
+ "test_gns_simple_lookup.conf", /* Config file to use */
+#if VERBOSE
+ "-L", "DEBUG",
+#endif
+ NULL
+ };
+ struct GNUNET_GETOPT_CommandLineOption options[] = {
+ GNUNET_GETOPT_OPTION_END
+ };
+ /* Run the run function as a new program */
+ ret =
+ GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
+ "test-gns-simple-mx-lookup", "nohelp", options, &run,
+ &ok);
+ if (ret != GNUNET_OK)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "`test-gns-simple-mx-lookup': Failed with error code %d\n", ret);
+ }
+ return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+ int ret;
+
+ GNUNET_log_setup ("test-gns-simple-mx-lookup",
+#if VERBOSE
+ "DEBUG",
+#else
+ "WARNING",
+#endif
+ NULL);
+ ret = check ();
+ /**
+ * Need to remove base directory, subdirectories taken care
+ * of by the testing framework.
+ */
+ return ret;
+}
+
+/* end of test_gns_simple_mx_lookup.c */
projects / oweals / gnunet.git / commitdiff