/**
* Start task that may speed up our system clock artificially
*
* @param cfg configuration to use
* @return #GNUNET_OK on success, #GNUNET_SYSERR if the speedup was not configured
*/
int
GNUNET_SPEEDUP_start_ (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg, "testing",
"SPEEDUP_INTERVAL", &interval))
return GNUNET_SYSERR;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg, "testing",
"SPEEDUP_DELTA", &delta))
return GNUNET_SYSERR;
if ((0 == interval.rel_value_us) || (0 == delta.rel_value_us))
{
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Speed up disabled\n");
return GNUNET_OK;
}
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Speed up execution by %s\n",
GNUNET_STRINGS_relative_time_to_string (delta, GNUNET_NO));
LOG (GNUNET_ERROR_TYPE_DEBUG,
"Speed up executed every %s\n",
GNUNET_STRINGS_relative_time_to_string (interval, GNUNET_NO));
speedup_task = GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
&do_speedup, NULL);
return GNUNET_OK;
}
/**
* 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);
}
/**
* Init the MLP problem solving component
*
* @param cfg the GNUNET_CONFIGURATION_Handle handle
* @param stats the GNUNET_STATISTICS handle
* @param max_duration maximum numbers of iterations for the LP/MLP Solver
* @param max_iterations maximum time limit for the LP/MLP Solver
* @return struct GAS_MLP_Handle * on success, NULL on fail
*/
struct GAS_MLP_Handle *
GAS_mlp_init (const struct GNUNET_CONFIGURATION_Handle *cfg,
const struct GNUNET_STATISTICS_Handle *stats,
struct GNUNET_TIME_Relative max_duration,
unsigned int max_iterations)
{
struct GAS_MLP_Handle * mlp = GNUNET_malloc (sizeof (struct GAS_MLP_Handle));
double D;
double R;
double U;
unsigned long long tmp;
unsigned int b_min;
unsigned int n_min;
struct GNUNET_TIME_Relative i_exec;
int c;
char * quota_out_str;
char * quota_in_str;
/* Init GLPK environment */
int res = glp_init_env();
switch (res) {
case 0:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
"initialization successful");
break;
case 1:
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "GLPK: `%s'\n",
"environment is already initialized");
break;
case 2:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
"initialization failed (insufficient memory)");
GNUNET_free(mlp);
return NULL;
break;
case 3:
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Could not init GLPK: `%s'\n",
"initialization failed (unsupported programming model)");
GNUNET_free(mlp);
return NULL;
break;
default:
break;
}
/* Create initial MLP problem */
mlp->prob = glp_create_prob();
GNUNET_assert (mlp->prob != NULL);
mlp->BIG_M = (double) BIG_M_VALUE;
/* Get diversity coefficient from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_D",
&tmp))
D = (double) tmp / 100;
else
D = 1.0;
/* Get proportionality coefficient from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_R",
&tmp))
R = (double) tmp / 100;
else
R = 1.0;
/* Get utilization coefficient from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_U",
&tmp))
U = (double) tmp / 100;
else
U = 1.0;
/* Get quality metric coefficients from configuration */
int i_delay = -1;
int i_distance = -1;
int q[GNUNET_ATS_QualityPropertiesCount] = GNUNET_ATS_QualityProperties;
for (c = 0; c < GNUNET_ATS_QualityPropertiesCount; c++)
{
/* initialize quality coefficients with default value 1.0 */
mlp->co_Q[c] = 1.0;
mlp->q[c] = q[c];
if (q[c] == GNUNET_ATS_QUALITY_NET_DELAY)
i_delay = c;
if (q[c] == GNUNET_ATS_QUALITY_NET_DISTANCE)
i_distance = c;
}
if ((i_delay != -1) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_QUALITY_DELAY",
&tmp)))
mlp->co_Q[i_delay] = (double) tmp / 100;
else
mlp->co_Q[i_delay] = 1.0;
if ((i_distance != -1) && (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"COEFFICIENT_QUALITY_DISTANCE",
&tmp)))
mlp->co_Q[i_distance] = (double) tmp / 100;
else
mlp->co_Q[i_distance] = 1.0;
/* Get minimum bandwidth per used address from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"MIN_BANDWIDTH",
&tmp))
b_min = tmp;
else
{
b_min = ntohl (GNUNET_CONSTANTS_DEFAULT_BW_IN_OUT.value__);
}
/* Get minimum number of connections from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_size (cfg, "ats",
"MIN_CONNECTIONS",
&tmp))
n_min = tmp;
else
n_min = 4;
/* Init network quotas */
int quotas[GNUNET_ATS_NetworkTypeCount] = GNUNET_ATS_NetworkType;
for (c = 0; c < GNUNET_ATS_NetworkTypeCount; c++)
{
mlp->quota_index[c] = quotas[c];
static char * entry_in = NULL;
static char * entry_out = NULL;
unsigned long long quota_in = 0;
unsigned long long quota_out = 0;
switch (quotas[c]) {
case GNUNET_ATS_NET_UNSPECIFIED:
entry_out = "UNSPECIFIED_QUOTA_OUT";
entry_in = "UNSPECIFIED_QUOTA_IN";
break;
case GNUNET_ATS_NET_LOOPBACK:
entry_out = "LOOPBACK_QUOTA_OUT";
entry_in = "LOOPBACK_QUOTA_IN";
break;
case GNUNET_ATS_NET_LAN:
entry_out = "LAN_QUOTA_OUT";
entry_in = "LAN_QUOTA_IN";
break;
case GNUNET_ATS_NET_WAN:
entry_out = "WAN_QUOTA_OUT";
entry_in = "WAN_QUOTA_IN";
break;
case GNUNET_ATS_NET_WLAN:
entry_out = "WLAN_QUOTA_OUT";
entry_in = "WLAN_QUOTA_IN";
break;
default:
break;
}
if ((entry_in == NULL) || (entry_out == NULL))
continue;
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_out, "a_out_str))
{
if (0 == strcmp(quota_out_str, BIG_M_STRING) ||
(GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_out_str, "a_out)))
quota_out = mlp->BIG_M;
GNUNET_free (quota_out_str);
quota_out_str = NULL;
}
else if (GNUNET_ATS_NET_UNSPECIFIED == quotas[c])
{
quota_out = mlp->BIG_M;
}
else
{
quota_out = mlp->BIG_M;
}
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(cfg, "ats", entry_in, "a_in_str))
{
if (0 == strcmp(quota_in_str, BIG_M_STRING) ||
(GNUNET_SYSERR == GNUNET_STRINGS_fancy_size_to_bytes (quota_in_str, "a_in)))
quota_in = mlp->BIG_M;
GNUNET_free (quota_in_str);
quota_in_str = NULL;
}
else if (GNUNET_ATS_NET_UNSPECIFIED == quotas[c])
{
quota_in = mlp->BIG_M;
}
else
{
quota_in = mlp->BIG_M;
}
/* Check if defined quota could make problem unsolvable */
if (((n_min * b_min) > quota_out) && (GNUNET_ATS_NET_UNSPECIFIED != quotas[c]))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Inconsistent quota configuration value `%s': "
"outbound quota (%u Bps) too small for combination of minimum connections and minimum bandwidth per peer (%u * %u Bps = %u)\n", entry_out, quota_out, n_min, b_min, n_min * b_min);
GAS_mlp_done(mlp);
mlp = NULL;
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Found `%s' quota %llu and `%s' quota %llu\n",
entry_out, quota_out, entry_in, quota_in);
GNUNET_STATISTICS_update ((struct GNUNET_STATISTICS_Handle *) stats, entry_out, quota_out, GNUNET_NO);
GNUNET_STATISTICS_update ((struct GNUNET_STATISTICS_Handle *) stats, entry_in, quota_in, GNUNET_NO);
mlp->quota_out[c] = quota_out;
mlp->quota_in[c] = quota_in;
}
/* Get minimum number of connections from configuration */
if (GNUNET_OK == GNUNET_CONFIGURATION_get_value_time (cfg, "ats",
"ATS_EXEC_INTERVAL",
&i_exec))
mlp->exec_interval = i_exec;
else
mlp->exec_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30);
mlp->stats = (struct GNUNET_STATISTICS_Handle *) stats;
mlp->max_iterations = max_iterations;
mlp->max_exec_duration = max_duration;
mlp->auto_solve = GNUNET_YES;
/* Redirect GLPK output to GNUnet logging */
glp_error_hook((void *) mlp, &mlp_term_hook);
/* Init LP solving parameters */
glp_init_smcp(&mlp->control_param_lp);
mlp->control_param_lp.msg_lev = GLP_MSG_OFF;
#if VERBOSE_GLPK
mlp->control_param_lp.msg_lev = GLP_MSG_ALL;
#endif
mlp->control_param_lp.it_lim = max_iterations;
mlp->control_param_lp.tm_lim = max_duration.rel_value;
/* Init MLP solving parameters */
glp_init_iocp(&mlp->control_param_mlp);
mlp->control_param_mlp.msg_lev = GLP_MSG_OFF;
#if VERBOSE_GLPK
mlp->control_param_mlp.msg_lev = GLP_MSG_ALL;
#endif
mlp->control_param_mlp.tm_lim = max_duration.rel_value;
mlp->last_execution = GNUNET_TIME_UNIT_FOREVER_ABS;
mlp->co_D = D;
mlp->co_R = R;
mlp->co_U = U;
mlp->b_min = b_min;
mlp->n_min = n_min;
mlp->m_q = GNUNET_ATS_QualityPropertiesCount;
mlp->semaphore = GNUNET_NO;
return mlp;
}
/**
* 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);
}
/**
* Initiate transport service.
*
* @param cls closure
* @param server the initialized server
* @param c configuration to use
*/
static void
run (void *cls,
struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *c)
{
char *keyfile;
struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
long long unsigned int max_fd_cfg;
int max_fd_rlimit;
int max_fd;
int friend_only;
/* setup globals */
GST_cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (c,
"PEER",
"PRIVATE_KEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
_("Transport service is lacking key configuration settings. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (c,
"transport",
"HELLO_EXPIRATION",
&hello_expiration))
{
hello_expiration = GNUNET_CONSTANTS_HELLO_ADDRESS_EXPIRATION;
}
GST_server = server;
pk = GNUNET_CRYPTO_eddsa_key_create_from_file (keyfile);
GNUNET_free (keyfile);
GNUNET_assert (NULL != pk);
GST_my_private_key = pk;
GST_stats = GNUNET_STATISTICS_create ("transport", GST_cfg);
GST_peerinfo = GNUNET_PEERINFO_connect (GST_cfg);
GNUNET_CRYPTO_eddsa_key_get_public (GST_my_private_key,
&GST_my_identity.public_key);
GNUNET_assert(NULL != GST_my_private_key);
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"My identity is `%4s'\n",
GNUNET_i2s_full (&GST_my_identity));
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
if (NULL == GST_peerinfo)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
max_fd_rlimit = 0;
max_fd_cfg = 0;
#if HAVE_GETRLIMIT
struct rlimit r_file;
if (0 == getrlimit (RLIMIT_NOFILE, &r_file))
{
max_fd_rlimit = r_file.rlim_cur;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Maximum number of open files was: %u/%u\n",
r_file.rlim_cur,
r_file.rlim_max);
}
max_fd_rlimit = (9 * max_fd_rlimit) / 10; /* Keep 10% for rest of transport */
#endif
GNUNET_CONFIGURATION_get_value_number (GST_cfg,
"transport",
"MAX_FD",
&max_fd_cfg);
if (max_fd_cfg > max_fd_rlimit)
max_fd = max_fd_cfg;
else
max_fd = max_fd_rlimit;
if (max_fd < DEFAULT_MAX_FDS)
max_fd = DEFAULT_MAX_FDS;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Limiting number of sockets to %u: validation %u, neighbors: %u\n",
max_fd, (max_fd / 3), (max_fd / 3) * 2);
friend_only = GNUNET_CONFIGURATION_get_value_yesno (GST_cfg,
"topology",
"FRIENDS-ONLY");
if (GNUNET_SYSERR == friend_only)
friend_only = GNUNET_NO; /* According to topology defaults */
/* start subsystems */
GST_blacklist_start (GST_server,
GST_cfg,
&GST_my_identity);
GST_is = GNUNET_ATS_scanner_init ();
GST_ats_connect = GNUNET_ATS_connectivity_init (GST_cfg);
GST_ats = GNUNET_ATS_scheduling_init (GST_cfg,
&ats_request_address_change,
NULL);
GST_ats_init ();
GST_manipulation_init ();
GST_plugins_load (&GST_manipulation_recv,
&plugin_env_address_change_notification,
&plugin_env_session_start,
&plugin_env_session_end);
GST_hello_start (friend_only,
&process_hello_update,
NULL);
GST_neighbours_start ((max_fd / 3) * 2);
GST_clients_start (GST_server);
GST_validation_start ((max_fd / 3));
}
/**
* 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);
}
/**
* 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));
}
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;
unsigned long long max_outstanding_connections;
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 (GNUNET_ERROR_TYPE_WARNING,
_
("Invalid value `%s' for option `%s' in section `%s': expected float\n"),
connect_topology_option_modifier_string,
"connect_topology_option_modifier", "TESTING");
}
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_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg, "testing", "SETTLE_TIME",
&settle_time))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n",
"testing", "SETTLE_TIME");
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (cfg, "testing", "CONNECT_TIMEOUT",
&connect_timeout))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n",
"testing", "CONNECT_TIMEOUT");
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "connect_attempts",
&connect_attempts))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n",
"testing", "connect_attempts");
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg, "testing",
"max_outstanding_connections",
&max_outstanding_connections))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Must provide option %s:%s!\n",
"testing", "max_outstanding_connections");
return;
}
if (GNUNET_SYSERR ==
GNUNET_CONFIGURATION_get_value_number (cfg, "testing", "num_peers",
&num_peers))
num_peers = DEFAULT_NUM_PEERS;
main_cfg = cfg;
peers_left = num_peers;
modnum = num_peers / 4;
dotnum = (num_peers / 50) + 1;
if (modnum == 0)
modnum = 1;
if (dotnum == 0)
dotnum = 1;
#if PROGRESS_BARS
FPRINTF (stdout, "%s", "Hostkey generation progress: [");
#endif
/* Set up a task to end testing if peer start fails */
die_task =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
SECONDS_PER_PEER_START * num_peers),
&end_badly,
"didn't generate all hostkeys within a reasonable amount of time!!!");
GNUNET_assert (num_peers > 0 && num_peers < (unsigned int) -1);
pg = GNUNET_TESTING_daemons_start (cfg, peers_left,
max_outstanding_connections, peers_left,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,
SECONDS_PER_PEER_START * num_peers),
&hostkey_callback, NULL,
&peers_started_callback, NULL,
&topology_callback, NULL, NULL);
}
/**
* Setup addr, addrlen, idle_timeout
* based on configuration!
*
* Configuration may specify:
* - PORT (where to bind to for TCP)
* - UNIXPATH (where to bind to for UNIX domain sockets)
* - TIMEOUT (after how many ms does an inactive service timeout);
* - DISABLEV6 (disable support for IPv6, otherwise we use dual-stack)
* - BINDTO (hostname or IP address to bind to, otherwise we take everything)
* - ACCEPT_FROM (only allow connections from specified IPv4 subnets)
* - ACCEPT_FROM6 (only allow connections from specified IPv6 subnets)
* - REJECT_FROM (disallow allow connections from specified IPv4 subnets)
* - REJECT_FROM6 (disallow allow connections from specified IPv6 subnets)
*
* @param sctx service context to initialize
* @return #GNUNET_OK if configuration succeeded
*/
static int
setup_service (struct GNUNET_SERVICE_Context *sctx)
{
struct GNUNET_TIME_Relative idleout;
int tolerant;
#ifndef MINGW
const char *nfds;
unsigned int cnt;
int flags;
#endif
if (GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->service_name, "TIMEOUT"))
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_time (sctx->cfg, sctx->service_name,
"TIMEOUT", &idleout))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Specified value for `%s' of service `%s' is invalid\n"),
"TIMEOUT", sctx->service_name);
return GNUNET_SYSERR;
}
sctx->timeout = idleout;
}
else
sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
if (GNUNET_CONFIGURATION_have_value
(sctx->cfg, sctx->service_name, "TOLERANT"))
{
if (GNUNET_SYSERR ==
(tolerant =
GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->service_name,
"TOLERANT")))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_("Specified value for `%s' of service `%s' is invalid\n"),
"TOLERANT", sctx->service_name);
return GNUNET_SYSERR;
}
}
else
tolerant = GNUNET_NO;
#ifndef MINGW
errno = 0;
if ((NULL != (nfds = getenv ("LISTEN_FDS"))) &&
(1 == SSCANF (nfds, "%u", &cnt)) && (cnt > 0) && (cnt < FD_SETSIZE) &&
(cnt + 4 < FD_SETSIZE))
{
sctx->lsocks =
GNUNET_malloc (sizeof (struct GNUNET_NETWORK_Handle *) * (cnt + 1));
while (0 < cnt--)
{
flags = fcntl (3 + cnt, F_GETFD);
if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) ||
(NULL ==
(sctx->lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt))))
{
LOG (GNUNET_ERROR_TYPE_ERROR,
_
("Could not access pre-bound socket %u, will try to bind myself\n"),
(unsigned int) 3 + cnt);
cnt++;
while (sctx->lsocks[cnt] != NULL)
GNUNET_break (0 == GNUNET_NETWORK_socket_close (sctx->lsocks[cnt++]));
GNUNET_free (sctx->lsocks);
sctx->lsocks = NULL;
break;
}
}
unsetenv ("LISTEN_FDS");
}
#else
if (getenv ("GNUNET_OS_READ_LSOCKS") != NULL)
{
receive_sockets_from_parent (sctx);
putenv ("GNUNET_OS_READ_LSOCKS=");
}
#endif
if ((NULL == sctx->lsocks) &&
(GNUNET_SYSERR ==
GNUNET_SERVICE_get_server_addresses (sctx->service_name, sctx->cfg,
&sctx->addrs, &sctx->addrlens)))
return GNUNET_SYSERR;
sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES;
sctx->match_uid =
GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->service_name,
"UNIX_MATCH_UID");
sctx->match_gid =
GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, sctx->service_name,
"UNIX_MATCH_GID");
process_acl4 (&sctx->v4_denied, sctx, "REJECT_FROM");
process_acl4 (&sctx->v4_allowed, sctx, "ACCEPT_FROM");
process_acl6 (&sctx->v6_denied, sctx, "REJECT_FROM6");
process_acl6 (&sctx->v6_allowed, sctx, "ACCEPT_FROM6");
return GNUNET_OK;
}
static void
load_property (void *cls,
const char *section)
{
struct GNUNET_CONFIGURATION_Handle *properties = cls;
struct SysmonProperty *sp;
char *tmp;
if (NULL == strstr (section, "sysmon-"))
return;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loading section `%s'\n", section);
if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (properties, section, "TYPE"))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Missing value %s in section `%s'\n",
"TYPE", section);
return;
}
if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (properties, section,"VALUE"))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Missing value %s in section `%s'\n",
"VALUE", section);
return;
}
if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (properties, section,"DESCRIPTION"))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Missing value %s in section `%s'\n",
"DESCRIPTION", section);
return;
}
if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (properties, section,"CMD"))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Missing value %s in section `%s'\n",
"CMD", section);
return;
}
sp = GNUNET_malloc (sizeof (struct SysmonProperty));
/* description */
GNUNET_CONFIGURATION_get_value_string (properties, section, "DESCRIPTION", &sp->desc);
/* cmd */
GNUNET_CONFIGURATION_get_value_string (properties, section, "CMD", &tmp);
char *args = "";
if (NULL != strchr (tmp, ' '))
{
args = strchr (tmp, ' ');
if (strlen (args) > 1)
{
args[0] = '\0';
args++;
}
}
sp->cmd = GNUNET_strdup (tmp);
sp->cmd_args = GNUNET_strdup (args);
GNUNET_free (tmp);
sp->task = &exec_cmd;
/* type */
GNUNET_CONFIGURATION_get_value_string (properties, section, "TYPE", &tmp);
to_lower_str (tmp);
if (0 == strcasecmp(tmp, "static"))
sp->type = t_static;
else if (0 == strcasecmp(tmp, "continous"))
sp->type = t_continous;
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid value %s for %s in section `%s'\n",
tmp, "TYPE", section);
GNUNET_free (tmp);
GNUNET_free (sp);
return;
}
GNUNET_free (tmp);
/* value */
GNUNET_CONFIGURATION_get_value_string (properties, section, "VALUE", &tmp);
to_lower_str (tmp);
if (0 == strcasecmp(tmp, "numeric"))
sp->value_type = v_numeric;
else if (0 == strcasecmp(tmp, "string"))
sp->value_type = v_string;
else
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Invalid value %s for %s in section `%s'\n",
tmp, "VALUE", section);
GNUNET_free (tmp);
GNUNET_free (sp);
return;
}
GNUNET_free (tmp);
/* interval */
if (GNUNET_NO == GNUNET_CONFIGURATION_have_value (properties, section,"INTERVAL"))
sp->interval = GNUNET_TIME_UNIT_MINUTES;
else
{
if (GNUNET_SYSERR == GNUNET_CONFIGURATION_get_value_time (properties, section, "INTERVAL", &sp->interval))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not parse execution interval for `%s', set to default 60 sec.\n"), section);
sp->interval = GNUNET_TIME_UNIT_MINUTES;
}
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Loaded property `%s': %s, %s, interval %llu\n",
(NULL != sp->desc) ? sp->desc: "<undefined>",
(t_continous == sp->type) ? "continious" : "static",
(v_numeric == sp->value_type) ? "numeric" : "string",
sp->interval.rel_value);
GNUNET_CONTAINER_DLL_insert (sp_head, sp_tail, sp);
}
