/**
* 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
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (NULL != hc_handle)
GNUNET_TESTBED_is_host_habitable_cancel (hc_handle);
GNUNET_assert (NULL == delayed_connect_task);
if (NULL != common_operation)
GNUNET_TESTBED_operation_done (common_operation);
if (NULL != reg_handle)
GNUNET_TESTBED_cancel_registration (reg_handle);
if (NULL != controller1)
GNUNET_TESTBED_controller_disconnect (controller1);
GNUNET_CONFIGURATION_destroy (cfg);
if (NULL != cfg2)
GNUNET_CONFIGURATION_destroy (cfg2);
if (NULL != cp1)
GNUNET_TESTBED_controller_stop (cp1);
if (NULL != host)
GNUNET_TESTBED_host_destroy (host);
if (NULL != neighbour1)
GNUNET_TESTBED_host_destroy (neighbour1);
if (NULL != neighbour2)
GNUNET_TESTBED_host_destroy (neighbour2);
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (NULL != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (NULL != delay_task_id)
{
GNUNET_SCHEDULER_cancel (delay_task_id);
delay_task_id = NULL;
}
if (NULL != hc_handle)
GNUNET_TESTBED_is_host_habitable_cancel (hc_handle);
if (NULL != mc)
GNUNET_TESTBED_controller_disconnect (mc);
if (NULL != cp)
GNUNET_TESTBED_controller_stop (cp);
if (NULL != slave3)
GNUNET_TESTBED_host_destroy (slave3);
if (NULL != slave2)
GNUNET_TESTBED_host_destroy (slave2);
if (NULL != slave)
GNUNET_TESTBED_host_destroy (slave);
if (NULL != host)
GNUNET_TESTBED_host_destroy (host);
if (NULL != cfg)
GNUNET_CONFIGURATION_destroy (cfg);
if (NULL != cfg3)
GNUNET_CONFIGURATION_destroy (cfg3);
if (NULL != rh)
GNUNET_TESTBED_cancel_registration (rh);
}
/**
* Callback which will be called when peer stop type operation is released
*
* @param cls the closure from GNUNET_TESTBED_operation_create_()
*/
static void
oprelease_peer_getinfo (void *cls)
{
struct OperationContext *opc = cls;
struct GNUNET_TESTBED_PeerInformation *data;
if (OPC_STATE_FINISHED != opc->state)
{
GNUNET_free_non_null (opc->data);
GNUNET_CONTAINER_DLL_remove (opc->c->ocq_head, opc->c->ocq_tail, opc);
}
else
{
data = opc->data;
GNUNET_assert (NULL != data);
switch (data->pit)
{
case GNUNET_TESTBED_PIT_CONFIGURATION:
GNUNET_CONFIGURATION_destroy (data->result.cfg);
break;
case GNUNET_TESTBED_PIT_IDENTITY:
GNUNET_free (data->result.id);
break;
default:
GNUNET_assert (0); /* We should never reach here */
}
GNUNET_free (data);
}
GNUNET_free (opc);
}
/**
* Disconnect from the ARM service (if connected) and destroy the context.
*
* @param h the handle that was being used
*/
void
GNUNET_ARM_monitor_disconnect_and_free (struct GNUNET_ARM_MonitorHandle *h)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n");
if (NULL != h->cth)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
h->cth = NULL;
}
if (NULL != h->init_timeout_task_id)
{
GNUNET_SCHEDULER_cancel (h->init_timeout_task_id);
h->init_timeout_task_id = NULL;
}
if (NULL != h->monitor)
{
GNUNET_CLIENT_disconnect (h->monitor);
h->monitor = NULL;
}
if (NULL != h->reconnect_task)
{
GNUNET_SCHEDULER_cancel (h->reconnect_task);
h->reconnect_task = NULL;
}
GNUNET_CONFIGURATION_destroy (h->cfg);
GNUNET_free (h);
}
/**
* Task run during shutdown.
*
* @param cls unused
* @param tc unused
*/
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct Ego *e;
if (NULL != nc)
{
GNUNET_SERVER_notification_context_destroy (nc);
nc = NULL;
}
if (NULL != stats)
{
GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
stats = NULL;
}
GNUNET_CONFIGURATION_destroy (subsystem_cfg);
subsystem_cfg = NULL;
GNUNET_free (subsystem_cfg_file);
subsystem_cfg_file = NULL;
GNUNET_free (ego_directory);
ego_directory = NULL;
while (NULL != (e = ego_head))
{
GNUNET_CONTAINER_DLL_remove (ego_head, ego_tail, e);
GNUNET_free (e->pk);
GNUNET_free (e->identifier);
GNUNET_free (e);
}
}
/**
* Assuming all peers have been destroyed cleanup run handle
*
* @param rc the run context
*/
static void
cleanup (struct GNUNET_TESTBED_RunHandle *rc)
{
unsigned int hid;
GNUNET_assert (NULL == rc->register_hosts_task);
GNUNET_assert (NULL == rc->reg_handle);
GNUNET_assert (NULL == rc->peers);
GNUNET_assert (NULL == rc->hclist);
GNUNET_assert (RC_PEERS_SHUTDOWN == rc->state);
GNUNET_assert (0 == GNUNET_CONTAINER_multihashmap32_size (rc->rcop_map));
GNUNET_CONTAINER_multihashmap32_destroy (rc->rcop_map);
if (NULL != rc->c)
GNUNET_TESTBED_controller_disconnect (rc->c);
if (NULL != rc->cproc)
GNUNET_TESTBED_controller_stop (rc->cproc);
if (NULL != rc->h)
GNUNET_TESTBED_host_destroy (rc->h);
for (hid = 0; hid < rc->num_hosts; hid++)
GNUNET_TESTBED_host_destroy (rc->hosts[hid]);
GNUNET_free_non_null (rc->hosts);
if (NULL != rc->cfg)
GNUNET_CONFIGURATION_destroy (rc->cfg);
GNUNET_free_non_null (rc->topo_file);
GNUNET_free_non_null (rc->trusted_ip);
GNUNET_free (rc);
}
/**
* Function to replace host's configuration
*
* @param host the host handle
* @param new_cfg the new configuration to replace the old one
*/
void
GNUNET_TESTBED_host_replace_cfg_ (struct GNUNET_TESTBED_Host *host,
const struct GNUNET_CONFIGURATION_Handle *new_cfg)
{
GNUNET_CONFIGURATION_destroy (host->cfg);
host->cfg = GNUNET_CONFIGURATION_dup (new_cfg);
}
/**
* Main run function.
*
* @param cls NULL
* @param args arguments passed to GNUNET_PROGRAM_run
* @param cfgfile the path to configuration file
* @param cfg the configuration file handle
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
cfg = GNUNET_CONFIGURATION_dup (config);
host = GNUNET_TESTBED_host_create (NULL, NULL, cfg, 0);
FAIL_TEST (NULL != host);
if (NULL ==
(hc_handle =
GNUNET_TESTBED_is_host_habitable (host, config, &host_habitable_cb,
NULL)))
{
GNUNET_TESTBED_host_destroy (host);
GNUNET_CONFIGURATION_destroy (cfg);
cfg = NULL;
host = NULL;
(void) PRINTF ("%s",
"Unable to run the test as this system is not configured "
"to use password less SSH logins to localhost.\n"
"Marking test as successful\n");
result = SKIP;
return;
}
abort_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5), &do_abort,
NULL);
}
/**
* Main function
*/
int
main (int argc, char **argv)
{
struct GNUNET_CONFIGURATION_Handle *cfg;
char pwd[PATH_MAX];
char *binary;
uint64_t event_mask;
result = GNUNET_SYSERR;
event_mask = 0;
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_assert (GNUNET_YES ==
GNUNET_CONFIGURATION_parse (cfg,
"test_testbed_api_barriers.conf.in"));
if (NULL == getcwd (pwd, PATH_MAX))
return 1;
GNUNET_assert (0 < GNUNET_asprintf (&binary, "%s/%s", pwd,
"gnunet-service-test-barriers"));
GNUNET_CONFIGURATION_set_value_string (cfg, "test-barriers","BINARY", binary);
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write
(cfg, "test_testbed_api_barriers.conf"));
GNUNET_CONFIGURATION_destroy (cfg);
cfg = NULL;
GNUNET_free (binary);
binary = NULL;
(void) GNUNET_TESTBED_test_run ("test_testbed_api_barriers",
"test_testbed_api_barriers.conf", NUM_PEERS,
event_mask, NULL, NULL,
&test_master, NULL);
(void) unlink ("test_testbed_api_barriers.conf");
if (GNUNET_OK != result)
return 1;
return 0;
}
static char *
generate_config (char *cfg_file, unsigned long long quota_in,
unsigned long long quota_out)
{
char *networks[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkTypeString;
char *in_name;
char *out_name;
char *fname = NULL;
struct GNUNET_CONFIGURATION_Handle *cfg = GNUNET_CONFIGURATION_create ();
int c;
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (cfg, cfg_file));
GNUNET_asprintf (&fname, "q_in_%llu_q_out_%llu_%s", quota_in, quota_out,
cfg_file);
GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG", fname);
for (c = 0; c < GNUNET_ATS_NetworkTypeCount; c++)
{
GNUNET_asprintf (&in_name, "%s_QUOTA_IN", networks[c]);
GNUNET_asprintf (&out_name, "%s_QUOTA_OUT", networks[c]);
GNUNET_CONFIGURATION_set_value_number (cfg, "ats", in_name, quota_in);
GNUNET_CONFIGURATION_set_value_number (cfg, "ats", out_name, quota_out);
GNUNET_free (in_name);
GNUNET_free (out_name);
}
GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_write (cfg, fname));
GNUNET_CONFIGURATION_destroy (cfg);
return fname;
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct DLLOperation *dll_op;
unsigned int nhost;
shutdown_task = GNUNET_SCHEDULER_NO_TASK;
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (GNUNET_SCHEDULER_NO_TASK != register_hosts_task)
GNUNET_SCHEDULER_cancel (register_hosts_task);
if (NULL != reg_handle)
GNUNET_TESTBED_cancel_registration (reg_handle);
if (NULL != topology_op)
GNUNET_TESTBED_operation_done (topology_op);
for (nhost = 0; nhost < num_hosts; nhost++)
if (NULL != hosts[nhost])
GNUNET_TESTBED_host_destroy (hosts[nhost]);
GNUNET_free_non_null (hosts);
while (NULL != (dll_op = dll_op_head))
{
GNUNET_TESTBED_operation_done (dll_op->op);
GNUNET_CONTAINER_DLL_remove (dll_op_head, dll_op_tail, dll_op);
GNUNET_free (dll_op);
}
if (NULL != mc)
GNUNET_TESTBED_controller_disconnect (mc);
if (NULL != mc_proc)
GNUNET_TESTBED_controller_stop (mc_proc);
if (NULL != cfg)
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */
}
static void
clean_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_SERVER_destroy (server);
server = NULL;
GNUNET_CONFIGURATION_destroy (cfg);
cfg = NULL;
}
static void
finish_up (void *cls)
{
GNUNET_assert (ok == 5);
ok = 0;
GNUNET_SERVER_destroy (server);
GNUNET_MQ_destroy (mq);
GNUNET_CONFIGURATION_destroy (cfg);
}
static void
finish_up (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_assert (ok == 5);
ok = 0;
GNUNET_SERVER_destroy (server);
GNUNET_CLIENT_disconnect (cc);
GNUNET_CONFIGURATION_destroy (cfg);
}
static int
init ()
{
struct GNUNET_CONFIGURATION_Handle *cfg;
char pwd[PATH_MAX];
char *binary;
cfg = GNUNET_CONFIGURATION_create ();
if (GNUNET_OK != GNUNET_CONFIGURATION_parse (cfg,
"test_arm_api_data.conf"))
return GNUNET_SYSERR;
if (NULL == getcwd (pwd, PATH_MAX))
return GNUNET_SYSERR;
GNUNET_assert (0 < GNUNET_asprintf (&binary,
"%s/%s",
pwd,
BINARY));
GNUNET_CONFIGURATION_set_value_string (cfg,
SERVICE,
"BINARY",
binary);
GNUNET_free (binary);
if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg,
CFGFILENAME))
{
GNUNET_CONFIGURATION_destroy (cfg);
return GNUNET_SYSERR;
}
GNUNET_CONFIGURATION_destroy (cfg);
#if LOG_BACKOFF
killLogFileName = GNUNET_DISK_mktemp ("exponential-backoff-waiting.log");
if (NULL == (killLogFilePtr = FOPEN (killLogFileName,
"w")))
{
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"fopen",
killLogFileName);
GNUNET_free (killLogFileName);
return GNUNET_SYSERR;
}
#endif
return GNUNET_OK;
}
/**
* Task to clean up and shutdown nicely
*
* @param cls NULL
* @param tc the TaskContext from scheduler
*/
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct MessageQueue *mq_entry;
uint32_t id;
shutdown_task_id = NULL;
LOG_DEBUG ("Shutting down testbed service\n");
/* cleanup any remaining forwarded operations */
GST_clear_fopcq ();
GST_free_lcfq ();
GST_free_mctxq ();
GST_free_occq ();
GST_free_roccq ();
GST_free_nccq ();
GST_neighbour_list_clean();
GST_free_prcq ();
/* Clear peer list */
GST_destroy_peers ();
/* Clear route list */
GST_route_list_clear ();
/* Clear GST_slave_list */
GST_slave_list_clear ();
/* Clear host list */
for (id = 0; id < GST_host_list_size; id++)
if (NULL != GST_host_list[id])
GNUNET_TESTBED_host_destroy (GST_host_list[id]);
GNUNET_free_non_null (GST_host_list);
if (NULL != GST_context)
{
GNUNET_free_non_null (GST_context->master_ip);
if (NULL != GST_context->system)
GNUNET_TESTING_system_destroy (GST_context->system, GNUNET_YES);
GNUNET_SERVER_client_drop (GST_context->client);
GNUNET_free (GST_context);
GST_context = NULL;
}
if (NULL != transmit_handle)
GNUNET_SERVER_notify_transmit_ready_cancel (transmit_handle);
while (NULL != (mq_entry = mq_head))
{
GNUNET_free (mq_entry->msg);
GNUNET_SERVER_client_drop (mq_entry->client);
GNUNET_CONTAINER_DLL_remove (mq_head, mq_tail, mq_entry);
GNUNET_free (mq_entry);
}
GNUNET_free_non_null (hostname);
/* Free hello cache */
GST_cache_clear ();
GST_connection_pool_destroy ();
GNUNET_TESTBED_operation_queue_destroy_ (GST_opq_openfds);
GST_opq_openfds = NULL;
GST_stats_destroy ();
GST_barriers_destroy ();
GNUNET_CONFIGURATION_destroy (GST_config);
}
static void
shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Ending test.\n");
#endif
GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
GNUNET_CONFIGURATION_destroy (testing_cfg);
}
static void
stop_arm (struct PeerContext *p)
{
if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
GNUNET_OS_process_get_pid (p->arm_proc));
GNUNET_OS_process_destroy (p->arm_proc);
p->arm_proc = NULL;
GNUNET_CONFIGURATION_destroy (p->cfg);
}
/**
* Setup a key file for a peer given the name of the
* configuration file (!). This function is used so that
* at a later point code can be certain that reading a
* key is fast (for example in time-dependent testcases).
*
* @param cfg_name name of the configuration file to use
*/
void
GNUNET_CRYPTO_eddsa_setup_key (const char *cfg_name)
{
struct GNUNET_CONFIGURATION_Handle *cfg;
struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
cfg = GNUNET_CONFIGURATION_create ();
(void) GNUNET_CONFIGURATION_load (cfg, cfg_name);
priv = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
if (NULL != priv)
GNUNET_free (priv);
GNUNET_CONFIGURATION_destroy (cfg);
}
/**
* Abort autoconfiguration.
*
* @param ah handle for operation to abort
*/
void
GNUNET_NAT_autoconfig_cancel (struct GNUNET_NAT_AutoHandle *ah)
{
if (NULL != ah->tst)
{
GNUNET_NAT_test_stop (ah->tst);
ah->tst = NULL;
}
if (NULL != ah->eh)
{
GNUNET_NAT_mini_get_external_ipv4_cancel (ah->eh);
ah->eh = NULL;
}
if (NULL != ah->task)
{
GNUNET_SCHEDULER_cancel (ah->task);
ah->task = NULL;
}
GNUNET_CONFIGURATION_destroy (ah->cfg);
GNUNET_CONFIGURATION_destroy (ah->initial_cfg);
GNUNET_free (ah);
}
/**
* 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)
{
die_task = GNUNET_SCHEDULER_NO_TASK;
int c;
if (GNUNET_SCHEDULER_NO_TASK != wait_task)
{
GNUNET_SCHEDULER_cancel (wait_task);
wait_task = GNUNET_SCHEDULER_NO_TASK;
}
for (c = 0; c < 3; c++)
{
if (NULL != nh[c])
{
GNUNET_NAMESTORE_disconnect(nh[c]);
nh[c] = NULL;
}
if (NULL != get_cfg_ops[c])
{
GNUNET_TESTBED_operation_done(get_cfg_ops[c]);
get_cfg_ops[c] = NULL;
}
if (NULL != cfg_handles[c])
{
GNUNET_CONFIGURATION_destroy (cfg_handles[c]);
cfg_handles[c] = NULL;
}
}
if (NULL != topology_op)
{
GNUNET_TESTBED_operation_done (topology_op);
topology_op = NULL;
}
if (NULL != lookup_handle)
{
GNUNET_GNS_cancel_lookup_request (lookup_handle);
lookup_handle = NULL;
}
if (NULL != gh)
{
GNUNET_GNS_disconnect(gh);
gh = NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Test failed \n");
GNUNET_SCHEDULER_shutdown ();
ok = 1;
}
static int check_blacklist_config (char *cfg_file,
struct GNUNET_PeerIdentity *peer, struct GNUNET_PeerIdentity *bl_peer)
{
struct GNUNET_CONFIGURATION_Handle *cfg;
char *section;
char *peer_str;
cfg = GNUNET_CONFIGURATION_create ();
if (GNUNET_OK != GNUNET_CONFIGURATION_load (cfg, cfg_file))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Could not load configuration `%s'\n", cfg_file);
GNUNET_CONFIGURATION_destroy (cfg);
return GNUNET_SYSERR;
}
peer_str = GNUNET_strdup (GNUNET_i2s_full(peer));
GNUNET_asprintf (§ion, "transport-blacklist-%s", peer_str);
if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (cfg, section, GNUNET_i2s_full(bl_peer)))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Configuration `%s' does not have blacklisting section for peer `%s' blacklisting `%s'\n",
cfg_file, peer_str, GNUNET_i2s_full(bl_peer));
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_free (section);
GNUNET_free (peer_str);
return GNUNET_SYSERR;
}
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Configuration `%s' does have blacklisting section for peer `%s' blacklisting `%s'\n",
cfg_file, peer_str, GNUNET_i2s_full(bl_peer));
GNUNET_CONFIGURATION_destroy (cfg);
GNUNET_free (section);
GNUNET_free (peer_str);
return GNUNET_OK;
}
/**
* Shutdown nicely
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
if (GNUNET_SCHEDULER_NO_TASK != abort_task)
GNUNET_SCHEDULER_cancel (abort_task);
if (NULL != slave3)
GNUNET_TESTBED_host_destroy (slave3);
if (NULL != slave2)
GNUNET_TESTBED_host_destroy (slave2);
if (NULL != slave)
GNUNET_TESTBED_host_destroy (slave);
if (NULL != host)
GNUNET_TESTBED_host_destroy (host);
if (NULL != mc)
GNUNET_TESTBED_controller_disconnect (mc);
if (NULL != cfg)
GNUNET_CONFIGURATION_destroy (cfg);
if (NULL != cfg3)
GNUNET_CONFIGURATION_destroy (cfg3);
if (NULL != cp)
GNUNET_TESTBED_controller_stop (cp);
if (NULL != rh)
GNUNET_TESTBED_cancel_registration (rh);
}
static void
waitpid_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct PeerContext *p = cls;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Killing ARM process.\n");
if (0 != GNUNET_OS_process_kill (p->arm_proc, GNUNET_TERM_SIG))
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
if (GNUNET_OS_process_wait (p->arm_proc) != GNUNET_OK)
GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "waitpid");
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "ARM process %u stopped\n",
GNUNET_OS_process_get_pid (p->arm_proc));
GNUNET_OS_process_destroy (p->arm_proc);
p->arm_proc = NULL;
GNUNET_CONFIGURATION_destroy (p->cfg);
}
/**
* The shutdown task
*
* @param cls NULL
* @param tc the task context
*/
static void
do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
GNUNET_TESTBED_host_destroy (host);
while (0 != num_hosts)
{
GNUNET_TESTBED_host_destroy (hosts[num_hosts - 1]);
num_hosts--;
}
GNUNET_free (hosts);
if (NULL != cfg)
{
GNUNET_CONFIGURATION_destroy (cfg);
cfg = NULL;
}
}
int
main (int argc, char *argv[])
{
int ok;
GNUNET_log_setup ("test_connection_timeout_no_connect",
"WARNING",
NULL);
ok = 1;
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
"localhost");
GNUNET_SCHEDULER_run (&task_timeout, &ok);
GNUNET_CONFIGURATION_destroy (cfg);
return ok;
}
/**
* Check whether peers successfully shut down.
*/
static void
shutdown_callback (void *cls, const char *emsg)
{
if (emsg != NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"test: Shutdown of peers failed! (%s)\n", emsg);
ok--;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"test: All peers successfully shut down!\n");
}
GNUNET_CONFIGURATION_destroy (testing_cfg);
}
static void
got_initial_value (void *cls, int success)
{
struct GNUNET_CONFIGURATION_Handle *cfg = cls;
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Got initial value\n");
/* Connect to ATS scheduling */
sched_ats = GNUNET_ATS_scheduling_init (cfg, &address_suggest_cb, NULL);
GNUNET_CONFIGURATION_destroy (cfg);
if (sched_ats == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not connect to ATS scheduling!\n");
GNUNET_SCHEDULER_add_now (&end_badly, NULL);
return;
}
}
/**
* Disconnect from the ARM service (if connected) and destroy the context.
*
* @param h the handle that was being used
*/
void
GNUNET_ARM_disconnect_and_free (struct GNUNET_ARM_Handle *h)
{
struct ARMControlMessage *cm;
LOG (GNUNET_ERROR_TYPE_DEBUG, "Disconnecting from ARM service\n");
if (NULL != h->cth)
{
GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
h->cth = NULL;
}
while ((NULL != (cm = h->control_pending_head))
|| (NULL != (cm = h->control_sent_head)) )
{
if (NULL != h->control_pending_head)
GNUNET_CONTAINER_DLL_remove (h->control_pending_head,
h->control_pending_tail, cm);
else
GNUNET_CONTAINER_DLL_remove (h->control_sent_head,
h->control_sent_tail, cm);
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != cm->timeout_task_id);
GNUNET_SCHEDULER_cancel (cm->timeout_task_id);
if (NULL != cm->result_cont)
cm->result_cont (cm->cont_cls, GNUNET_ARM_REQUEST_DISCONNECTED,
NULL, 0);
/* FIXME: What about list callback? */
GNUNET_free_non_null (cm->msg);
GNUNET_free (cm);
}
if (NULL != h->client)
{
GNUNET_CLIENT_disconnect (h->client);
h->client = NULL;
}
if (GNUNET_SCHEDULER_NO_TASK != h->reconnect_task)
{
GNUNET_SCHEDULER_cancel (h->reconnect_task);
h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
}
if (GNUNET_NO == h->service_test_is_active)
{
GNUNET_CONFIGURATION_destroy (h->cfg);
GNUNET_free (h);
}
}
