rd[i].data_size = ntohl(rb->data_length);
rd[i].data = &rb[1];
rd[i].expiration = GNUNET_TIME_absolute_ntoh(rb->expiration);
- rd[i].flags = ntohs(rb->flags);
+ rd[i].flags = ntohl(rb->flags);
if (strcmp(name, rh->query->name) &&
(rd[i].record_type == rh->query->type))
GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key);
- timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20);
+ timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5);
xquery = htonl(GNUNET_GNS_RECORD_PKEY);
//FIXME how long to wait for results?
5, //Replication level FIXME
GNUNET_DHT_RO_NONE,
&xquery, //xquery FIXME is this bad?
- sizeof(GNUNET_GNS_RECORD_PKEY),
+ 0, // for test bp sizeof(GNUNET_GNS_RECORD_PKEY),
&process_authority_dht_result,
rh);
char* name = NULL;
int i;
GNUNET_HashCode zone, name_hash;
-
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "got dht result\n");
if (data == NULL)
return;
struct GNUNET_NAMESTORE_RecordData rd[num_records];
name = (char*)&nrb[1];
- rb = (struct GNSRecordBlock*)(&nrb[1] + strlen(name) + 1);
+ rb = (struct GNSRecordBlock*)(&nrb[1] + strlen(name) + 2);
for (i=0; i<num_records; i++)
{
rd[i].data_size = ntohl(rb->data_length);
rd[i].data = (char*)&rb[1];
rd[i].expiration = GNUNET_TIME_absolute_ntoh(rb->expiration);
- rd[i].flags = ntohs(rb->flags);
+ rd[i].flags = ntohl(rb->flags);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Got name: %s (wanted %s)\n", name, rh->name);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Got type: %d (wanted %d)\n",
+ rd[i].record_type, rh->query->type);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Got data length: %d\n", rd[i].data_size);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "Got flag %d\n", rd[i].flags);
//FIXME class?
- if (strcmp(name, rh->query->name) &&
+ if (strcmp(name, rh->name) &&
(rd[i].record_type == rh->query->type))
{
rh->answered++;
}
+ rb = &rb[1] + rd[i].data_size;
+
}
GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
struct GNUNET_TIME_Relative timeout;
GNUNET_HashCode name_hash;
GNUNET_HashCode lookup_key;
+ struct GNUNET_CRYPTO_HashAsciiEncoded lookup_key_string;
GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
GNUNET_CRYPTO_hash_xor(&name_hash, &rh->authority, &lookup_key);
-
+ GNUNET_CRYPTO_hash_to_enc (&lookup_key, &lookup_key_string);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "starting dht lookup for %s with key: %s\n",
+ name, (char*)&lookup_key_string);
- timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20);
+ timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 5);
xquery = htonl(rh->query->type);
//FIXME how long to wait for results?
5, //Replication level FIXME
GNUNET_DHT_RO_NONE,
&xquery, //xquery FIXME is this bad?
- sizeof(rh->query->type),
+ 0, //for test bp sizeof(rh->query->type),
&process_name_dht_result,
rh);
* if this is not our zone we cannot rely on the namestore to be
* complete. -> Query DHT
*/
- if (!GNUNET_CRYPTO_hash_cmp(&zone, &zone_hash))
+ if (GNUNET_CRYPTO_hash_cmp(&zone, &zone_hash))
{
if (remaining_time.rel_value == 0)
{
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+ "trying dht...\n");
resolve_name_dht(rh, name);
return;
}
else
{
- GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Record is still recent. No DHT lookup\n");
}
}
//GNUNET_CRYPTO_hash(bob, GNUNET_CRYPTO_RSA_KEY_LENGTH, bob_zone);
struct in_addr *alice = GNUNET_malloc(sizeof(struct in_addr));
- struct in_addr *bob_web = GNUNET_malloc(sizeof(struct in_addr));
+ struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
struct GNUNET_NAMESTORE_RecordData rda;
//struct GNUNET_NAMESTORE_RecordData rdb;
- //struct GNUNET_NAMESTORE_RecordData rdb_web;
+ struct GNUNET_NAMESTORE_RecordData rdb_web;
GNUNET_assert(1 == inet_pton (AF_INET, ipA, alice));
- //GNUNET_assert(1 == inet_pton (AF_INET, ipB, bob_web));
+ GNUNET_assert(1 == inet_pton (AF_INET, ipB, web));
rda.data_size = sizeof(struct in_addr);
- //rdb_web.data_size = sizeof(struct in_addr);
+ rdb_web.data_size = sizeof(struct in_addr);
//rdb.data_size = sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded);
rda.data = alice;
//rdb.data = bob;
- //rdb_web.data = bob_web;
+ rdb_web.data = web;
rda.record_type = GNUNET_GNS_RECORD_TYPE_A;
- //rdb_web.record_type = GNUNET_GNS_RECORD_TYPE_A;
+ rdb_web.record_type = GNUNET_DNSPARSER_TYPE_A;
//rdb.record_type = GNUNET_GNS_RECORD_PKEY;
- //rdb_web.expiration = GNUNET_TIME_absolute_get_forever ();
+ rdb_web.expiration = GNUNET_TIME_absolute_get_forever ();
rda.expiration = GNUNET_TIME_absolute_get_forever ();
//rdb.expiration = GNUNET_TIME_absolute_get_forever ();
&rda,
NULL,
NULL);
+ GNUNET_NAMESTORE_record_create (namestore_handle,
+ zone_key,
+ "www",
+ &rdb_web,
+ NULL,
+ NULL);
/*
//www.bob.gnunet A IN 5.6.7.8
GNUNET_NAMESTORE_record_create (namestore_handle,
"bob",
&rdb,
NULL,
- NULL);
- GNUNET_NAMESTORE_record_put(namestore_handle,
- bob,
+ NULL);*/
+ /*GNUNET_NAMESTORE_record_put(namestore_handle,
+ zone_key,
"www",
GNUNET_TIME_absolute_get_forever (),
1,
&rdb_web,
NULL, //Signature
NULL, //Cont
- NULL); //cls
- */
+ NULL); //cls*/
}
void
GNUNET_NAMESTORE_zone_iterator_next(namestore_iter);
}
+void
+record_dht_put(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "put request transmitted\n");
+}
+
/* prototype */
static void
update_zone_dht_start(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
struct GNSRecordBlock *rb;
GNUNET_HashCode name_hash;
GNUNET_HashCode xor_hash;
+ struct GNUNET_CRYPTO_HashAsciiEncoded xor_hash_string;
int i;
uint32_t rd_payload_length;
for (i=0; i<rd_count; i++)
{
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "putting record with type %d\n",
+ rd[i].record_type);
rb->type = htonl(rd[i].record_type);
rb->expiration = GNUNET_TIME_absolute_hton(rd[i].expiration);
rb->data_length = htonl(rd[i].data_size);
timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 20);
GNUNET_CRYPTO_hash(name, strlen(name), &name_hash);
GNUNET_CRYPTO_hash_xor(&zone_hash, &name_hash, &xor_hash);
+ GNUNET_CRYPTO_hash_to_enc (&xor_hash, &xor_hash_string);
+ GNUNET_log(GNUNET_ERROR_TYPE_INFO, "putting new record %s under key: %s\n",
+ name, (char*)&xor_hash_string);
+
GNUNET_DHT_put (dht_handle, &xor_hash,
5, //replication level
GNUNET_DHT_RO_NONE,
(char*)nrb,
expiration,
timeout,
- NULL, //FIXME continuation needed? success check? yes ofc
+ &record_dht_put, //FIXME continuation needed? success check? yes ofc
NULL); //cls for cont
num_public_records++;
GNUNET_DNS_FLAG_PRE_RESOLUTION,
&handle_dns_request, /* rh */
NULL); /* Closure */
- }
-
- if (NULL == dns_handle)
- {
- GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
+ if (NULL == dns_handle)
+ {
+ GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to the dnsservice!\n");
+ }
}
+
+
/**
* handle to our local namestore
*/
--- /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_twopeer.c
+ * @brief base testcase for testing DHT service with
+ * two running peers.
+ *
+ * This testcase starts peers using the GNUNET_TESTING_daemons_start
+ * function call. On peer start, connects to the peers DHT service
+ * by calling GNUNET_DHT_connected. Once notified about all peers
+ * being started (by the peers_started_callback function), calls
+ * GNUNET_TESTING_connect_topology, which connects the peers in a
+ * "straight line" topology. On notification that all peers have
+ * been properly connected, calls the do_get function which initiates
+ * a GNUNET_DHT_get from the *second* peer. Once the GNUNET_DHT_get
+ * function starts, runs the do_put function to insert data at the first peer.
+ * If the GET is successful, schedules finish_testing
+ * to stop the test and shut down peers. If GET is unsuccessful
+ * after GET_TIMEOUT seconds, prints an error message and shuts down
+ * the peers.
+ */
+#include "platform.h"
+#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
+
+/* Timeout for entire testcase */
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 40)
+
+/* If number of peers not in config file, use this number */
+#define DEFAULT_NUM_PEERS 2
+
+/* Globals */
+
+/**
+ * Directory to store temp data in, defined in config file
+ */
+static char *test_directory;
+
+/**
+ * Variable used to store the number of connections we should wait for.
+ */
+static unsigned int expected_connections;
+
+/**
+ * Variable used to keep track of how many peers aren't yet started.
+ */
+static unsigned long long peers_left;
+
+struct GNUNET_TESTING_Daemon *d1;
+struct GNUNET_TESTING_Daemon *d2;
+
+
+/**
+ * Total number of peers to run, set based on config file.
+ */
+static unsigned long long num_peers;
+
+/**
+ * Global used to count how many connections we have currently
+ * been notified about (how many times has topology_callback been called
+ * with success?)
+ */
+static unsigned int total_connections;
+
+/**
+ * Global used to count how many failed connections we have
+ * been notified about (how many times has topology_callback
+ * been called with failure?)
+ */
+static unsigned int failed_connections;
+
+/* Task handle to use to schedule test failure */
+GNUNET_SCHEDULER_TaskIdentifier die_task;
+
+GNUNET_SCHEDULER_TaskIdentifier bob_task;
+
+/* Global return value (0 for success, anything else for failure) */
+static int ok;
+
+int bob_online, alice_online;
+
+/**
+ * Check whether peers successfully shut down.
+ */
+void
+shutdown_callback (void *cls, const char *emsg)
+{
+ if (emsg != NULL)
+ {
+ if (ok == 0)
+ ok = 2;
+ }
+}
+
+/**
+ * Function scheduled to be run on the successful completion of this
+ * testcase. Specifically, called when our get request completes.
+ */
+static void
+finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ ok = 0;
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer1!\n");
+ GNUNET_TESTING_daemon_stop (d1, TIMEOUT, &shutdown_callback, NULL,
+ GNUNET_YES, GNUNET_NO);
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Shutting down peer2!\n");
+ GNUNET_TESTING_daemon_stop (d2, TIMEOUT, &shutdown_callback, NULL,
+ GNUNET_YES, GNUNET_NO);
+ GNUNET_SCHEDULER_cancel(bob_task);
+ GNUNET_SCHEDULER_cancel(die_task);
+}
+
+/**
+ * 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 (d1 != NULL)
+ GNUNET_TESTING_daemon_stop (d1, TIMEOUT, &shutdown_callback, NULL,
+ GNUNET_YES, GNUNET_NO);
+ if (d2 != NULL)
+ GNUNET_TESTING_daemon_stop (d2, TIMEOUT, &shutdown_callback, NULL,
+ GNUNET_YES, GNUNET_NO);
+}
+
+/**
+ * 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_INFO, "Failing test with error: `%s'!\n",
+ (char *) cls);
+ GNUNET_SCHEDULER_cancel(bob_task);
+ GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
+ ok = 1;
+}
+
+static void
+do_lookup(void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ //do lookup here
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 30),
+ &finish_testing, NULL);
+}
+
+static void
+gns_started(void *cls, const struct GNUNET_PeerIdentity *id,
+ const struct GNUNET_CONFIGURATION_Handle *cfg,
+ struct GNUNET_TESTING_Daemon *d, const char *emsg)
+{
+ if (NULL != emsg)
+ {
+ if (d == d1)
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS failed to start alice\n");
+ else
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS failed to start bob\n");
+ return;
+ }
+ if (d == d1)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS started on alice\n");
+ GNUNET_TESTING_daemon_start_service (d2, "gns", TIMEOUT, &gns_started,
+ NULL);
+ return;
+ }
+
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "GNS started on bob\n");
+
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 1),
+ &do_lookup, 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
+ * number of times this function is called should equal the number returned
+ * from the GNUNET_TESTING_connect_topology call.
+ *
+ * The emsg variable is NULL on success (peers connected), and non-NULL on
+ * failure (peers failed to connect).
+ */
+void
+notify_connect (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,
+ struct GNUNET_TESTING_Daemon *second_daemon,
+ const char *emsg)
+{
+ if (emsg == NULL)
+ {
+ total_connections++;
+#if VERBOSE
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+ "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_INFO,
+ "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_INFO,
+ "Created %d total connections, which is our target number! Starting next phase of testing.\n",
+ total_connections);
+#endif
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, "from test lookup");
+ GNUNET_TESTING_daemon_start_service (d1, "gns", TIMEOUT, &gns_started, NULL);
+
+ }
+ else if (total_connections + failed_connections == expected_connections)
+ {
+ GNUNET_SCHEDULER_cancel (die_task);
+ die_task =
+ GNUNET_SCHEDULER_add_now (&end_badly,
+ "from topology_callback (too many failed connections)");
+ }
+}
+
+/**
+ * Set up some data, and call API PUT function
+ */
+static void
+alice_idle (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+
+ if (!bob_online)
+ {
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 2),
+ &alice_idle, NULL);
+ return;
+ }
+
+ GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Connecting peers\n");
+ GNUNET_TESTING_daemons_connect (d1, d2, TIMEOUT, 5, 1,
+ ¬ify_connect, NULL);
+}
+
+static void
+bob_idle (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+
+ bob_online = 1;
+ bob_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 2),
+ &bob_idle, NULL);
+}
+
+
+
+
+/**
+ * Callback which is called whenever a peer is started (as a result of the
+ * GNUNET_TESTING_daemons_start call.
+ *
+ * @param cls closure argument given to GNUNET_TESTING_daemons_start
+ * @param id the GNUNET_PeerIdentity of the started peer
+ * @param cfg the configuration for this specific peer (needed to connect
+ * to the DHT)
+ * @param d the handle to the daemon started
+ * @param emsg NULL if peer started, non-NULL on error
+ */
+static void
+alice_started (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_assert (id != NULL);
+
+ alice_online = 1;
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 2),
+ &alice_idle, NULL);
+}
+
+static void
+bob_started (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_assert (id != NULL);
+
+ alice_online = 1;
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 2),
+ &bob_idle, NULL);
+}
+
+static void
+run (void *cls, char *const *args, const char *cfgfile,
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+
+ /* Get path from configuration file */
+ 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 ==
+ GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
+ &num_peers))
+ num_peers = DEFAULT_NUM_PEERS;
+
+ /* Set peers_left so we know when all peers started */
+ peers_left = num_peers;
+
+ /* 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!!!");
+ alice_online = 0;
+ bob_online = 0;
+ d1 = GNUNET_TESTING_daemon_start(cfg, TIMEOUT, GNUNET_NO, NULL, NULL, 0,
+ NULL, NULL, NULL, &alice_started, NULL);
+ uint16_t port = 6000;
+ expected_connections = 1;
+ uint32_t upnum = 23;
+ uint32_t fdnum = 42;
+ struct GNUNET_CONFIGURATION_Handle *cfg2 = GNUNET_TESTING_create_cfg(cfg,
+ 23, &port, &upnum,
+ NULL, &fdnum);
+ GNUNET_CONFIGURATION_set_value_string (cfg2, "paths", "servicehome",
+ "/tmp/peer2");
+ GNUNET_CONFIGURATION_set_value_string (cfg2, "gns", "HIJACK_DNS",
+ "NO");
+ GNUNET_CONFIGURATION_set_value_string (cfg2, "gns", "ZONEKEY",
+ "/tmp/bobkey");
+ GNUNET_CONFIGURATION_set_value_string (cfg2, "gns", "TRUSTED",
+ "alice:/tmp/zonekey");
+ d2 = GNUNET_TESTING_daemon_start(cfg2, TIMEOUT, GNUNET_NO, NULL, NULL, 0,
+ NULL, NULL, NULL, &bob_started, NULL);
+
+
+}
+
+static int
+check ()
+{
+ int ret;
+
+ /* Arguments for GNUNET_PROGRAM_run */
+ char *const argv[] = { "test-gns-twopeer", /* Name to give running binary */
+ "-c",
+ "test_gns_twopeer.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-twopeer", "nohelp", options, &run,
+ &ok);
+ if (ret != GNUNET_OK)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "`test-gns-twopeer': Failed with error code %d\n", ret);
+ }
+ return ok;
+}
+
+int
+main (int argc, char *argv[])
+{
+ int ret;
+
+ GNUNET_log_setup ("test-gns-twopeer",
+#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_twopeer.c */
projects / oweals / gnunet.git / commitdiff