/**
* Initialize framework and start test
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_log_setup ("test_stream_local",
#if VERBOSE
"DEBUG",
#else
"WARNING",
#endif
NULL);
/* Duplicate the configuration */
config_peer1 = GNUNET_CONFIGURATION_dup (cfg);
config_peer2 = GNUNET_CONFIGURATION_dup (cfg);
arm_pid =
GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
#if VERBOSE_ARM
"-L", "DEBUG",
#endif
"-c", "test_stream_local.conf", NULL);
abort_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 60), &do_abort,
NULL);
test_task = GNUNET_SCHEDULER_add_now (&test, NULL);
}
/**
* 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)
{
host = GNUNET_TESTBED_host_create (NULL, NULL, 0);
GNUNET_assert (NULL != host);
if (GNUNET_YES != GNUNET_TESTBED_is_host_habitable (host, config))
{
GNUNET_TESTBED_host_destroy (host);
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 = SUCCESS;
return;
}
cfg = GNUNET_CONFIGURATION_dup (config);
cp = GNUNET_TESTBED_controller_start ("127.0.0.1", host, cfg, status_cb,
NULL);
abort_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5), &do_abort,
NULL);
}
/**
* Create a host to run peers and controllers on.
*
* @param id global host ID assigned to the host; 0 is
* reserved to always mean 'localhost'
* @param hostname name of the host, use "NULL" for localhost
* @param username username to use for the login; may be NULL
* @param cfg the configuration to use as a template while starting a controller
* on this host. Operation queue sizes specific to a host are also
* read from this configuration handle
* @param port port number to use for ssh; use 0 to let ssh decide
* @return handle to the host, NULL on error
*/
struct GNUNET_TESTBED_Host *
GNUNET_TESTBED_host_create_with_id (uint32_t id, const char *hostname,
const char *username,
const struct GNUNET_CONFIGURATION_Handle
*cfg,
uint16_t port)
{
struct GNUNET_TESTBED_Host *host;
unsigned int new_size;
if ((id < host_list_size) && (NULL != host_list[id]))
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Host with id: %u already created\n", id);
return NULL;
}
host = GNUNET_new (struct GNUNET_TESTBED_Host);
host->hostname = (NULL != hostname) ? GNUNET_strdup (hostname) : NULL;
host->username = (NULL != username) ? GNUNET_strdup (username) : NULL;
host->id = id;
host->port = (0 == port) ? 22 : port;
host->cfg = GNUNET_CONFIGURATION_dup (cfg);
host->opq_parallel_overlay_connect_operations =
GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_ADAPTIVE,
UINT_MAX);
new_size = host_list_size;
while (id >= new_size)
new_size += HOST_LIST_GROW_STEP;
if (new_size != host_list_size)
GNUNET_array_grow (host_list, host_list_size, new_size);
GNUNET_assert (id < host_list_size);
LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding host with id: %u\n", host->id);
host_list[id] = host;
return host;
}
/**
* 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);
}
/**
* 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);
}
static int
setup_alice (const struct GNUNET_CONFIGURATION_Handle * cfg)
{
char* keyfile;
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_NAMESTORE_RecordData rd;
cfg_handles[2] = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_assert (NULL != cfg);
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return GNUNET_SYSERR;
}
key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
if (NULL == key)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
nh[2] = GNUNET_NAMESTORE_connect (cfg_handles[2]);
if (NULL == nh[2])
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
rd.expiration_time = UINT64_MAX;
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (nh[2], key, "bob", &rd, &cont_ns, nh[2]);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up alice gns\n");
gh = GNUNET_GNS_connect (cfg_handles[2]);
if (NULL == gh)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to gns\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
alice_is_setup = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up alice done\n");
return GNUNET_OK;
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
stats = GNUNET_STATISTICS_create ("ats", cfg);
GNUNET_STATISTICS_watch (stats, "ats", "# addresses", &stat_cb, NULL);
initial_get = GNUNET_STATISTICS_get (stats, "ats", "# addresses", TIMEOUT,
&got_initial_value, &dummy_stat,
GNUNET_CONFIGURATION_dup (cfg));
}
/**
* Start auto-configuration routine. The resolver service should
* be available when this function is called.
*
* @param cfg initial configuration
* @param cb function to call with autoconfiguration result
* @param cb_cls closure for @a cb
* @return handle to cancel operation
*/
struct GNUNET_NAT_AutoHandle *
GNUNET_NAT_autoconfig_start (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_NAT_AutoResultCallback cb,
void *cb_cls)
{
struct GNUNET_NAT_AutoHandle *ah;
ah = GNUNET_new (struct GNUNET_NAT_AutoHandle);
ah->fin_cb = cb;
ah->fin_cb_cls = cb_cls;
ah->ret = GNUNET_NAT_ERROR_SUCCESS;
ah->cfg = GNUNET_CONFIGURATION_dup (cfg);
ah->initial_cfg = GNUNET_CONFIGURATION_dup (cfg);
/* never use loopback addresses if user wanted autoconfiguration */
GNUNET_CONFIGURATION_set_value_string (ah->cfg, "nat",
"USE_LOCALADDR",
"NO");
next_phase (ah);
return ah;
}
/**
* Main function that will be run by the scheduler.
*
* @param cls closure
* @param args remaining command-line arguments
* @param cfgfile name of the configuration file used (for saving, can be NULL!)
* @param config configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
unsigned int nhost;
if (NULL == args[0])
{
fprintf (stderr, _("No hosts-file specified on command line\n"));
return;
}
if (0 == num_peers)
{
result = GNUNET_OK;
return;
}
num_hosts = GNUNET_TESTBED_hosts_load_from_file (args[0], &hosts);
if (0 == num_hosts)
{
fprintf (stderr, _("No hosts loaded. Need at least one host\n"));
return;
}
for (nhost = 0; nhost < num_hosts; nhost++)
{
if (GNUNET_YES != GNUNET_TESTBED_is_host_habitable (hosts[nhost], config))
{
fprintf (stderr, _("Host %s cannot start testbed\n"),
GNUNET_TESTBED_host_get_hostname_ (hosts[nhost]));
break;
}
}
if (num_hosts != nhost)
{
fprintf (stderr, _("Exiting\n"));
shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
return;
}
cfg = GNUNET_CONFIGURATION_dup (config);
mc_proc =
GNUNET_TESTBED_controller_start (GNUNET_TESTBED_host_get_hostname_
(hosts[0]),
hosts[0],
cfg,
status_cb,
NULL);
abort_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 5), &do_abort,
NULL);
}
/**
* Main point of test execution
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct TestingContext *test_ctx;
char *emsg;
struct GNUNET_PeerIdentity id;
struct GNUNET_TESTING_SharedService ss[] = {
{"peerinfo", cfg, 2},
{NULL, NULL, 0}
};
struct GNUNET_TESTING_Peer *peer;
unsigned int cnt;
test_ctx = GNUNET_new (struct TestingContext);
test_ctx->system =
GNUNET_TESTING_system_create ("test-gnunet-testing",
"127.0.0.1", NULL, ss);
emsg = NULL;
if (NULL == test_ctx->system)
goto end;
test_ctx->cfg = GNUNET_CONFIGURATION_dup (cfg);
for (cnt = 0; cnt < NUM_PEERS; cnt++)
{
peer = GNUNET_TESTING_peer_configure (test_ctx->system,
test_ctx->cfg,
0, &id, &emsg);
if (NULL == peer)
{
if (NULL != emsg)
printf ("Test failed upon error: %s", emsg);
goto end;
}
if (GNUNET_OK != GNUNET_TESTING_peer_start (peer))
{
GNUNET_TESTING_peer_destroy (peer);
goto end;
}
test_ctx->peers[cnt] = peer;
}
status = GNUNET_OK;
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
&do_shutdown, test_ctx);
return;
end:
GNUNET_SCHEDULER_add_now (&do_shutdown, test_ctx);
GNUNET_free_non_null (emsg);
}
/**
* run: load configuration options and schedule test to run (start peergroup)
* @param cls closure
* @param args argv
* @param cfgfile configuration file name (can be NULL)
* @param cfg configuration handle
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_TESTING_Host *hosts;
ok = GNUNET_NO;
total_connections = 0;
failed_connections = 0;
testing_cfg = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_log_setup ("test_testing_2dtorus",
#if VERBOSE
"DEBUG",
#else
"WARNING",
#endif
NULL);
#if VERBOSE
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "test: Starting daemons.\n");
GNUNET_CONFIGURATION_set_value_string (testing_cfg, "testing",
"use_progressbars", "YES");
#endif
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (testing_cfg, "testing",
"num_peers", &num_peers))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Option TESTING:NUM_PEERS is required!\n");
return;
}
hosts = GNUNET_TESTING_hosts_load (testing_cfg);
pg = GNUNET_TESTING_peergroup_start (testing_cfg, num_peers, TIMEOUT,
&connect_cb, &peergroup_ready, NULL,
hosts);
GNUNET_assert (pg != NULL);
shutdown_handle =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task, NULL);
}
/**
* Set up a context for communicating with ARM, then
* start connecting to the ARM service using that context.
*
* @param cfg configuration to use (needed to contact ARM;
* the ARM service may internally use a different
* configuration to determine how to start the service).
* @param conn_status will be called when connecting/disconnecting
* @param cls closure for conn_status
* @return context to use for further ARM operations, NULL on error.
*/
struct GNUNET_ARM_Handle *
GNUNET_ARM_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_ARM_ConnectionStatusCallback conn_status, void *cls)
{
struct GNUNET_ARM_Handle *h;
h = GNUNET_new (struct GNUNET_ARM_Handle);
h->cfg = GNUNET_CONFIGURATION_dup (cfg);
h->currently_down = GNUNET_YES;
h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
h->conn_status = conn_status;
h->conn_status_cls = cls;
if (GNUNET_OK != reconnect_arm (h))
{
GNUNET_free (h);
return NULL;
}
return h;
}
/**
* Main point of test execution
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Starting test...\n");
config = GNUNET_CONFIGURATION_dup (cfg);
arm_pid =
GNUNET_OS_start_process (GNUNET_YES, NULL, NULL, "gnunet-service-arm",
"gnunet-service-arm",
#if VERBOSE_ARM
"-L", "DEBUG",
#endif
"-c", "test_lockmanager_api.conf", NULL);
GNUNET_assert (NULL != arm_pid);
GNUNET_SCHEDULER_add_delayed (TIME_REL_SECONDS (3),
&test,
NULL);
}
/**
* Setup a context for monitoring ARM, then
* start connecting to the ARM service for monitoring using that context.
*
* @param cfg configuration to use (needed to contact ARM;
* the ARM service may internally use a different
* configuration to determine how to start the service).
* @param cont callback to invoke on status updates
* @param cont_cls closure
* @return context to use for further ARM monitor operations, NULL on error.
*/
struct GNUNET_ARM_MonitorHandle *
GNUNET_ARM_monitor (const struct GNUNET_CONFIGURATION_Handle *cfg,
GNUNET_ARM_ServiceStatusCallback cont, void *cont_cls)
{
struct GNUNET_ARM_MonitorHandle *h;
h = GNUNET_new (struct GNUNET_ARM_MonitorHandle);
h->cfg = GNUNET_CONFIGURATION_dup (cfg);
h->currently_down = GNUNET_YES;
h->reconnect_task = NULL;
h->init_timeout_task_id = NULL;
h->service_status = cont;
h->cls = cont_cls;
if (GNUNET_OK != reconnect_arm_monitor (h))
{
GNUNET_free (h);
return NULL;
}
return h;
}
/**
* 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)
{
unsigned int cnt;
cfg = GNUNET_CONFIGURATION_dup (config);
host = GNUNET_TESTBED_host_create ("localhost", NULL, cfg, 0);
GNUNET_assert (NULL != host);
GNUNET_assert (0 != GNUNET_TESTBED_host_get_id_ (host));
GNUNET_TESTBED_host_destroy (host);
host = GNUNET_TESTBED_host_create (NULL, NULL, cfg, 0);
GNUNET_assert (NULL != host);
GNUNET_assert (0 == GNUNET_TESTBED_host_get_id_ (host));
GNUNET_assert (host == GNUNET_TESTBED_host_lookup_by_id_ (0));
hosts = NULL;
num_hosts = GNUNET_TESTBED_hosts_load_from_file ("sample_hosts.txt", cfg, &hosts);
GNUNET_assert (7 == num_hosts);
GNUNET_assert (NULL != hosts);
for (cnt = 0; cnt < num_hosts; cnt++)
{
if (cnt < 3)
{
GNUNET_assert (0 == strcmp ("totakura",
GNUNET_TESTBED_host_get_username_
(hosts[cnt])));
GNUNET_assert (NULL != GNUNET_TESTBED_host_get_hostname (hosts[cnt]));
GNUNET_assert (22 == GNUNET_TESTBED_host_get_ssh_port_ (hosts[cnt]));
}
if (3 == cnt)
{
GNUNET_assert (0 == strcmp ("totakura",
GNUNET_TESTBED_host_get_username_
(hosts[cnt])));
GNUNET_assert (NULL != GNUNET_TESTBED_host_get_hostname (hosts[cnt]));
GNUNET_assert (2022 == GNUNET_TESTBED_host_get_ssh_port_ (hosts[cnt]));
}
if (4 == cnt)
{
GNUNET_assert (0 == strcmp ("totakura",
GNUNET_TESTBED_host_get_username_
(hosts[cnt])));
GNUNET_assert (0 == strcmp ("asgard.realm",
GNUNET_TESTBED_host_get_hostname
(hosts[cnt])));
GNUNET_assert (22 == GNUNET_TESTBED_host_get_ssh_port_ (hosts[cnt]));
}
if (5 == cnt)
{
GNUNET_assert (NULL == GNUNET_TESTBED_host_get_username_ (hosts[cnt]));
GNUNET_assert (0 == strcmp ("rivendal",
GNUNET_TESTBED_host_get_hostname
(hosts[cnt])));
GNUNET_assert (22 == GNUNET_TESTBED_host_get_ssh_port_ (hosts[cnt]));
}
if (6 == cnt)
{
GNUNET_assert (NULL == GNUNET_TESTBED_host_get_username_ (hosts[cnt]));
GNUNET_assert (0 == strcmp ("rohan",
GNUNET_TESTBED_host_get_hostname
(hosts[cnt])));
GNUNET_assert (561 == GNUNET_TESTBED_host_get_ssh_port_ (hosts[cnt]));
}
}
status = GNUNET_YES;
shutdown_id =
GNUNET_SCHEDULER_add_delayed (TIME_REL_SECS (0), &do_shutdown, NULL);
}
/**
* Testbed setup
*
* @param cls closure
* @param server the initialized server
* @param cfg configuration to use
*/
static void
testbed_run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler message_handlers[] = {
{&handle_init, NULL, GNUNET_MESSAGE_TYPE_TESTBED_INIT, 0},
{&handle_add_host, NULL, GNUNET_MESSAGE_TYPE_TESTBED_ADD_HOST, 0},
{&GST_handle_link_controllers, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_LINK_CONTROLLERS,
sizeof (struct GNUNET_TESTBED_ControllerLinkRequest)},
{&GST_handle_peer_create, NULL, GNUNET_MESSAGE_TYPE_TESTBED_CREATE_PEER, 0},
{&GST_handle_peer_destroy, NULL, GNUNET_MESSAGE_TYPE_TESTBED_DESTROY_PEER,
sizeof (struct GNUNET_TESTBED_PeerDestroyMessage)},
{&GST_handle_peer_start, NULL, GNUNET_MESSAGE_TYPE_TESTBED_START_PEER,
sizeof (struct GNUNET_TESTBED_PeerStartMessage)},
{&GST_handle_peer_stop, NULL, GNUNET_MESSAGE_TYPE_TESTBED_STOP_PEER,
sizeof (struct GNUNET_TESTBED_PeerStopMessage)},
{&GST_handle_peer_get_config, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_GET_PEER_INFORMATION,
sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage)},
{&GST_handle_overlay_connect, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_OVERLAY_CONNECT,
sizeof (struct GNUNET_TESTBED_OverlayConnectMessage)},
{&GST_handle_remote_overlay_connect, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_REMOTE_OVERLAY_CONNECT, 0},
{&GST_handle_manage_peer_service, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_MANAGE_PEER_SERVICE, 0},
{&handle_slave_get_config, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_GET_SLAVE_CONFIGURATION,
sizeof (struct GNUNET_TESTBED_SlaveGetConfigurationMessage)},
{&GST_handle_shutdown_peers, NULL, GNUNET_MESSAGE_TYPE_TESTBED_SHUTDOWN_PEERS,
sizeof (struct GNUNET_TESTBED_ShutdownPeersMessage)},
{&GST_handle_peer_reconfigure, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_RECONFIGURE_PEER, 0},
{&GST_handle_barrier_init, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_INIT, 0},
{&GST_handle_barrier_cancel, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_CANCEL, 0},
{&GST_handle_barrier_status, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_BARRIER_STATUS, 0},
{NULL, NULL, 0, 0}
};
char *logfile;
unsigned long long num;
LOG_DEBUG ("Starting testbed\n");
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_filename (cfg, "TESTBED", "LOG_FILE",
&logfile))
{
GNUNET_break (GNUNET_OK == GNUNET_log_setup ("testbed", "DEBUG", logfile));
GNUNET_free (logfile);
}
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (cfg, "TESTBED",
"CACHE_SIZE", &num));
GST_cache_init ((unsigned int) num);
GST_connection_pool_init ((unsigned int) num);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (cfg, "TESTBED",
"MAX_OPEN_FDS", &num));
GST_opq_openfds = GNUNET_TESTBED_operation_queue_create_
(OPERATION_QUEUE_TYPE_FIXED, (unsigned int) num);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_time (cfg, "TESTBED",
"OPERATION_TIMEOUT",
(struct
GNUNET_TIME_Relative *)
&GST_timeout));
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (cfg, "testbed",
"HOSTNAME", &hostname));
GST_config = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_SERVER_add_handlers (server, message_handlers);
GNUNET_SERVER_disconnect_notify (server, &client_disconnect_cb, NULL);
shutdown_task_id =
GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_SCHEDULER_PRIORITY_IDLE,
&shutdown_task, NULL);
LOG_DEBUG ("Testbed startup complete\n");
GST_stats_init (GST_config);
GST_barriers_init (GST_config);
}
/**
* Function called with the result from the autoconfiguration.
*
* @param cls closure
* @param diff minimal suggested changes to the original configuration
* to make it work (as best as we can)
* @param result #GNUNET_NAT_ERROR_SUCCESS on success, otherwise the specific error code
* @param type what the situation of the NAT
*/
static void
auto_config_cb (void *cls,
const struct GNUNET_CONFIGURATION_Handle *diff,
enum GNUNET_NAT_StatusCode result,
enum GNUNET_NAT_Type type)
{
const char *nat_type;
char unknown_type[64];
struct GNUNET_CONFIGURATION_Handle *new_cfg;
ah = NULL;
switch (type)
{
case GNUNET_NAT_TYPE_NO_NAT:
nat_type = "NO NAT";
break;
case GNUNET_NAT_TYPE_UNREACHABLE_NAT:
nat_type = "NAT but we can traverse";
break;
case GNUNET_NAT_TYPE_STUN_PUNCHED_NAT:
nat_type = "NAT but STUN is able to identify the correct information";
break;
case GNUNET_NAT_TYPE_UPNP_NAT:
nat_type = "NAT but UPNP opened the ports";
break;
default:
SPRINTF (unknown_type,
"NAT unknown, type %u",
type);
nat_type = unknown_type;
break;
}
GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
"NAT status: %s/%s\n",
GNUNET_NAT_AUTO_status2string (result),
nat_type);
/* Shortcut: if there are no changes suggested, bail out early. */
if (GNUNET_NO ==
GNUNET_CONFIGURATION_is_dirty (diff))
{
test_finished ();
return;
}
/* Apply diff to original configuration and show changes
to the user */
new_cfg = write_cfg ? GNUNET_CONFIGURATION_dup (cfg) : NULL;
if (NULL != diff)
{
GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
_("Suggested configuration changes:\n"));
GNUNET_CONFIGURATION_iterate_section_values (diff,
"nat",
&auto_conf_iter,
new_cfg);
}
/* If desired, write configuration to file; we write only the
changes to the defaults to keep things compact. */
if ( (write_cfg) &&
(NULL != diff) )
{
struct GNUNET_CONFIGURATION_Handle *def_cfg;
GNUNET_CONFIGURATION_set_value_string (new_cfg,
"ARM",
"CONFIG",
NULL);
def_cfg = GNUNET_CONFIGURATION_create ();
GNUNET_break (GNUNET_OK ==
GNUNET_CONFIGURATION_load (def_cfg,
NULL));
if (GNUNET_OK !=
GNUNET_CONFIGURATION_write_diffs (def_cfg,
new_cfg,
cfg_file))
{
GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
_("Failed to write configuration to `%s'\n"),
cfg_file);
global_ret = 1;
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_MESSAGE,
_("Wrote updated configuration to `%s'\n"),
cfg_file);
}
GNUNET_CONFIGURATION_destroy (def_cfg);
}
if (NULL != new_cfg)
GNUNET_CONFIGURATION_destroy (new_cfg);
test_finished ();
}
static int
setup_dave (const struct GNUNET_CONFIGURATION_Handle * cfg)
{
char* keyfile;
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
struct in_addr *web;
struct GNUNET_NAMESTORE_RecordData rd;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up dave\n");
cfg_handles[0] = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_assert (NULL != cfg_handles[0]);
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return GNUNET_SYSERR;
}
key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
if (NULL == key)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
nh[0] = GNUNET_NAMESTORE_connect (cfg_handles[0]);
if (NULL == nh[0])
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
GNUNET_CRYPTO_rsa_key_get_public (key, &pkey);
GNUNET_CRYPTO_short_hash(&pkey, sizeof(pkey), &dave_hash);
rd.expiration_time = UINT64_MAX;
web = GNUNET_malloc(sizeof(struct in_addr));
GNUNET_assert(1 == inet_pton (AF_INET, TEST_IP, web));
rd.data_size = sizeof(struct in_addr);
rd.data = web;
rd.record_type = GNUNET_GNS_RECORD_A;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (nh[0], key, "www", &rd, NULL, NULL);
rd.data_size = strlen(TEST_DAVE_PSEU);
rd.data = TEST_DAVE_PSEU;
rd.record_type = GNUNET_GNS_RECORD_PSEU;
GNUNET_NAMESTORE_record_create (nh[0], key, GNUNET_GNS_MASTERZONE_STR, &rd, &cont_ns, nh[0]);
GNUNET_CRYPTO_rsa_key_free(key);
GNUNET_free(keyfile);
GNUNET_free(web);
dave_is_setup = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up dave done\n");
return GNUNET_OK;
}
/**
* Signature of the event handler function called by the
* respective event controller.
*
* @param cls closure
* @param event information about the event
*/
static void
controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
{
switch (result)
{
case SLAVE2_REGISTERED:
check_operation_success (event);
GNUNET_TESTBED_operation_done (op);
op = NULL;
result = SLAVE1_LINK_SUCCESS;
GNUNET_assert (NULL != slave2);
GNUNET_assert (NULL != slave);
op = GNUNET_TESTBED_peer_create (mc, slave, cfg, peer_create_cb, NULL);
GNUNET_assert (NULL != op);
break;
case SLAVE1_PEER_START_SUCCESS:
check_operation_success (event);
GNUNET_TESTBED_operation_done (op);
result = SLAVE2_LINK_SUCCESS;
op = GNUNET_TESTBED_peer_create (mc, slave2, cfg, peer_create_cb, NULL);
GNUNET_assert (NULL != op);
break;
case MASTER_PEER_CREATE_SUCCESS:
GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type);
GNUNET_assert (event->details.peer_start.host == host);
GNUNET_assert (event->details.peer_start.peer == master_peer);
GNUNET_TESTBED_operation_done (op);
result = MASTER_PEER_START_SUCCESS;
slave = GNUNET_TESTBED_host_create_with_id (1, "127.0.0.1", NULL, 0);
GNUNET_assert (NULL != slave);
rh = GNUNET_TESTBED_register_host (mc, slave, ®istration_cont, NULL);
GNUNET_assert (NULL != rh);
break;
case SLAVE1_PEER_CREATE_SUCCESS:
GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type);
GNUNET_assert (event->details.peer_start.host == slave);
GNUNET_assert (event->details.peer_start.peer == slave1_peer);
GNUNET_TESTBED_operation_done (op);
result = SLAVE1_PEER_START_SUCCESS;
op = GNUNET_TESTBED_controller_link (NULL, mc, slave2, slave, cfg,
GNUNET_YES);
break;
case SLAVE2_PEER_CREATE_SUCCESS:
GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type);
GNUNET_assert (event->details.peer_stop.peer == slave1_peer);
GNUNET_TESTBED_operation_done (op);
result = SLAVE1_PEER_STOP_SUCCESS;
op = GNUNET_TESTBED_peer_start (NULL, slave2_peer, NULL, NULL);
GNUNET_assert (NULL != op);
break;
case SLAVE1_PEER_STOP_SUCCESS:
GNUNET_assert (GNUNET_TESTBED_ET_PEER_START == event->type);
GNUNET_assert (event->details.peer_start.host == slave2);
GNUNET_assert (event->details.peer_start.peer == slave2_peer);
GNUNET_TESTBED_operation_done (op);
result = SLAVE2_PEER_START_SUCCESS;
op = GNUNET_TESTBED_overlay_connect (mc, NULL, NULL, master_peer,
slave2_peer);
break;
case SLAVE2_PEER_START_SUCCESS:
GNUNET_assert (NULL != event);
GNUNET_assert (GNUNET_TESTBED_ET_CONNECT == event->type);
GNUNET_assert (event->details.peer_connect.peer1 == master_peer);
GNUNET_assert (event->details.peer_connect.peer2 == slave2_peer);
result = MASTER_SLAVE2_PEERS_CONNECTED;
GNUNET_TESTBED_operation_done (op);
op = NULL;
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 1), &delay_task,
NULL);
break;
case MASTER_SLAVE2_PEERS_CONNECTED:
GNUNET_assert (GNUNET_TESTBED_ET_PEER_STOP == event->type);
GNUNET_assert (event->details.peer_stop.peer == slave2_peer);
GNUNET_TESTBED_operation_done (op);
result = SLAVE2_PEER_STOP_SUCCESS;
op = GNUNET_TESTBED_peer_destroy (slave1_peer);
GNUNET_assert (NULL != op);
break;
case SLAVE2_PEER_STOP_SUCCESS:
check_operation_success (event);
GNUNET_TESTBED_operation_done (op);
result = SLAVE1_PEER_DESTROY_SUCCESS;
op = GNUNET_TESTBED_peer_destroy (slave2_peer);
GNUNET_assert (NULL != op);
break;
case SLAVE1_PEER_DESTROY_SUCCESS:
check_operation_success (event);
GNUNET_TESTBED_operation_done (op);
op = NULL;
result = SLAVE2_PEER_DESTROY_SUCCESS;
slave3 = GNUNET_TESTBED_host_create_with_id (3, "127.0.0.1", NULL, 0);
rh = GNUNET_TESTBED_register_host (mc, slave3, ®istration_cont, NULL);
break;
case SLAVE3_REGISTERED:
check_operation_success (event);
GNUNET_TESTBED_operation_done (op);
op = NULL;
result = SLAVE3_STARTED;
op = GNUNET_TESTBED_get_slave_config (NULL, mc, slave3);
GNUNET_assert (NULL != op);
break;
case SLAVE3_STARTED:
GNUNET_assert (NULL != event);
GNUNET_assert (GNUNET_TESTBED_ET_OPERATION_FINISHED == event->type);
GNUNET_assert (event->details.operation_finished.operation == op);
GNUNET_assert (NULL == event->details.operation_finished.op_cls);
GNUNET_assert (NULL == event->details.operation_finished.emsg);
cfg3 = GNUNET_CONFIGURATION_dup (event->details.operation_finished.generic);
GNUNET_TESTBED_operation_done (op);
result = SLAVE3_GET_CONFIG_SUCCESS;
op = GNUNET_TESTBED_controller_link (NULL, mc, slave3, slave, cfg3, GNUNET_NO);
break;
case SLAVE3_GET_CONFIG_SUCCESS:
result = SLAVE3_LINK_SUCCESS;
GNUNET_TESTBED_operation_done (op);
op = GNUNET_TESTBED_peer_destroy (master_peer);
break;
case SLAVE3_LINK_SUCCESS:
check_operation_success (event);
result = SUCCESS;
GNUNET_TESTBED_operation_done (op);
op = NULL;
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 3),
&do_shutdown, NULL);
break;
default:
GNUNET_assert (0);
}
}