#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_YES
+#define VERBOSE GNUNET_NO
/* Timeout for entire testcase */
#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 5)
*/
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.
static unsigned int failed_connections;
/* Task handle to use to schedule test failure */
-GNUNET_SCHEDULER_TaskIdentifier die_task;
+static GNUNET_SCHEDULER_TaskIdentifier die_task;
/* Global return value (0 for success, anything else for failure) */
static int ok;
/**
* Check whether peers successfully shut down.
*/
-void shutdown_callback (void *cls,
- const char *emsg)
+void
+shutdown_callback (void *cls, const char *emsg)
{
if (emsg != NULL)
- {
- if (ok == 0)
- ok = 2;
- }
+ {
+ if (ok == 0)
+ ok = 2;
+ }
}
/**
* testcase. Specifically, called when our get request completes.
*/
static void
-finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_assert (pg != NULL);
GNUNET_assert (peer1dht != NULL);
GNUNET_assert (peer2dht != NULL);
- GNUNET_DHT_disconnect(peer1dht);
- GNUNET_DHT_disconnect(peer2dht);
+ GNUNET_DHT_disconnect (peer1dht);
+ GNUNET_DHT_disconnect (peer2dht);
GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
ok = 0;
}
* down the peers without freeing memory associated with GET request.
*/
static void
-end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (peer1dht != NULL)
- GNUNET_DHT_disconnect(peer1dht);
+ GNUNET_DHT_disconnect (peer1dht);
if (peer2dht != NULL)
- GNUNET_DHT_disconnect(peer2dht);
+ GNUNET_DHT_disconnect (peer2dht);
if (pg != NULL)
GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
* test.
*/
static void
-end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failing test with error: `%s'!\n", (char *)cls);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failing test with error: `%s'!\n",
+ (char *) cls);
if (global_get_handle != NULL)
- {
- GNUNET_DHT_get_stop(global_get_handle);
- global_get_handle = NULL;
- }
- GNUNET_SCHEDULER_add_now(sched, &end_badly_cont, NULL);
+ {
+ GNUNET_DHT_get_stop (global_get_handle);
+ global_get_handle = NULL;
+ }
+ GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
ok = 1;
}
* @param size number of bytes in data
* @param data pointer to the result data
*/
-void get_result_iterator (void *cls,
- struct GNUNET_TIME_Absolute exp,
- const GNUNET_HashCode * key,
- const struct GNUNET_PeerIdentity * const *get_path,
- const struct GNUNET_PeerIdentity * const *put_path,
- enum GNUNET_BLOCK_Type type,
- uint32_t size,
- const void *data)
+static void
+get_result_iterator (void *cls, struct GNUNET_TIME_Absolute exp,
+ const GNUNET_HashCode * key,
+ const struct GNUNET_PeerIdentity *get_path,
+ unsigned int get_path_size,
+ const struct GNUNET_PeerIdentity *put_path,
+ unsigned int put_path_size,
+ enum GNUNET_BLOCK_Type type, size_t size,
+ 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));
+ char original_data[4]; /* Made up data that was stored */
- if ((0 != memcmp(&original_key, key, sizeof (GNUNET_HashCode))) || (0 != memcmp(original_data, data, sizeof(original_data))))
+ 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 ((sizeof (original_data) != size) ||
+ (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;
}
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
- GNUNET_SCHEDULER_cancel(sched, die_task);
- GNUNET_DHT_get_stop(global_get_handle);
- GNUNET_SCHEDULER_add_now (sched, &finish_testing, NULL);
+ GNUNET_SCHEDULER_cancel (die_task);
+ GNUNET_DHT_get_stop (global_get_handle);
+ global_get_handle = NULL;
+ GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
}
-/**
- * Start the GET request for the same key/data that was inserted.
- */
-static void
-do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
-{
- GNUNET_HashCode key; /* Key for data lookup */
- memset(&key, 42, sizeof(GNUNET_HashCode)); /* Set the key to the same thing as when data was inserted */
- global_get_handle = GNUNET_DHT_get_start(peer2dht, GNUNET_TIME_relative_get_forever(),
- 1 /* FIXME: use real type */, &key,
- GNUNET_DHT_RO_NONE,
- NULL, 0,
- NULL, 0,
- &get_result_iterator, NULL);
-}
/**
* Called when the PUT request has been transmitted to the DHT service.
* Schedule the GET request for some time in the future.
*/
static void
-put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+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,
- &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_HashCode key; /* Key for data lookup */
+
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task =
+ GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT, &end_badly,
+ "waiting for get response (data not found)");
+
+ memset (&key, 42, sizeof (GNUNET_HashCode)); /* Set the key to the same thing as when data was inserted */
+ global_get_handle =
+ GNUNET_DHT_get_start (peer2dht, GNUNET_TIME_UNIT_FOREVER_REL,
+ GNUNET_BLOCK_TYPE_TEST,
+ &key, 1, GNUNET_DHT_RO_NONE,
+ NULL, 0, &get_result_iterator, NULL);
}
+
/**
* Set up some data, and call API PUT function
*/
static void
-do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
- GNUNET_HashCode key; /* Made up key to store data under */
- char data[4]; /* Made up data to store */
- memset(&key, 42, sizeof(GNUNET_HashCode)); /* Set the key to something simple so we can issue GET request */
- memset(data, 43, sizeof(data));
+ GNUNET_HashCode key; /* Made up key to store data under */
+ char data[4]; /* Made up data to store */
+
+ memset (&key, 42, sizeof (GNUNET_HashCode)); /* Set the key to something simple so we can issue GET request */
+ memset (data, 43, sizeof (data));
/* Insert the data at the first peer */
- GNUNET_DHT_put(peer1dht,
- &key,
- GNUNET_DHT_RO_NONE,
- 1 /* FIXME: use real type */,
- sizeof(data), data,
- GNUNET_TIME_UNIT_FOREVER_ABS,
- GNUNET_TIME_UNIT_FOREVER_REL,
- &put_finished, NULL);
+ GNUNET_DHT_put (peer1dht, &key, 1, GNUNET_DHT_RO_NONE,
+ GNUNET_BLOCK_TYPE_TEST, sizeof (data), data,
+ GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL,
+ &put_finished, NULL);
}
+
/**
* This function is called whenever a connection attempt is finished between two of
* the started peers (started with GNUNET_TESTING_daemons_start). The total
* The emsg variable is NULL on success (peers connected), and non-NULL on
* failure (peers failed to connect).
*/
-void
-topology_callback (void *cls,
- const struct GNUNET_PeerIdentity *first,
- const struct GNUNET_PeerIdentity *second,
- uint32_t distance,
+static void
+topology_callback (void *cls, const struct GNUNET_PeerIdentity *first,
+ const struct GNUNET_PeerIdentity *second, uint32_t distance,
const struct GNUNET_CONFIGURATION_Handle *first_cfg,
const struct GNUNET_CONFIGURATION_Handle *second_cfg,
struct GNUNET_TESTING_Daemon *first_daemon,
const char *emsg)
{
if (emsg == NULL)
- {
- total_connections++;
+ {
+ total_connections++;
#if VERBOSE
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n",
- first_daemon->shortname,
- second_daemon->shortname,
- distance);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "connected peer %s to peer %s, distance %u\n",
+ first_daemon->shortname, second_daemon->shortname, distance);
#endif
- }
+ }
#if VERBOSE
else
- {
- failed_connections++;
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n",
- first_daemon->shortname,
- second_daemon->shortname, emsg);
- }
+ {
+ failed_connections++;
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "Failed to connect peer %s to peer %s with error :\n%s\n",
+ first_daemon->shortname, second_daemon->shortname, emsg);
+ }
#endif
if (total_connections == expected_connections)
- {
+ {
#if VERBOSE
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "Created %d total connections, which is our target number! Starting next phase of testing.\n",
- total_connections);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "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,
- &end_badly, "from test gets");
+ 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_UNIT_SECONDS, &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)");
+ }
}
* @param emsg NULL if peer started, non-NULL on error
*/
static void
-peers_started_callback (void *cls,
- const struct GNUNET_PeerIdentity *id,
- const struct GNUNET_CONFIGURATION_Handle *cfg,
- struct GNUNET_TESTING_Daemon *d, const char *emsg)
+peers_started_callback (void *cls, const struct GNUNET_PeerIdentity *id,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_TESTING_Daemon *d, const char *emsg)
{
if (emsg != NULL)
- {
- GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to start daemon with error: `%s'\n",
- emsg);
- return;
- }
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Failed to start daemon with error: `%s'\n", emsg);
+ return;
+ }
GNUNET_assert (id != NULL);
/* This is the first peer started */
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 */
- if (peer1dht == NULL) /* If DHT connect failed */
+ memcpy (&peer1id, id, sizeof (struct GNUNET_PeerIdentity)); /* Save the peer id */
+ 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 */
+ 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);
+ memcpy (&peer2id, id, sizeof (struct GNUNET_PeerIdentity)); /* Same as for first peer... */
+ 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");
}
}
/* Decrement number of peers left to start */
peers_left--;
- if (peers_left == 0) /* Indicates all peers started */
- {
+ if (peers_left == 0) /* Indicates all peers started */
+ {
#if VERBOSE
- GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
- "All %d daemons started, now connecting peers!\n",
- num_peers);
+ GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+ "All %d daemons started, now connecting peers!\n", num_peers);
#endif
- expected_connections = -1;
- 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);
- }
-
- /* Cancel current timeout fail task */
- GNUNET_SCHEDULER_cancel (sched, die_task);
- if (expected_connections == GNUNET_SYSERR) /* Some error happened */
- die_task = GNUNET_SCHEDULER_add_now (sched,
- &end_badly, "from connect topology (bad return)");
-
- /* Schedule timeout on failure task */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
- &end_badly, "from connect topology (timeout)");
- ok = 0;
+ expected_connections = -1;
+ 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, TIMEOUT, 12, NULL, NULL);
}
+
+ /* Cancel current timeout fail task */
+ GNUNET_SCHEDULER_cancel (die_task);
+ if (expected_connections == GNUNET_SYSERR) /* Some error happened */
+ die_task =
+ GNUNET_SCHEDULER_add_now (&end_badly,
+ "from connect topology (bad return)");
+
+ /* Schedule timeout on failure task */
+ 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)
+run (void *cls, 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))
- {
- ok = 404;
- return;
- }
+ if (GNUNET_YES !=
+ GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
+ &test_directory))
+ {
+ ok = 404;
+ return;
+ }
/* Get number of peers to start from configuration (should be two) */
if (GNUNET_SYSERR ==
peers_left = num_peers;
/* Set up a task to end testing if peer start fails */
- die_task = GNUNET_SCHEDULER_add_delayed (sched,
- TIMEOUT,
- &end_badly, "didn't start all daemons in reasonable amount of time!!!");
+ 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,
+ pg = GNUNET_TESTING_daemons_start (cfg, num_peers, 2, 2, TIMEOUT, NULL, NULL,
+ &peers_started_callback, NULL,
&topology_callback, NULL, NULL);
}
check ()
{
int ret;
+
/* Arguments for GNUNET_PROGRAM_run */
- char *const argv[] = {"test-dht-twopeer-put-get", /* Name to give running binary */
+ char *const argv[] = { "test-dht-twopeer-put-get", /* Name to give running binary */
"-c",
- "test_dht_twopeer_data.conf", /* Config file to use */
+ "test_dht_twopeer_data.conf", /* Config file to use */
#if VERBOSE
"-L", "DEBUG",
#endif
GNUNET_GETOPT_OPTION_END
};
/* Run the run function as a new program */
- ret = GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
- argv, "test-dht-twopeer-put-get", "nohelp",
- options, &run, &ok);
+ ret =
+ GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, argv,
+ "test-dht-twopeer-put-get", "nohelp", options, &run,
+ &ok);
if (ret != GNUNET_OK)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`test-dht-twopeer': Failed with error code %d\n", ret);
- }
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "`test-dht-twopeer': Failed with error code %d\n", ret);
+ }
return ok;
}
* of by the testing framework.
*/
if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to remove testing directory %s\n", test_directory);
- }
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "Failed to remove testing directory %s\n", test_directory);
+ }
return ret;
}