static void
terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"ENDING ANGRILY %u\n", ok);
GNUNET_break (0);
if (NULL != p1.ch)
{
GNUNET_CORE_disconnect (p1.ch);
p1.ch = NULL;
}
if (NULL != p2.ch)
{
GNUNET_CORE_disconnect (p2.ch);
p2.ch = NULL;
}
if (p1.th != NULL)
{
GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
GNUNET_TRANSPORT_disconnect (p1.th);
p1.th = NULL;
}
if (p2.th != NULL)
{
GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
GNUNET_TRANSPORT_disconnect (p2.th);
p2.th = NULL;
}
if (GNUNET_SCHEDULER_NO_TASK != con_task)
{
GNUNET_SCHEDULER_cancel (con_task);
con_task = GNUNET_SCHEDULER_NO_TASK;
}
ok = 42;
}
static void
terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_CORE_Handle *ch;
err_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_STATISTICS_destroy (p1.stats, GNUNET_NO);
GNUNET_STATISTICS_destroy (p2.stats, GNUNET_NO);
GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
if (p1.nth != NULL)
{
GNUNET_CORE_notify_transmit_ready_cancel (p1.nth);
p1.nth = NULL;
}
if (connect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (connect_task);
connect_task = GNUNET_SCHEDULER_NO_TASK;
}
ch = p1.ch;
p1.ch = NULL;
GNUNET_CORE_disconnect (ch);
ch = p2.ch;
p2.ch = NULL;
GNUNET_CORE_disconnect (ch);
GNUNET_TRANSPORT_disconnect (p1.th);
p1.th = NULL;
GNUNET_TRANSPORT_disconnect (p2.th);
p2.th = NULL;
GNUNET_free_non_null (p1.hello);
GNUNET_free_non_null (p2.hello);
}
static void
disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct TestMessageContext *pos = cls;
/* Disconnect from the respective cores */
#if VERBOSE > 1
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from peer 1 `%4s'\n",
GNUNET_i2s (&pos->peer1->id));
#endif
if (pos->peer1handle != NULL)
GNUNET_CORE_disconnect (pos->peer1handle);
#if VERBOSE > 1
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from peer 2 `%4s'\n",
GNUNET_i2s (&pos->peer2->id));
#endif
if (pos->peer2handle != NULL)
GNUNET_CORE_disconnect (pos->peer2handle);
/* Set handles to NULL so test case can be ended properly */
pos->peer1handle = NULL;
pos->peer2handle = NULL;
pos->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
/* Decrement total connections so new can be established */
total_server_connections -= 2;
}
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_CORE_disconnect (p1.ch);
p1.ch = NULL;
GNUNET_CORE_disconnect (p2.ch);
p2.ch = NULL;
ok = 0;
}
static void
finish_testing ()
{
GNUNET_assert (pg != NULL);
struct TestMessageContext *pos;
struct TestMessageContext *free_pos;
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Called finish testing, stopping daemons.\n");
#endif
pos = test_messages;
while (pos != NULL)
{
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
free_pos = pos;
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (free_pos->disconnect_task);
}
GNUNET_free (free_pos);
}
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n",
transmit_ready_scheduled, transmit_ready_failed,
transmit_ready_called);
#endif
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Calling daemons_stop\n");
#endif
GNUNET_TESTING_daemons_stop (pg, timeout, &shutdown_callback, NULL);
if (dotOutFile != NULL)
{
FPRINTF (dotOutFile, "%s", "}");
FCLOSE (dotOutFile);
}
ok = 0;
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *msg = cls;
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"End badly was called (%s)... stopping daemons.\n", msg);
struct TestMessageContext *pos;
struct TestMessageContext *free_pos;
pos = test_messages;
while (pos != NULL)
{
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
free_pos = pos;
pos = pos->next;
GNUNET_free (free_pos);
}
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n",
transmit_ready_scheduled, transmit_ready_failed,
transmit_ready_called);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Total messages received %d, expected %d.\n",
total_messages_received, expected_messages);
#endif
if (pg != NULL)
{
GNUNET_TESTING_daemons_stop (pg, timeout, &shutdown_callback, NULL);
ok = 7331; /* Opposite of leet */
}
else
ok = 401; /* Never got peers started */
if (dotOutFile != NULL)
{
FPRINTF (dotOutFile, "%s", "}");
FCLOSE (dotOutFile);
}
}
static void
terminate_peer (struct PeerContext *p)
{
if (NULL != p->ch)
{
GNUNET_CORE_disconnect (p->ch);
p->ch = NULL;
}
if (NULL != p->ghh)
{
GNUNET_TRANSPORT_hello_get_cancel (p->ghh);
p->ghh = NULL;
}
if (NULL != p->oh)
{
GNUNET_TRANSPORT_offer_hello_cancel (p->oh);
p->oh = NULL;
}
if (NULL != p->ats_sh)
{
GNUNET_ATS_connectivity_suggest_cancel (p->ats_sh);
p->ats_sh = NULL;
}
if (NULL != p->ats)
{
GNUNET_ATS_connectivity_done (p->ats);
p->ats = NULL;
}
}
/**
* Last task run during shutdown. Disconnects us from
* the transport and core.
*
* @param cls unused, NULL
* @param tc scheduler context
*/
static void
cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != peerinfo_notify)
{
GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
peerinfo_notify = NULL;
}
GNUNET_TRANSPORT_disconnect (transport);
transport = NULL;
if (handle != NULL)
{
GNUNET_CORE_disconnect (handle);
handle = NULL;
}
whitelist_peers ();
if (GNUNET_SCHEDULER_NO_TASK != add_task)
{
GNUNET_SCHEDULER_cancel (add_task);
add_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_CONTAINER_multihashmap_iterate (peers, &free_peer, NULL);
GNUNET_CONTAINER_multihashmap_destroy (peers);
peers = NULL;
if (stats != NULL)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
}
static void
timeout_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
FPRINTF (stderr, "%s", "Timeout.\n");
if (p1.ch != NULL)
{
GNUNET_CORE_disconnect (p1.ch);
p1.ch = NULL;
}
if (p2.ch != NULL)
{
GNUNET_CORE_disconnect (p2.ch);
p2.ch = NULL;
}
ok = 42;
}
/**
* Last task run during shutdown. Disconnects us from
* the other services.
*
* @param cls NULL
* @param tc scheduler context
*/
static void
cleaning_task (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Hostlist daemon is shutting down\n");
if (NULL != core)
{
GNUNET_CORE_disconnect (core);
core = NULL;
}
if (bootstrapping)
{
GNUNET_HOSTLIST_client_stop ();
}
#if HAVE_MHD
if (provide_hostlist)
{
GNUNET_HOSTLIST_server_stop ();
}
#endif
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
}
static void
shutdown_task (void *cls,
const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down\n");
GNUNET_MQ_destroy (mq);
GNUNET_CORE_disconnect (core);
}
/**
* Task run during shutdown.
*
* @param cls unused
*/
static void
shutdown_task (void *cls)
{
if (NULL != flood_task)
{
GNUNET_SCHEDULER_cancel (flood_task);
flood_task = NULL;
}
if (NULL != proof_task)
{
GNUNET_SCHEDULER_cancel (proof_task);
proof_task = NULL;
write_proof (); /* remember progress */
}
if (NULL != nc)
{
GNUNET_notification_context_destroy (nc);
nc = NULL;
}
if (NULL != core_api)
{
GNUNET_CORE_disconnect (core_api);
core_api = NULL;
}
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
if (NULL != peers)
{
GNUNET_CONTAINER_multipeermap_destroy (peers);
peers = NULL;
}
if (NULL != my_private_key)
{
GNUNET_free (my_private_key);
my_private_key = NULL;
}
#if ENABLE_NSE_HISTOGRAM
if (NULL != logger_test)
{
GNUNET_CLIENT_service_test_cancel (logger_test);
logger_test = NULL;
}
if (NULL != lh)
{
GNUNET_TESTBED_LOGGER_flush (lh,
&flush_comp_cb,
NULL);
}
if (NULL != histogram)
{
GNUNET_BIO_write_close (histogram);
histogram = NULL;
}
#endif
}
/**
* @brief This function releases all resources held by the flooding component.
*
* \latexonly \\ \\ \endlatexonly
* \em Detailed \em description \n
* This function releases all resources held by the flooding component. It also disconnects from the GNUnet core and flushes the output queue.
*/
void gnunet_search_flooding_free() {
GNUNET_CORE_disconnect(gnunet_search_flooding_core_handle);
GNUNET_free(gnunet_search_flooding_routing_table);
while(queue_get_length(gnunet_search_flooding_message_queue)) {
struct gnunet_search_flooding_queued_message *msg =
(struct gnunet_search_flooding_queued_message *) queue_dequeue(gnunet_search_flooding_message_queue);
GNUNET_free(msg->buffer);
GNUNET_free(msg);
}
}
/**
* Function scheduled as very last function, cleans up after us
*/
static void
cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tskctx)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
if (core != NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting core.\n");
GNUNET_CORE_disconnect (core);
core = NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending test.\n");
}
static void
terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_assert (ok == 6);
GNUNET_CORE_disconnect (p1.ch);
p1.ch = NULL;
GNUNET_CORE_disconnect (p2.ch);
p2.ch = NULL;
GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
p1.ghh = NULL;
GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
p2.ghh = NULL;
GNUNET_TRANSPORT_disconnect (p1.th);
p1.th = NULL;
GNUNET_TRANSPORT_disconnect (p2.th);
p2.th = NULL;
if (GNUNET_SCHEDULER_NO_TASK != con_task)
{
GNUNET_SCHEDULER_cancel (con_task);
con_task = GNUNET_SCHEDULER_NO_TASK;
}
ok = 0;
}
static void
terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
err_task = GNUNET_SCHEDULER_NO_TASK;
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase failed!\n");
//GNUNET_break (0);
if (p1.nth != NULL)
{
GNUNET_CORE_notify_transmit_ready_cancel (p1.nth);
p1.nth = NULL;
}
if (measure_task != GNUNET_SCHEDULER_NO_TASK)
GNUNET_SCHEDULER_cancel (measure_task);
if (connect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (connect_task);
connect_task = GNUNET_SCHEDULER_NO_TASK;
}
GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
if (NULL != p1.ch)
GNUNET_CORE_disconnect (p1.ch);
p1.ch = NULL;
if (NULL != p2.ch)
GNUNET_CORE_disconnect (p2.ch);
p2.ch = NULL;
if (NULL != p1.th)
GNUNET_TRANSPORT_disconnect (p1.th);
p1.th = NULL;
if (NULL != p2.th)
GNUNET_TRANSPORT_disconnect (p2.th);
p2.th = NULL;
ok = 42;
}
static void
disconnect_cores (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct TestMessageContext *pos = cls;
/* Disconnect from the respective cores */
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from peer 1 `%4s'\n",
GNUNET_i2s (&pos->peer1->id));
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from peer 2 `%4s'\n",
GNUNET_i2s (&pos->peer2->id));
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
pos->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
/* Decrement total connections so new can be established */
total_server_connections -= 2;
}
/**
* Last task run during shutdown. Disconnects us from
* the transport and core.
*
* @param cls unused, NULL
*/
static void
cleaning_task (void *cls)
{
if (NULL != peerinfo_notify)
{
GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
peerinfo_notify = NULL;
}
if (NULL != handle)
{
GNUNET_CORE_disconnect (handle);
handle = NULL;
}
whitelist_peers ();
if (NULL != add_task)
{
GNUNET_SCHEDULER_cancel (add_task);
add_task = NULL;
}
if (NULL != oh)
{
GNUNET_TRANSPORT_offer_hello_cancel (oh);
oh = NULL;
}
GNUNET_CONTAINER_multipeermap_iterate (peers,
&free_peer,
NULL);
GNUNET_CONTAINER_multipeermap_destroy (peers);
peers = NULL;
if (NULL != ats)
{
GNUNET_ATS_connectivity_done (ats);
ats = NULL;
}
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
}
static void
terminate_peer (struct PeerContext *p)
{
if (p->nth != NULL)
{
GNUNET_CORE_notify_transmit_ready_cancel (p->nth);
p->nth = NULL;
}
if (NULL != p->ch)
{
GNUNET_CORE_disconnect (p->ch);
p->ch = NULL;
}
if (NULL != p->th)
{
GNUNET_TRANSPORT_get_hello_cancel (p->ghh);
GNUNET_TRANSPORT_disconnect (p->th);
p->th = NULL;
}
if (NULL != p->ats_sh)
{
GNUNET_ATS_connectivity_suggest_cancel (p->ats_sh);
p->ats_sh = NULL;
}
if (NULL != p->ats)
{
GNUNET_ATS_connectivity_done (p->ats);
p->ats = NULL;
}
if (NULL != p->stats)
{
GNUNET_STATISTICS_destroy (p->stats, GNUNET_NO);
p->stats = NULL;
}
if (NULL != p->hello)
{
GNUNET_free (p->hello);
p->hello = NULL;
}
}
/**
* Stop the nodes management
*/
void
GED_nodes_stop ()
{
if (NULL != ch)
{
GNUNET_CORE_disconnect (ch);
ch = NULL;
}
if (NULL != nodes_requested)
{
GNUNET_CONTAINER_multipeermap_iterate (nodes_requested,
&cleanup_node,
nodes_requested);
update_stats (nodes_requested);
GNUNET_CONTAINER_multipeermap_destroy (nodes_requested);
nodes_requested = NULL;
}
if (NULL != nodes_active)
{
GNUNET_CONTAINER_multipeermap_iterate (nodes_active,
&cleanup_node,
nodes_active);
update_stats (nodes_active);
GNUNET_CONTAINER_multipeermap_destroy (nodes_active);
nodes_active = NULL;
}
if (NULL != nodes_inactive)
{
GNUNET_CONTAINER_multipeermap_iterate (nodes_inactive,
&cleanup_node,
nodes_inactive);
update_stats (nodes_inactive);
GNUNET_CONTAINER_multipeermap_destroy (nodes_inactive);
nodes_inactive = NULL;
}
}
static void
shutdown_testcase ()
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown testcase....\n");
if (timeout_task != NULL)
{
GNUNET_SCHEDULER_cancel (timeout_task);
timeout_task = NULL;
}
if (NULL != download_stats)
{
GNUNET_STATISTICS_get_cancel (download_stats);
download_stats = NULL;
}
if (NULL != urisrecv_stat)
{
GNUNET_STATISTICS_get_cancel (urisrecv_stat);
urisrecv_stat = NULL;
}
if (NULL != advsent_stat)
{
GNUNET_STATISTICS_get_cancel (advsent_stat);
advsent_stat = NULL;
}
if (NULL != adv_peer.stats)
{
GNUNET_STATISTICS_destroy (adv_peer.stats, GNUNET_NO);
adv_peer.stats = NULL;
}
if (NULL != learn_peer.stats)
{
GNUNET_STATISTICS_destroy (learn_peer.stats, GNUNET_NO);
learn_peer.stats = NULL;
}
if (check_task != NULL)
{
GNUNET_SCHEDULER_cancel (check_task);
check_task = NULL;
}
if (NULL != current_adv_uri)
{
GNUNET_free (current_adv_uri);
current_adv_uri = NULL;
}
if (adv_peer.th != NULL)
{
GNUNET_TRANSPORT_disconnect (adv_peer.th);
adv_peer.th = NULL;
}
if (learn_peer.th != NULL)
{
GNUNET_TRANSPORT_disconnect (learn_peer.th);
learn_peer.th = NULL;
}
if (adv_peer.core != NULL)
{
GNUNET_CORE_disconnect (adv_peer.core);
adv_peer.core = NULL;
}
if (learn_peer.core != NULL)
{
GNUNET_CORE_disconnect (learn_peer.core);
learn_peer.core = NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Killing hostlist server ARM process.\n");
if (0 != GNUNET_OS_process_kill (adv_peer.arm_proc, GNUNET_TERM_SIG))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
if (GNUNET_OS_process_wait (adv_peer.arm_proc) != GNUNET_OK)
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
GNUNET_OS_process_destroy (adv_peer.arm_proc);
adv_peer.arm_proc = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Killing hostlist client ARM process.\n");
if (0 != GNUNET_OS_process_kill (learn_peer.arm_proc, GNUNET_TERM_SIG))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
if (GNUNET_OS_process_wait (learn_peer.arm_proc) != GNUNET_OK)
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
GNUNET_OS_process_destroy (learn_peer.arm_proc);
learn_peer.arm_proc = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutdown complete....\n");
}
static void
send_other_messages (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct TestMessageContext *pos;
struct TestMessageContext *free_pos;
struct PeerContext *peer_pos;
#if TEST_ALL
struct PeerContext *inner_peer_pos;
struct TestMessageContext *temp_context;
#endif
peer_pos = all_peers;
while (peer_pos != NULL)
{
if (peer_pos->peer_handle != NULL)
{
GNUNET_CORE_disconnect (peer_pos->peer_handle);
peer_pos->peer_handle = NULL;
}
#if TEST_ALL
inner_peer_pos = all_peers;
while (inner_peer_pos != NULL)
{
if (inner_peer_pos != peer_pos)
{
temp_total_other_messages++;
temp_context = GNUNET_malloc (sizeof (struct TestMessageContext));
temp_context->peer1 = peer_pos->daemon;
temp_context->peer2 = inner_peer_pos->daemon;
temp_context->next = other_test_messages;
temp_context->uid = total_connections + temp_total_other_messages;
temp_context->disconnect_task = GNUNET_SCHEDULER_NO_TASK;
other_test_messages = temp_context;
}
inner_peer_pos = inner_peer_pos->next;
}
#endif
peer_pos = peer_pos->next;
}
all_peers = NULL;
pos = test_messages;
while (pos != NULL)
{
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
free_pos = pos;
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (free_pos->disconnect_task);
}
GNUNET_free (free_pos);
}
test_messages = NULL;
total_other_expected_messages = temp_total_other_messages;
if (total_other_expected_messages == 0)
{
GNUNET_SCHEDULER_add_now (&end_badly,
"send_other_messages had 0 messages to send, no DV connections made!");
}
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Preparing to send %d other test messages\n",
total_other_expected_messages);
GNUNET_SCHEDULER_add_now (&send_test_messages, other_test_messages);
if (GNUNET_SCHEDULER_NO_TASK != die_task)
GNUNET_SCHEDULER_cancel (die_task);
die_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 250), &end_badly,
"from send_other_messages");
}
static void
end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
char *msg = cls;
struct TestMessageContext *pos;
struct TestMessageContext *free_pos;
struct PeerContext *peer_pos;
struct PeerContext *free_peer_pos;
die_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"End badly was called (%s)... stopping daemons.\n", msg);
peer_pos = all_peers;
while (peer_pos != NULL)
{
if (peer_pos->peer_handle != NULL)
GNUNET_CORE_disconnect (peer_pos->peer_handle);
free_peer_pos = peer_pos;
peer_pos = peer_pos->next;
GNUNET_free (free_peer_pos);
}
all_peers = NULL;
pos = test_messages;
while (pos != NULL)
{
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
free_pos = pos;
pos = pos->next;
GNUNET_free (free_pos);
}
pos = other_test_messages;
while (pos != NULL)
{
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
free_pos = pos;
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (free_pos->disconnect_task);
}
GNUNET_free (free_pos);
}
if (pg != NULL)
{
GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
ok = 7331; /* Opposite of leet */
}
else
ok = 401; /* Never got peers started */
if (dotOutFile != NULL)
{
FPRINTF (dotOutFile, "%s", "}");
FCLOSE (dotOutFile);
}
}
static void
finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_assert (pg != NULL);
struct PeerContext *peer_pos;
struct PeerContext *free_peer_pos;
struct TestMessageContext *pos;
struct TestMessageContext *free_pos;
die_task = GNUNET_SCHEDULER_NO_TASK;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Called finish testing, stopping daemons.\n");
peer_pos = all_peers;
while (peer_pos != NULL)
{
if (peer_pos->peer_handle != NULL)
GNUNET_CORE_disconnect (peer_pos->peer_handle);
free_peer_pos = peer_pos;
peer_pos = peer_pos->next;
GNUNET_free (free_peer_pos);
}
all_peers = NULL;
pos = test_messages;
while (pos != NULL)
{
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
free_pos = pos;
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (free_pos->disconnect_task);
}
GNUNET_free (free_pos);
}
pos = other_test_messages;
while (pos != NULL)
{
if (pos->peer1handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer1handle);
pos->peer1handle = NULL;
}
if (pos->peer2handle != NULL)
{
GNUNET_CORE_disconnect (pos->peer2handle);
pos->peer2handle = NULL;
}
free_pos = pos;
pos = pos->next;
if (free_pos->disconnect_task != GNUNET_SCHEDULER_NO_TASK)
{
GNUNET_SCHEDULER_cancel (free_pos->disconnect_task);
}
GNUNET_free (free_pos);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"transmit_ready's scheduled %d, failed %d, transmit_ready's called %d\n",
transmit_ready_scheduled, transmit_ready_failed,
transmit_ready_called);
GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
if (dotOutFile != NULL)
{
FPRINTF (dotOutFile, "%s", "}");
FCLOSE (dotOutFile);
}
ok = 0;
}
