/**
* Shutdown nicely
*/
static void
do_close (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
switch (test_step)
{
case TEST_STEP_1_HOP:
if (NULL != peer_data[0].socket)
GNUNET_STREAM_close (peer_data[0].socket);
if (NULL != peer_data[1].socket)
GNUNET_STREAM_close (peer_data[1].socket);
if (NULL != peer2_listen_socket)
GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */
break;
case TEST_STEP_2_HOP:
if (NULL != peer_data[1].socket)
GNUNET_STREAM_close (peer_data[1].socket);
if (NULL != peer_data[0].op)
GNUNET_TESTBED_operation_done (peer_data[0].op);
if (NULL != peer_data[1].op)
GNUNET_TESTBED_operation_done (peer_data[1].op);
break;
case TEST_STEP_3_HOP:
GNUNET_break (0);
}
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (GNUNET_SCHEDULER_NO_TASK != write_task)
GNUNET_SCHEDULER_cancel (write_task);
GNUNET_SCHEDULER_shutdown (); /* Shutdown this testcase */
if (NULL != meter)
{
free_meter (meter);
meter = NULL;
}
}
/**
* Shutdown nicely
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_STREAM_close (peer1.socket);
if (NULL != peer2.socket)
GNUNET_STREAM_close (peer2.socket);
if (NULL != peer2_listen_socket)
GNUNET_STREAM_listen_close (peer2_listen_socket);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: shutdown\n");
if (0 != abort_task)
{
GNUNET_SCHEDULER_cancel (abort_task);
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: arm\n");
if (0 != GNUNET_OS_process_kill (arm_pid, SIGTERM))
{
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Wait\n");
/* Free the duplicated configuration */
GNUNET_CONFIGURATION_destroy (config_peer1);
GNUNET_CONFIGURATION_destroy (config_peer2);
GNUNET_assert (GNUNET_OK == GNUNET_OS_process_wait (arm_pid));
GNUNET_OS_process_destroy (arm_pid);
}
/**
* Shutdown nicely
*/
static void
do_close (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (NULL != peer1.socket)
GNUNET_STREAM_close (peer1.socket);
if (NULL != peer2.socket)
GNUNET_STREAM_close (peer2.socket);
if (NULL != peer2_listen_socket)
GNUNET_STREAM_listen_close (peer2_listen_socket); /* Close listen socket */
}
/**
* Destroy a stream handle.
*
* @param sh stream to process
*/
static void
destroy_stream_handle (struct StreamHandle *sh)
{
struct GSF_StreamRequest *sr;
while (NULL != (sr = sh->pending_head))
{
sr->proc (sr->proc_cls, GNUNET_BLOCK_TYPE_ANY,
GNUNET_TIME_UNIT_FOREVER_ABS,
0, NULL);
GSF_stream_query_cancel (sr);
}
GNUNET_CONTAINER_multihashmap_iterate (sh->waiting_map,
&free_waiting_entry,
sh);
if (NULL != sh->wh)
GNUNET_STREAM_io_write_cancel (sh->wh);
if (NULL != sh->rh)
GNUNET_STREAM_io_read_cancel (sh->rh);
if (GNUNET_SCHEDULER_NO_TASK != sh->timeout_task)
GNUNET_SCHEDULER_cancel (sh->timeout_task);
GNUNET_STREAM_close (sh->stream);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONTAINER_multihashmap_remove (stream_map,
&sh->target.hashPubKey,
sh));
GNUNET_CONTAINER_multihashmap_destroy (sh->waiting_map);
GNUNET_free (sh);
}
/**
* Adapter function called to destroy a connection to
* a service.
*
* @param cls closure
* @param op_result service handle returned from the connect adapter
*/
static void
stream_da (void *cls, void *op_result)
{
if (&peer_data[1] == cls)
{
GNUNET_STREAM_listen_close (op_result);
return;
}
else if (&peer_data[0] == cls)
{
GNUNET_STREAM_close (op_result);
return;
}
GNUNET_assert (0);
}
/**
* We had a serious error, tear down and re-create stream from scratch.
*
* @param sh stream to reset
*/
static void
reset_stream (struct StreamHandle *sh)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Resetting stream to %s\n",
GNUNET_i2s (&sh->target));
if (NULL != sh->rh)
GNUNET_STREAM_io_read_cancel (sh->rh);
GNUNET_STREAM_close (sh->stream);
sh->is_ready = GNUNET_NO;
GNUNET_CONTAINER_multihashmap_iterate (sh->waiting_map,
&move_to_pending,
sh);
sh->stream = GNUNET_STREAM_open (GSF_cfg,
&sh->target,
GNUNET_APPLICATION_TYPE_FS_BLOCK_TRANSFER,
&stream_ready_cb, sh,
GNUNET_STREAM_OPTION_END);
}
/**
* We're done with a particular client, clean up.
*
* @param sc client to clean up
*/
static void
terminate_stream (struct StreamClient *sc)
{
GNUNET_STATISTICS_update (GSF_stats,
gettext_noop ("# stream connections active"), -1,
GNUNET_NO);
if (GNUNET_SCHEDULER_NO_TASK != sc->terminate_task)
GNUNET_SCHEDULER_cancel (sc->terminate_task);
if (GNUNET_SCHEDULER_NO_TASK != sc->timeout_task)
GNUNET_SCHEDULER_cancel (sc->timeout_task);
if (NULL != sc->rh)
GNUNET_STREAM_io_read_cancel (sc->rh);
if (NULL != sc->wh)
GNUNET_STREAM_io_write_cancel (sc->wh);
if (NULL != sc->qe)
GNUNET_DATASTORE_cancel (sc->qe);
GNUNET_SERVER_mst_destroy (sc->mst);
GNUNET_STREAM_close (sc->socket);
GNUNET_CONTAINER_DLL_remove (sc_head,
sc_tail,
sc);
sc_count--;
GNUNET_free (sc);
}
