static void
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *p = cls;
if ( (NULL != p1) &&
(0 == memcmp (peer, &p1->id, sizeof (struct GNUNET_PeerIdentity))))
{
p1_connected = GNUNET_NO;
}
if ( (NULL != p2) &&
(0 == memcmp (peer, &p2->id, sizeof (struct GNUNET_PeerIdentity))))
{
p2_connected = GNUNET_NO;
}
char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Peer %u (`%4s'): peer (`%s') disconnected from me!\n", p->no, ps,
GNUNET_i2s (peer));
GNUNET_free (ps);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (GNUNET_SCHEDULER_NO_TASK != send_task)
GNUNET_SCHEDULER_cancel (send_task);
send_task = GNUNET_SCHEDULER_NO_TASK;
}
static void
end ()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
if (send_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (send_task);
send_task = GNUNET_SCHEDULER_NO_TASK;
if (reconnect_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (reconnect_task);
reconnect_task = GNUNET_SCHEDULER_NO_TASK;
if (die_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
p1 = NULL;
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
p2 = NULL;
}
static void
end ()
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Stopping peers\n");
if (send_task != NULL)
GNUNET_SCHEDULER_cancel (send_task);
if (die_task != NULL)
GNUNET_SCHEDULER_cancel (die_task);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
p1 = NULL;
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
p2 = NULL;
if (NULL != vmc_p1)
{
GNUNET_TRANSPORT_monitor_validation_entries_cancel (vmc_p1);
vmc_p1 = NULL;
}
if (NULL != vmc_p2)
{
GNUNET_TRANSPORT_monitor_validation_entries_cancel (vmc_p2);
vmc_p2 = NULL;
}
ok = 0;
}
static void
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *p = cls;
{
char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Peer %u (`%4s'): peer (`%s') disconnected from me!\n",
p->no,
ps,
GNUNET_i2s (peer));
GNUNET_free (ps);
}
if (NULL != send_task)
{
GNUNET_SCHEDULER_cancel(send_task);
GNUNET_break (0);
send_task = NULL;
}
if (NULL != th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
}
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_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 (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;
}
}
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);
}
void
GNUNET_ATS_TEST_generate_traffic_stop (struct TrafficGenerator *tg)
{
GNUNET_CONTAINER_DLL_remove (tg_head, tg_tail, tg);
tg->dest->tg = NULL;
if (GNUNET_SCHEDULER_NO_TASK != tg->send_task)
{
GNUNET_SCHEDULER_cancel (tg->send_task);
tg->send_task = GNUNET_SCHEDULER_NO_TASK;
}
if (top->test_core)
{
if (NULL != tg->dest->cth)
{
GNUNET_CORE_notify_transmit_ready_cancel (tg->dest->cth);
tg->dest->cth = NULL;
}
}
else
{
if (NULL != tg->dest->tth)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (tg->dest->tth);
tg->dest->tth = NULL;
}
}
GNUNET_free (tg);
}
static void
end ()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
if (send_task != NULL)
{
GNUNET_SCHEDULER_cancel (send_task);
send_task = NULL;
}
if (die_task != NULL)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = NULL;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = 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;
/* success */
ok = 0;
}
/**
* Task run in monitor mode when the user presses CTRL-C to abort.
* Stops monitoring activity.
*
* @param cls the 'struct GNUNET_TRANSPORT_PeerIterateContext *'
* @param tc scheduler context
*/
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_TIME_Relative duration;
end = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_SCHEDULER_NO_TASK != op_timeout)
{
GNUNET_SCHEDULER_cancel (op_timeout);
op_timeout = GNUNET_SCHEDULER_NO_TASK;
}
if (NULL != tc_handle)
{
GNUNET_TRANSPORT_try_connect_cancel (tc_handle);
tc_handle = NULL;
}
if (NULL != pic)
{
GNUNET_TRANSPORT_monitor_peers_cancel (pic);
pic = NULL;
}
if (NULL != vic)
{
GNUNET_TRANSPORT_monitor_validation_entries_cancel (vic);
vic = NULL;
}
if (NULL != th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
if (NULL != handle)
{
GNUNET_TRANSPORT_disconnect (handle);
handle = NULL;
}
if (benchmark_send)
{
duration = GNUNET_TIME_absolute_get_duration (start_time);
FPRINTF (stdout, _("Transmitted %llu bytes/s (%llu bytes in %s)\n"),
1000LL * 1000LL * traffic_sent / (1 + duration.rel_value_us),
traffic_sent,
GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
}
if (benchmark_receive)
{
duration = GNUNET_TIME_absolute_get_duration (start_time);
FPRINTF (stdout, _("Received %llu bytes/s (%llu bytes in %s)\n"),
1000LL * 1000LL * traffic_received / (1 + duration.rel_value_us),
traffic_received,
GNUNET_STRINGS_relative_time_to_string (duration, GNUNET_YES));
}
if (NULL != monitored_peers)
{
GNUNET_CONTAINER_multipeermap_iterate (monitored_peers, &destroy_it, NULL);
GNUNET_CONTAINER_multipeermap_destroy (monitored_peers);
monitored_peers = NULL;
}
}
static void
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer `%4s' disconnected (%p)!\n",
GNUNET_i2s (peer), cls);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
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
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *p = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Peer %u (`%4s') disconnected!\n", p->no,
GNUNET_i2s (peer));
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = 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
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
if (shutdown_flag != GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"FAIL! Peer `%4s' disconnected during waiting period!\n",
GNUNET_i2s (peer));
disconnects++;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
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
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *p = cls;
char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Peer %u (`%4s'): peer (`%s') disconnected from me!\n", p->no, ps,
GNUNET_i2s (peer));
GNUNET_free (ps);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
/**
* Free the given entry for the neighbour.
*
* @param n neighbour to free
*/
static void
free_neighbour (struct Neighbour *n)
{
struct NeighbourMessageEntry *m;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Destroying neighbour entry for peer `%s'\n",
GNUNET_i2s (&n->peer));
while (NULL != (m = n->message_head))
{
GNUNET_CONTAINER_DLL_remove (n->message_head,
n->message_tail,
m);
n->queue_size--;
GNUNET_free (m);
}
GNUNET_assert (0 == n->queue_size);
if (NULL != n->th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (n->th);
n->th = NULL;
}
GNUNET_STATISTICS_update (GSC_stats,
gettext_noop
("# sessions terminated by transport disconnect"),
1, GNUNET_NO);
if (NULL != n->kxinfo)
{
GSC_KX_stop (n->kxinfo);
n->kxinfo = NULL;
}
if (NULL != n->retry_plaintext_task)
{
GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
n->retry_plaintext_task = NULL;
}
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multipeermap_remove (neighbours,
&n->peer, n));
GNUNET_STATISTICS_set (GSC_stats,
gettext_noop ("# neighbour entries allocated"),
GNUNET_CONTAINER_multipeermap_size (neighbours),
GNUNET_NO);
GNUNET_free (n);
}
/**
* Function called to notify transport users that another
* peer disconnected from us.
*
* @param cls closure
* @param peer the peer that disconnected
*/
static void
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
if (0 != memcmp (&pid, peer, sizeof (struct GNUNET_PeerIdentity)))
return;
if (NULL != th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
if (benchmark_send)
{
FPRINTF (stdout, _("Disconnected from peer `%s' while benchmarking\n"), GNUNET_i2s (&pid));
if (GNUNET_SCHEDULER_NO_TASK != end)
GNUNET_SCHEDULER_cancel (end);
return;
}
}
static void
end ()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\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);
if (NULL != th)
{
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
}
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
}
static void
notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
{
struct PeerContext *p = cls;
char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Peer %u (`%4s'): peer (`%s') disconnected from me!\n", p->no, ps,
GNUNET_i2s (peer));
GNUNET_free (ps);
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
if (shutdown_ == GNUNET_YES)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Complete, shutting down...\n");
GNUNET_SCHEDULER_add_now (&end, NULL);
}
}
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 ()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
if (timer_task != NULL)
{
GNUNET_SCHEDULER_cancel (timer_task);
timer_task = NULL;
}
if (die_task != NULL)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = NULL;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
if (disconnects == 0)
ok = 0;
else
{
ok = disconnects;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Fail! Had %u disconnects while waiting %s\n",
disconnects,
GNUNET_STRINGS_relative_time_to_string (WAIT,
GNUNET_YES));
}
GNUNET_TRANSPORT_TESTING_done (tth);
}
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 ()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping peers\n");
if (timer_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (timer_task);
timer_task = GNUNET_SCHEDULER_NO_TASK;
}
if (die_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (die_task);
die_task = GNUNET_SCHEDULER_NO_TASK;
}
if (th != NULL)
GNUNET_TRANSPORT_notify_transmit_ready_cancel (th);
th = NULL;
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p1);
GNUNET_TRANSPORT_TESTING_stop_peer (tth, p2);
if (disconnects == 0)
ok = 0;
else
{
ok = disconnects;
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Fail! Had %u disconnects while waiting %llu seconds \n",
disconnects, WAIT.rel_value);
}
GNUNET_TRANSPORT_TESTING_done (tth);
}
