/**
* Initialize the DHT subsystem.
*
* @param c Configuration.
*/
void
GCD_init (const struct GNUNET_CONFIGURATION_Handle *c)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (c, "CADET",
"DHT_REPLICATION_LEVEL",
&dht_replication_level))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING, "CADET",
"DHT_REPLICATION_LEVEL", "USING DEFAULT");
dht_replication_level = 3;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (c, "CADET", "ID_ANNOUNCE_TIME",
&id_announce_time))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, "CADET",
"ID_ANNOUNCE_TIME", "MISSING");
GNUNET_SCHEDULER_shutdown ();
return;
}
dht_handle = GNUNET_DHT_connect (c, 64);
if (NULL == dht_handle)
{
GNUNET_break (0);
}
announce_delay = GNUNET_TIME_UNIT_SECONDS;
announce_id_task = GNUNET_SCHEDULER_add_now (&announce_id, NULL);
get_requests = GNUNET_CONTAINER_multihashmap32_create (32);
}
/**
* 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 cfg configuration
*/
static void
run (void *cls,
char *const *args,
const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *config)
{
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
char *pids;
cfg = config;
/* load proof of work */
if (NULL == pwfn)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "NSE",
"PROOFFILE",
&pwfn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE", "PROOFFILE");
GNUNET_SCHEDULER_shutdown ();
return;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Proof of Work file: %s\n",
pwfn);
if ( (GNUNET_YES != GNUNET_DISK_file_test (pwfn)) ||
(sizeof (proof) !=
GNUNET_DISK_fn_read (pwfn, &proof, sizeof (proof))))
proof = 0;
/* load private key */
if (NULL == pkfn)
{
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER",
"PRIVATE_KEY",
&pkfn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"PEER", "PRIVATE_KEY");
return;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Private Key file: %s\n", pkfn);
if (NULL == (pk = GNUNET_CRYPTO_eddsa_key_create_from_file (pkfn)))
{
FPRINTF (stderr, _("Loading hostkey from `%s' failed.\n"), pkfn);
GNUNET_free (pkfn);
return;
}
GNUNET_free (pkfn);
GNUNET_CRYPTO_eddsa_key_get_public (pk, &pub);
GNUNET_free (pk);
pids = GNUNET_CRYPTO_eddsa_public_key_to_string (&pub);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Peer ID: %s\n",
pids);
GNUNET_free (pids);
/* get target bit amount */
if (0 == nse_work_required)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg, "NSE", "WORKBITS",
&nse_work_required))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR, "NSE", "WORKBITS",
_("Value is too large.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
} else if (0 == nse_work_required)
{
write_proof ();
GNUNET_SCHEDULER_shutdown ();
return;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Bits: %llu\n",
nse_work_required);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Delay between tries: %s\n",
GNUNET_STRINGS_relative_time_to_string (proof_find_delay, 1));
GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&find_proof, NULL);
}
/**
* Handle network size estimate clients.
*
* @param cls closure
* @param c configuration to use
* @param service the initialized service
*/
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_SERVICE_Handle *service)
{
struct GNUNET_MQ_MessageHandler core_handlers[] = {
GNUNET_MQ_hd_fixed_size (p2p_estimate,
GNUNET_MESSAGE_TYPE_NSE_P2P_FLOOD,
struct GNUNET_NSE_FloodMessage,
NULL),
GNUNET_MQ_handler_end ()
};
char *proof;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg,
"NSE",
"INTERVAL",
&gnunet_nse_interval))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"INTERVAL");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg,
"NSE",
"WORKDELAY",
&proof_find_delay))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"WORKDELAY");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg,
"NSE",
"WORKBITS",
&nse_work_required))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"WORKBITS");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (nse_work_required >= sizeof (struct GNUNET_HashCode) * 8)
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"WORKBITS",
_("Value is too large.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
#if ENABLE_NSE_HISTOGRAM
{
char *histogram_dir;
char *histogram_fn;
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_filename (cfg,
"NSE",
"HISTOGRAM_DIR",
&histogram_dir))
{
GNUNET_assert (0 < GNUNET_asprintf (&histogram_fn,
"%s/timestamps",
histogram_dir));
GNUNET_free (histogram_dir);
histogram = GNUNET_BIO_write_open (histogram_fn);
if (NULL == histogram)
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Unable to open histogram file `%s'\n",
histogram_fn);
GNUNET_free (histogram_fn);
}
logger_test =
GNUNET_CLIENT_service_test ("testbed-logger",
cfg,
GNUNET_TIME_UNIT_SECONDS,
&status_cb,
NULL);
}
#endif
GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
NULL);
pk = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
GNUNET_assert (NULL != pk);
my_private_key = pk;
GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
&my_identity.public_key);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg,
"NSE",
"PROOFFILE",
&proof))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR,
"NSE",
"PROOFFILE");
GNUNET_free (my_private_key);
my_private_key = NULL;
GNUNET_SCHEDULER_shutdown ();
return;
}
if ((GNUNET_YES != GNUNET_DISK_file_test (proof)) ||
(sizeof (my_proof) !=
GNUNET_DISK_fn_read (proof,
&my_proof,
sizeof (my_proof))))
my_proof = 0;
GNUNET_free (proof);
proof_task =
GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&find_proof,
NULL);
peers = GNUNET_CONTAINER_multipeermap_create (128,
GNUNET_YES);
nc = GNUNET_notification_context_create (1);
/* Connect to core service and register core handlers */
core_api = GNUNET_CORE_connect (cfg, /* Main configuration */
NULL, /* Closure passed to functions */
&core_init, /* Call core_init once connected */
&handle_core_connect, /* Handle connects */
&handle_core_disconnect, /* Handle disconnects */
core_handlers); /* Register these handlers */
if (NULL == core_api)
{
GNUNET_SCHEDULER_shutdown ();
return;
}
stats = GNUNET_STATISTICS_create ("nse",
cfg);
}
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char *topology_str;
char *connect_topology_str;
char *blacklist_topology_str;
char *connect_topology_option_str;
char *connect_topology_option_modifier_string;
ok = 1;
dotOutFile = fopen (dotOutFileName, "w");
if (dotOutFile != NULL)
{
FPRINTF (dotOutFile, "%s", "strict graph G {\n");
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Starting daemons based on config file %s\n", cfgfile);
if (GNUNET_YES !=
GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
&test_directory))
{
ok = 404;
return;
}
if ((GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_string (cfg, "testing", "topology",
&topology_str)) &&
(GNUNET_NO == GNUNET_TESTING_topology_get (&topology, topology_str)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Invalid topology `%s' given for section %s option %s\n",
topology_str, "TESTING", "TOPOLOGY");
topology = GNUNET_TESTING_TOPOLOGY_CLIQUE; /* Defaults to NONE, so set better default here */
}
if ((GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_string (cfg, "testing",
"connect_topology",
&connect_topology_str)) &&
(GNUNET_NO ==
GNUNET_TESTING_topology_get (&connection_topology,
connect_topology_str)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Invalid connect topology `%s' given for section %s option %s\n",
connect_topology_str, "TESTING", "CONNECT_TOPOLOGY");
}
GNUNET_free_non_null (connect_topology_str);
if ((GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_string (cfg, "testing",
"connect_topology_option",
&connect_topology_option_str)) &&
(GNUNET_NO ==
GNUNET_TESTING_topology_option_get (&connect_topology_option,
connect_topology_option_str)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Invalid connect topology option `%s' given for section %s option %s\n",
connect_topology_option_str, "TESTING",
"CONNECT_TOPOLOGY_OPTION");
connect_topology_option = GNUNET_TESTING_TOPOLOGY_OPTION_ALL; /* Defaults to NONE, set to ALL */
}
GNUNET_free_non_null (connect_topology_option_str);
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_string (cfg, "testing",
"connect_topology_option_modifier",
&connect_topology_option_modifier_string))
{
if (SSCANF
(connect_topology_option_modifier_string, "%lf",
&connect_topology_option_modifier) != 1)
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
"testing", "connect_topology_option_modifier",
"expected float");
}
GNUNET_free (connect_topology_option_modifier_string);
}
if (GNUNET_YES !=
GNUNET_CONFIGURATION_get_value_string (cfg, "testing",
"blacklist_transports",
&blacklist_transports))
blacklist_transports = NULL;
if ((GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_string (cfg, "testing",
"blacklist_topology",
&blacklist_topology_str)) &&
(GNUNET_NO ==
GNUNET_TESTING_topology_get (&blacklist_topology,
blacklist_topology_str)))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
"Invalid topology `%s' given for section %s option %s\n",
topology_str, "TESTING", "BLACKLIST_TOPOLOGY");
}
GNUNET_free_non_null (topology_str);
GNUNET_free_non_null (blacklist_topology_str);
if (GNUNET_SYSERR ==
GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
&num_peers))
num_peers = DEFAULT_NUM_PEERS;
if (GNUNET_SYSERR ==
GNUNET_CONFIGURATION_get_value_number (cfg, "testing",
"additional_messages",
&num_additional_messages))
num_additional_messages = DEFAULT_ADDITIONAL_MESSAGES;
main_cfg = cfg;
GNUNET_assert (num_peers > 0 && num_peers < (unsigned int) -1);
peers_left = num_peers;
/* Set up a task to end testing if peer start fails */
die_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MINUTES, 5), &end_badly,
"didn't start all daemons in reasonable amount of time!!!");
peer_daemon_hash = GNUNET_CONTAINER_multihashmap_create (peers_left, GNUNET_NO);
pg = GNUNET_TESTING_daemons_start (cfg, peers_left, /* Total number of peers */
peers_left, /* Number of outstanding connections */
peers_left, /* Number of parallel ssh connections, or peers being started at once */
TIMEOUT, &hostkey_callback, NULL,
&peers_started_callback, NULL,
&topology_callback, NULL, NULL);
}
/**
* Setup CADET internals.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_SERVICE_Handle *service)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (c,
"CADET",
"RATCHET_MESSAGES",
&ratchet_messages))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
"CADET",
"RATCHET_MESSAGES",
"needs to be a number");
ratchet_messages = 64;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (c,
"CADET",
"RATCHET_TIME",
&ratchet_time))
{
GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
"CADET",
"RATCHET_TIME",
"need delay value");
ratchet_time = GNUNET_TIME_UNIT_HOURS;
}
my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (c);
if (NULL == my_private_key)
{
GNUNET_break (0);
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_CRYPTO_eddsa_key_get_public (my_private_key,
&my_full_id.public_key);
stats = GNUNET_STATISTICS_create ("cadet",
c);
GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
NULL);
ats_ch = GNUNET_ATS_connectivity_init (c);
/* FIXME: optimize code to allow GNUNET_YES here! */
open_ports = GNUNET_CONTAINER_multihashmap_create (16,
GNUNET_NO);
loose_channels = GNUNET_CONTAINER_multihashmap_create (16,
GNUNET_NO);
peers = GNUNET_CONTAINER_multipeermap_create (16,
GNUNET_YES);
connections = GNUNET_CONTAINER_multishortmap_create (256,
GNUNET_YES);
GCH_init (c);
GCD_init (c);
GCO_init (c);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"CADET starting at peer %s\n",
GNUNET_i2s (&my_full_id));
}
