#include "gnunet_testing_lib.h"
#include "gnunet_core_service.h"
#include "gnunet_dht_service.h"
+#include "block_dns.h"
+#include "gnunet_signatures.h"
/* DEFINES */
#define VERBOSE GNUNET_NO
/* If number of peers not in config file, use this number */
#define DEFAULT_NUM_PEERS 2
+#define DNS GNUNET_NO
+
/* Globals */
/**
*/
struct GNUNET_DHT_GetHandle *global_get_handle;
-/**
- * Global scheduler, used for all GNUNET_SCHEDULER_* functions.
- */
-static struct GNUNET_SCHEDULER_Handle *sched;
/**
* Total number of peers to run, set based on config file.
/* Global return value (0 for success, anything else for failure) */
static int ok;
+#if DNS
+struct GNUNET_DNS_Record data;
+#endif
+
/**
* Peer identity of the first peer started.
*/
GNUNET_DHT_get_stop(global_get_handle);
global_get_handle = NULL;
}
- GNUNET_SCHEDULER_add_now(sched, &end_badly_cont, NULL);
+ GNUNET_SCHEDULER_add_now(&end_badly_cont, NULL);
ok = 1;
}
const struct GNUNET_PeerIdentity * const *put_path,
enum GNUNET_BLOCK_Type type,
size_t size,
- const void *data)
+ const void *result_data)
{
GNUNET_HashCode original_key; /* Key data was stored data under */
char original_data[4]; /* Made up data that was stored */
memset(&original_key, 42, sizeof(GNUNET_HashCode)); /* Set the key to what it was set to previously */
memset(original_data, 43, sizeof(original_data));
- if ((0 != memcmp(&original_key, key, sizeof (GNUNET_HashCode))) || (0 != memcmp(original_data, data, sizeof(original_data))))
+#if DNS
+ if ((0 != memcmp(&data.service_descriptor, key, sizeof (GNUNET_HashCode))) || (0 != memcmp((char *)&data, result_data, sizeof(original_data))))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Key or data is not the same as was inserted!\n");
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "key or data mismatch in get response!\n");
+ return;
+ }
+#else
+ if ((0 != memcmp(&original_key, key, sizeof (GNUNET_HashCode))) || (0 != memcmp(original_data, result_data, sizeof(original_data))))
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Key or data is not the same as was inserted!\n");
- GNUNET_SCHEDULER_cancel(sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "key or data mismatch in get response!\n");
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Key or data is not the same as was inserted!\n");
+ GNUNET_SCHEDULER_cancel(die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "key or data mismatch in get response!\n");
return;
}
+#endif
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
- GNUNET_SCHEDULER_cancel(sched, die_task);
+ GNUNET_SCHEDULER_cancel(die_task);
GNUNET_DHT_get_stop(global_get_handle);
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
/**
do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
{
GNUNET_HashCode key; /* Key for data lookup */
+#if DNS
+ memcpy(&key, &data.service_descriptor, sizeof(GNUNET_HashCode));
+#else
memset(&key, 42, sizeof(GNUNET_HashCode)); /* Set the key to the same thing as when data was inserted */
+#endif
global_get_handle = GNUNET_DHT_get_start(peer2dht, GNUNET_TIME_relative_get_forever(),
- GNUNET_BLOCK_TYPE_TEST,
- &key,
- GNUNET_DHT_RO_NONE,
- NULL, 0,
- NULL, 0,
- &get_result_iterator, NULL);
+#if DNS
+ GNUNET_BLOCK_TYPE_DNS,
+#else
+ GNUNET_BLOCK_TYPE_TEST,
+#endif
+ &key,
+ DEFAULT_GET_REPLICATION,
+ GNUNET_DHT_RO_NONE,
+ NULL, 0,
+ NULL, 0,
+ &get_result_iterator, NULL);
}
/**
static void
put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, GET_TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT,
&end_badly, "waiting for get response (data not found)");
- GNUNET_SCHEDULER_add_delayed(sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10), &do_get, NULL);
+ GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10), &do_get, NULL);
}
+
+#if !DNS
/**
* Set up some data, and call API PUT function
*/
/* Insert the data at the first peer */
GNUNET_DHT_put(peer1dht,
&key,
- GNUNET_DHT_RO_NONE,
+ DEFAULT_PUT_REPLICATION,
+ GNUNET_DHT_RO_NONE,
GNUNET_BLOCK_TYPE_TEST,
sizeof(data), data,
GNUNET_TIME_UNIT_FOREVER_ABS,
GNUNET_TIME_UNIT_FOREVER_REL,
&put_finished, NULL);
}
+#else
+
+/**
+ * Set up some data, and call API PUT function
+ */
+static void
+do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+{
+ char* name = "philipptoelke.gnunet.";
+ size_t size = sizeof(struct GNUNET_DNS_Record);
+ memset(&data, 0, size);
+
+ data.purpose.size = htonl(size - sizeof(struct GNUNET_CRYPTO_RsaSignature));
+ data.purpose.purpose = GNUNET_SIGNATURE_PURPOSE_DNS_RECORD;
+
+ GNUNET_CRYPTO_hash(name, strlen(name)+1, &data.service_descriptor);
+
+ data.service_type = htonl(GNUNET_DNS_SERVICE_TYPE_UDP);
+ data.ports = htons(69);
+
+ char* keyfile;
+ GNUNET_asprintf(&keyfile, "/tmp/test_dns_data_key");
+ struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file(keyfile);
+ GNUNET_free(keyfile);
+ GNUNET_assert(my_private_key != NULL);
+
+ GNUNET_CRYPTO_rsa_key_get_public(my_private_key, &data.peer);
+
+ data.expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS);
+
+ /* Sign the block */
+ if (GNUNET_OK != GNUNET_CRYPTO_rsa_sign(my_private_key,
+ &data.purpose,
+ &data.signature))
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "could not sign DNS_Record\n");
+ return;
+ }
+ GNUNET_CRYPTO_rsa_key_free(my_private_key);
+
+ GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ "Putting with key %08x\n",
+ *((unsigned int*)&data.service_descriptor));
+
+ GNUNET_DHT_put(peer1dht,
+ &data.service_descriptor,
+ DEFAULT_PUT_REPLICATION,
+ GNUNET_DHT_RO_NONE,
+ GNUNET_BLOCK_TYPE_DNS,
+ size,
+ (char*)&data,
+ GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS),
+ GNUNET_TIME_UNIT_MINUTES,
+ &put_finished,
+ NULL);
+}
+#endif
/**
* This function is called whenever a connection attempt is finished between two of
"Created %d total connections, which is our target number! Starting next phase of testing.\n",
total_connections);
#endif
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_delayed (sched, TIMEOUT,
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from test gets");
- GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_put, NULL);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_put, NULL);
}
else if (total_connections + failed_connections == expected_connections)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from topology_callback (too many failed connections)");
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
}
}
if (peers_left == num_peers)
{
memcpy(&peer1id, id, sizeof(struct GNUNET_PeerIdentity)); /* Save the peer id */
- peer1dht = GNUNET_DHT_connect(sched, cfg, 100); /* Connect to the first peers DHT service */
+ peer1dht = GNUNET_DHT_connect(cfg, 100); /* Connect to the first peers DHT service */
if (peer1dht == NULL) /* If DHT connect failed */
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
}
}
else /* This is the second peer started */
{
memcpy(&peer2id, id, sizeof(struct GNUNET_PeerIdentity)); /* Same as for first peer... */
- peer2dht = GNUNET_DHT_connect(sched, cfg, 100);
+ peer2dht = GNUNET_DHT_connect(cfg, 100);
if (peer2dht == NULL)
{
- GNUNET_SCHEDULER_cancel (sched, die_task);
- GNUNET_SCHEDULER_add_now(sched, &end_badly, "Failed to get dht handle!\n");
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
}
}
if ((pg != NULL)) /* Sanity check */
{
/* Connect peers in a "straight line" topology, return the number of expected connections */
- expected_connections = GNUNET_TESTING_connect_topology (pg, GNUNET_TESTING_TOPOLOGY_LINE, GNUNET_TESTING_TOPOLOGY_OPTION_ALL, 0.0);
+ expected_connections = GNUNET_TESTING_connect_topology (pg,
+ GNUNET_TESTING_TOPOLOGY_LINE,
+ GNUNET_TESTING_TOPOLOGY_OPTION_ALL,
+ 0.0,
+ TIMEOUT,
+ 12,
+ NULL, NULL);
}
/* Cancel current timeout fail task */
- GNUNET_SCHEDULER_cancel (sched, die_task);
+ GNUNET_SCHEDULER_cancel (die_task);
if (expected_connections == GNUNET_SYSERR) /* Some error happened */
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
+ die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
/* Schedule timeout on failure task */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "from connect topology (timeout)");
ok = 0;
}
static void
run (void *cls,
- struct GNUNET_SCHEDULER_Handle *s,
char *const *args,
const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
{
- sched = s;
/* Get path from configuration file */
if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
peers_left = num_peers;
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
+ die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
&end_badly, "didn't start all daemons in reasonable amount of time!!!");
/* Start num_peers peers, call peers_started_callback on peer start, topology_callback on peer connect */
/* Read the API documentation for other parameters! */
- pg = GNUNET_TESTING_daemons_start (sched, cfg,
- num_peers, TIMEOUT, NULL, NULL, &peers_started_callback, NULL,
- &topology_callback, NULL, NULL);
+ pg = GNUNET_TESTING_daemons_start (cfg,
+ num_peers,
+ 2,
+ 2,
+ TIMEOUT,
+ NULL,
+ NULL,
+ &peers_started_callback,
+ NULL,
+ &topology_callback,
+ NULL,
+ NULL);
}
projects / oweals / gnunet.git / blobdiff