static void
testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
{
static int connected = GNUNET_NO;
if ((cls == cc1) && (NULL != cc2))
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc2);
}
if ((cls == cc2) && (NULL != cc1))
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc1);
}
cc1 = NULL;
cc2 = NULL;
if (connected > 0)
return;
connected++;
{
char *p1_c = GNUNET_strdup (GNUNET_i2s (&p1->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Peers connected: %u (%s) <-> %u (%s)\n",
p1->no,
p1_c,
p2->no,
GNUNET_i2s (&p2->id));
GNUNET_free (p1_c);
}
send_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&sendtask,
NULL);
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
if (send_task != NULL)
{
GNUNET_SCHEDULER_cancel (send_task);
send_task = NULL;
}
if (NULL != cc2)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n"));
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc2);
cc2 = NULL;
}
if (NULL != cc1)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n"));
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc1);
cc1 = NULL;
}
if (NULL != th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
ok = GNUNET_SYSERR;
}
static void
end_badly ()
{
die_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
if (measure_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (measure_task);
if (test_connected == GNUNET_YES)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers got connected\n");
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers got NOT connected\n");
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (cc != NULL)
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
test_failed = GNUNET_YES;
}
static void
end ()
{
unsigned long long delta;
char *value_name;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
FPRINTF (stderr, "\nThroughput was %llu kb/s\n",
total_bytes * 1000 / 1024 / delta);
GNUNET_asprintf (&value_name, "reliable_%s", test_plugin);
GAUGER ("TRANSPORT", value_name, (int) (total_bytes * 1000 / 1024 / delta),
"kb/s");
GNUNET_free (value_name);
if (die_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (die_task);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (cc != NULL)
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
GNUNET_TRANSPORT_TESTING_done (tth);
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping\n");
if (send_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (send_task);
if (die_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
if (cc != NULL)
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel(tth, cc);
cc = NULL;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (blacklist_p1 != NULL)
{
GNUNET_TRANSPORT_blacklist_cancel (blacklist_p1);
blacklist_p1 = NULL;
}
if (blacklist_p2 != NULL)
{
GNUNET_TRANSPORT_blacklist_cancel (blacklist_p2);
blacklist_p2 = NULL;
}
if (p1 != NULL)
{
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
p1 = NULL;
}
if (p2 != NULL)
{
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
p2 = NULL;
}
if ((blacklist_request_p1 == GNUNET_YES) &&
(blacklist_request_p2 == GNUNET_YES) &&
(connected == GNUNET_NO))
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Peers were not connected, success\n"));
ok = 0;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, _("Peers were not connected, fail\n"));
ok = 1;
}
}
/**
* Clean up the transport testing
* @param tth transport testing handle
*/
void
GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_handle *tth)
{
struct ConnectingContext *cc = tth->cc_head;
struct ConnectingContext *ct = NULL;
struct PeerContext *p = tth->p_head;
struct PeerContext *t = NULL;
GNUNET_assert (tth != NULL);
while (cc != tth->cc_tail)
{
ct = cc->next;
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
"Developer forgot to cancel connect request %p!\n", cc);
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = ct;
}
while (p != NULL)
{
t = p->next;
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
"Developer forgot to stop peer!\n");
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p);
p = t;
}
GNUNET_TESTING_system_destroy (tth->tl_system, GNUNET_YES);
GNUNET_free (tth);
tth = NULL;
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (stage_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (stage_task);
stage_task = GNUNET_SCHEDULER_NO_TASK;
}
if (cc != NULL)
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel(tth, cc);
cc = NULL;
}
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
ok = GNUNET_SYSERR;
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
if (timer_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (timer_task);
timer_task = GNUNET_SCHEDULER_NO_TASK;
}
if (cc != NULL)
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
ok = GNUNET_SYSERR;
GNUNET_TRANSPORT_TESTING_done (tth);
}
static void
end ()
{
unsigned long long delta;
unsigned long long rate;
char *value_name;
unsigned int i;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Stopping peers\n");
/* Calculcate statistics */
delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value_us;
rate = (1000LL* 1000ll * total_bytes) / (1024 * delta);
FPRINTF (stderr,
"\nThroughput was %llu KiBytes/s\n",
rate);
GNUNET_asprintf (&value_name,
"unreliable_%s",
test_plugin);
GAUGER ("TRANSPORT",
value_name,
(int) rate,
"kb/s");
GNUNET_free (value_name);
if (die_task != NULL)
GNUNET_SCHEDULER_cancel (die_task);
if (th != NULL)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
if (cc != NULL)
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = NULL;
}
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
GNUNET_TRANSPORT_TESTING_done (tth);
ok = 0;
for (i = 0; i < TOTAL_MSGS; i++)
{
if (get_bit (bitmap, i) == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Did not receive message %d\n",
i);
ok = -1;
}
}
}
static void
testing_connect_cb (struct PeerContext *p1, struct PeerContext *p2, void *cls)
{
if (cls == cc1)
{
cc1 = NULL;
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc2);
}
if (cls == cc2)
{
cc2 = NULL;
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc1);
}
char *p1_c = GNUNET_strdup (GNUNET_i2s (&p1->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peers connected: %u (%s) <-> %u (%s)\n",
p1->no, p1_c, p2->no, GNUNET_i2s (&p2->id));
GNUNET_free (p1_c);
send_task = GNUNET_SCHEDULER_add_now (&sendtask, NULL);
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
if (send_task != NULL)
GNUNET_SCHEDULER_cancel (send_task);
if (cc != NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n"));
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = NULL;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were not ready to send data\n"));
if (s_started == GNUNET_NO)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peers were not started \n"));
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peers were started \n"));
if (s_connected == GNUNET_NO)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were not connected\n"));
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were connected\n"));
if (s_sending == GNUNET_NO)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were not ready to send data\n"));
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer were ready to send data\n"));
th = NULL;
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer 1 was not started\n"));
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Peer 2 was not started\n"));
ok = GNUNET_SYSERR;
}
static void
end_badly ()
{
die_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
if (test_connected == GNUNET_YES)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers got connected\n");
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peers got NOT connected\n");
if (test_sending == GNUNET_NO)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Testcase did not send any messages before timeout\n");
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Reliability failed: Last message sent %u, Next message scheduled %u, Last message received %u, Message expected %u\n",
msg_sent, msg_scheduled, msg_recv, msg_recv_expected);
if (test_send_timeout == GNUNET_YES)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Test had timeout while waiting to send data\n");
int i;
for (i = 0; i < TOTAL_MSGS; i++)
{
if (get_bit (bitmap, i) == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Did not receive message %d\n", i);
ok = -1;
}
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (cc != NULL)
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = NULL;
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
GNUNET_TRANSPORT_TESTING_done (tth);
ok = GNUNET_SYSERR;
}
static void
end ()
{
unsigned long long delta;
unsigned long long datarate;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
delta = GNUNET_TIME_absolute_get_duration (start_time).rel_value;
datarate = (total_bytes_sent * 1000) / delta;
FPRINTF (stderr, "Throughput was %llu b/s\n", datarate);
test_failed = GNUNET_NO;
if (datarate > quota_in_p2)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Datarate of %llu b/s higher than allowed inbound quota of %llu b/s\n",
datarate, quota_in_p2);
test_failed = GNUNET_YES;
}
if (datarate > quota_out_p1)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Datarate of %llu b/s higher than allowed outbound quota of %llu b/s\n",
datarate, quota_out_p1);
test_failed = GNUNET_YES;
}
if (test_failed == GNUNET_NO)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Datarate of %llu b/s complied to allowed outbound quota of %llu b/s and inbound quota of %llu b/s\n",
datarate, quota_out_p1, quota_in_p2);
}
if (die_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (die_task);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (cc != NULL)
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
}
static void
end_badly ()
{
unsigned int i;
die_task = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Fail! Stopping peers\n");
if (test_connected == GNUNET_YES)
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Peers got connected\n");
else
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Peers got NOT connected\n");
if (test_sending == GNUNET_NO)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Testcase did not send any messages before timeout\n");
if (test_send_timeout == GNUNET_YES)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Test had timeout while waiting to send data\n");
for (i = 0; i < TOTAL_MSGS; i++)
{
if (get_bit (bitmap, i) == 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Did not receive message %u\n",
i);
ok = -1;
}
}
if (th != NULL)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
if (cc != NULL)
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = NULL;
}
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
GNUNET_TRANSPORT_TESTING_done (tth);
ok = GNUNET_SYSERR;
}
static void
end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping\n");
if (die_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
if (timeout_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = GNUNET_SCHEDULER_NO_TASK;
}
if (stage_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (stage_task);
stage_task = GNUNET_SCHEDULER_NO_TASK;
}
if (cc != NULL)
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel(tth, cc);
cc = NULL;
}
if (p1 != NULL)
{
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
p1 = NULL;
}
if (p2 != NULL)
{
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
p2 = NULL;
}
}
static void
notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *p = cls;
char *p2_s;
struct PeerContext *p2;
GNUNET_assert (NULL != p);
GNUNET_assert (NULL != p->tth);
p2 = find_peer_context (p->tth, peer);
if (p->nc != NULL)
p->nc (p->cb_cls, peer);
if (p2 != NULL)
GNUNET_asprintf (&p2_s, "%u (`%s')", p2->no, GNUNET_i2s (&p2->id));
else
GNUNET_asprintf (&p2_s, "`%s'", GNUNET_i2s (peer));
GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
"Peers %s connected to peer %u (`%s')\n", p2_s, p->no,
GNUNET_i2s (&p->id));
GNUNET_free (p2_s);
/* Find ConnectingContext */
struct ConnectingContext *cc = find_connecting_context (p->tth, p, p2);
if (cc == NULL)
return;
if (p == cc->p1)
cc->p1_c = GNUNET_YES;
if (p == cc->p2)
cc->p2_c = GNUNET_YES;
if ((cc->p1_c == GNUNET_YES) && (cc->p2_c == GNUNET_YES))
{
cc->cb (cc->p1, cc->p2, cc->cb_cls);
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (p->tth, cc);
}
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (send_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (send_task);
send_task = GNUNET_SCHEDULER_NO_TASK;
}
if (shutdown_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (shutdown_task);
shutdown_task = GNUNET_SCHEDULER_NO_TASK;
}
if (cc != NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n"));
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = NULL;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (blacklist_p1 != NULL)
GNUNET_TRANSPORT_blacklist_cancel (blacklist_p1);
if (blacklist_p2 != NULL)
GNUNET_TRANSPORT_blacklist_cancel (blacklist_p2);
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
ok = GNUNET_SYSERR;
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Fail! Stopping peers\n");
if (restarted == GNUNET_YES)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peer was restarted\n");
if (restarted == GNUNET_NO)
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Peer was NOT restarted\n");
if (reconnect_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (reconnect_task);
reconnect_task = GNUNET_SCHEDULER_NO_TASK;
if (send_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (send_task);
send_task = GNUNET_SCHEDULER_NO_TASK;
if (cc != NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Fail! Could not connect peers\n"));
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = NULL;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
ok = GNUNET_SYSERR;
}
static void
end_badly ()
{
timeout_task = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Timeout! Stopping peers\n");
if (NULL != cc)
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
cc = NULL;
}
if (p1 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
if (p2 != NULL)
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
if (NULL != tth)
GNUNET_TRANSPORT_TESTING_done (tth);
ret = GNUNET_SYSERR;
}
static void
run_stage (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
stage_task = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_SCHEDULER_NO_TASK != die_task)
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running stage %u\n", stage);
if (0 == stage)
{
started = GNUNET_NO;
connected = GNUNET_NO;
if (0 == strcmp(test_name, "test_transport_blacklisting_no_bl"))
{
/* Try to connect peers successfully */
p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_peer1.conf", 1,
NULL, NULL, NULL, &start_cb, NULL);
p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_peer2.conf", 2,
NULL, NULL, NULL, &start_cb, NULL);
}
else if (0 == strcmp(test_name, "test_transport_blacklisting_outbound_bl_full"))
{
p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_blp_peer1_full.conf", 1,
NULL, NULL, NULL, &start_cb, NULL);
p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_peer2.conf", 2,
NULL, NULL, NULL, &start_cb, NULL);
}
else if (0 == strcmp(test_name, "test_transport_blacklisting_outbound_bl_plugin"))
{
p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_blp_peer1_plugin.conf", 1,
NULL, NULL, NULL, &start_cb, NULL);
p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_peer2.conf", 2,
NULL, NULL, NULL, &start_cb, NULL);
}
else if (0 == strcmp(test_name, "test_transport_blacklisting_inbound_bl_full"))
{
p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_peer1.conf", 1,
NULL, NULL, NULL, &start_cb, NULL);
p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_blp_peer2_full.conf", 2,
NULL, NULL, NULL, &start_cb, NULL);
}
else if (0 == strcmp(test_name, "test_transport_blacklisting_inbound_bl_plugin"))
{
p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_peer1.conf", 1,
NULL, NULL, NULL, &start_cb, NULL);
p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_blp_peer2_plugin.conf", 2,
NULL, NULL, NULL, &start_cb, NULL);
}
else if (0 == strcmp(test_name, "test_transport_blacklisting_multiple_plugins"))
{
p1 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_blp_peer1_multiple_plugins.conf", 1,
NULL, NULL, NULL, &start_cb, NULL);
p2 = GNUNET_TRANSPORT_TESTING_start_peer (tth, "test_transport_blacklisting_cfg_blp_peer2_multiple_plugins.conf", 2,
NULL, NULL, NULL, &start_cb, NULL);
}
if ((NULL == p1) || (NULL == p2))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Failed to start peers\n");
ok = 1;
GNUNET_SCHEDULER_add_now (&end, NULL);
}
timeout_task = GNUNET_SCHEDULER_add_delayed (CONNECT_TIMEOUT, &connect_timeout, NULL);
stage ++;
return;
}
if (cc != NULL)
{
GNUNET_TRANSPORT_TESTING_connect_peers_cancel(tth, cc);
cc = NULL;
}
if (p1 != NULL)
{
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
p1 = NULL;
}
if (p2 != NULL)
{
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
p2 = NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Done in stage %u: Peers %s and %s!\n", stage,
(GNUNET_NO == started) ? "NOT STARTED" : "STARTED",
(GNUNET_YES == connected) ? "CONNECTED" : "NOT CONNECTED");
if ((0 == strcmp(test_name, "test_transport_blacklisting_no_bl")) ||
(0 == strcmp(test_name, "test_transport_blacklisting_multiple_plugins")))
{
if ((GNUNET_NO != started) && (GNUNET_YES == connected))
ok = 0;
else
{
GNUNET_break (0);
ok = 1;
}
}
else
{
if ((GNUNET_NO != started) && (GNUNET_YES != connected))
ok = 0;
else
{
ok = 1;
}
}
GNUNET_SCHEDULER_add_now (&end, NULL);
}
