/**
* 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 c configuration
*/
static void
run (void *cls, char *const *args, const char *cfgfile,
const struct GNUNET_CONFIGURATION_Handle *c)
{
struct GNUNET_CRYPTO_RsaPrivateKey *priv;
char *fn;
cfg = c;
if ( (NULL != args[0]) &&
(NULL == put_uri) &&
(args[0] == strcasestr (args[0], "gnunet://hello/")) )
{
put_uri = GNUNET_strdup (args[0]);
args++;
}
if (NULL != args[0])
{
FPRINTF (stderr,
_("Invalid command line argument `%s'\n"),
args[0]);
return;
}
if (NULL == (peerinfo = GNUNET_PEERINFO_connect (cfg)))
{
FPRINTF (stderr, "%s", _("Could not access PEERINFO service. Exiting.\n"));
return;
}
if ( (GNUNET_YES == get_self) || (GNUNET_YES == get_uri) )
{
/* load private key */
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "GNUNETD", "HOSTKEY",
&fn))
{
FPRINTF (stderr, _("Could not find option `%s:%s' in configuration.\n"),
"GNUNETD", "HOSTKEYFILE");
return;
}
if (NULL == (priv = GNUNET_CRYPTO_rsa_key_create_from_file (fn)))
{
FPRINTF (stderr, _("Loading hostkey from `%s' failed.\n"), fn);
GNUNET_free (fn);
return;
}
GNUNET_free (fn);
GNUNET_CRYPTO_rsa_key_get_public (priv, &my_public_key);
GNUNET_CRYPTO_rsa_key_free (priv);
GNUNET_CRYPTO_hash (&my_public_key, sizeof (my_public_key), &my_peer_identity.hashPubKey);
}
tt = GNUNET_SCHEDULER_add_now (&state_machine, NULL);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
NULL);
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
h = GNUNET_PEERINFO_connect (cfg);
GNUNET_assert (NULL != h);
add_peer ();
ic = GNUNET_PEERINFO_iterate (h, GNUNET_NO, &pid,
&process, cls);
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
h = GNUNET_PEERINFO_connect (cfg);
GNUNET_assert (NULL != h);
ic = GNUNET_PEERINFO_iterate (h, GNUNET_YES, NULL,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS, 15), &process, cls);
}
static void
run (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL );
mycfg = cfg;
pnc_w_fo = GNUNET_PEERINFO_notify (mycfg, GNUNET_YES, &process_w_fo, NULL );
pnc_wo_fo = GNUNET_PEERINFO_notify (mycfg, GNUNET_NO, &process_wo_fo, NULL );
h = GNUNET_PEERINFO_connect (cfg);
GNUNET_assert(NULL != h);
add_peer ();
}
/**
* Function to call to start our services
*/
void NetworkManager::start(struct GNUNET_CONFIGURATION_Handle *config)
{
m_config = config;
//Connect to peerinfo
if (NULL == (m_peerInfo = GNUNET_PEERINFO_connect (config)))
{
qWarning("Failed to connect to PeerInfo service");
}
//Initialize transport plugins
m_gnunetTransportPlugins = new GnunetTransportPlugins(config,this);
//Connect to peerinfo notifications
m_peerInfoNotify = GNUNET_PEERINFO_notify (config, NULL, peerinfoProcessorCallback, this);
if (m_peerInfoNotify == NULL) {
qWarning("Failed to connect to PeerInfo Notify service");
}
//Connect to the ats service
m_ats = GNUNET_ATS_performance_init (config, ATSstatusChangeCallback, this);
if (m_ats == NULL) {
qWarning("Failed to connect to ATS service");
}
//Monitor peer for connected transports
m_peerMonitoring = GNUNET_TRANSPORT_monitor_peers (config,
NULL,
GNUNET_NO,
GNUNET_TIME_UNIT_FOREVER_REL,
&transportPeerChangeCallback,
NULL);
//Monitor peer for validated transports
m_peerTransportValidation = GNUNET_TRANSPORT_monitor_validation_entries (config,
NULL,
GNUNET_NO,
GNUNET_TIME_UNIT_FOREVER_REL,
&validationMonitorCallback,
NULL);
//Connect to core to receive all income and outcome messages ( for bandwidth calculation)
m_core = GNUNET_CORE_connect (m_config, this, NULL,
notifyConnectCallback, notifyDisconnectCallback,
incomeMsgCallback, GNUNET_YES, outcomeMsgCallback, GNUNET_YES, NULL);
//Inicialize NSE
struct GNUNET_NSE_Handle *nse;
nse = GNUNET_NSE_connect (config, checkNseMessageCallback, this);
if(m_peerInfoNotify && m_ats && nse)
{
//status->setOkState();
}
}
/**
* 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_RsaPublicKeyBinaryEncoded tmp;
/* setup globals */
GST_cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (c, "GNUNETD", "HOSTKEY",
&keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Transport service is lacking key configuration settings. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GST_my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
GNUNET_free (keyfile);
if (GST_my_private_key == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Transport service could not access hostkey. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GST_stats = GNUNET_STATISTICS_create ("transport", c);
GST_peerinfo = GNUNET_PEERINFO_connect (c);
memset (&GST_my_public_key, '\0', sizeof (GST_my_public_key));
memset (&tmp, '\0', sizeof (tmp));
GNUNET_CRYPTO_rsa_key_get_public (GST_my_private_key, &GST_my_public_key);
GNUNET_CRYPTO_hash (&GST_my_public_key, sizeof (GST_my_public_key),
&GST_my_identity.hashPubKey);
GNUNET_assert (NULL != GST_my_private_key);
GNUNET_assert (0 != memcmp (&GST_my_public_key, &tmp, sizeof (GST_my_public_key)));
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
if (GST_peerinfo == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
/* start subsystems */
GST_hello_start (&process_hello_update, NULL);
GNUNET_assert (NULL != GST_hello_get());
GST_blacklist_start (server);
GST_ats =
GNUNET_ATS_scheduling_init (GST_cfg, &ats_request_address_change, NULL);
GST_plugins_load (&plugin_env_receive_callback,
&plugin_env_address_change_notification,
&plugin_env_session_end,
&plugin_env_address_to_type);
GST_neighbours_start (NULL,
&neighbours_connect_notification,
&neighbours_disconnect_notification,
&neighbours_address_notification);
GST_clients_start (server);
GST_validation_start ();
}
/**
* 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));
}
/**
* Start server offering our hostlist.
*
* @param c configuration to use
* @param st statistics handle to use
* @param co core handle to use
* @param[out] server_ch set to handler for CORE connect events
* @param[out] server_dh set to handler for CORE disconnect events
* @param advertise #GNUNET_YES if we should advertise our hostlist
* @return #GNUNET_OK on success
*/
int
GNUNET_HOSTLIST_server_start (const struct GNUNET_CONFIGURATION_Handle *c,
struct GNUNET_STATISTICS_Handle *st,
struct GNUNET_CORE_Handle *co,
GNUNET_CORE_ConnectEventHandler *server_ch,
GNUNET_CORE_DisconnectEventHandler *server_dh,
int advertise)
{
unsigned long long port;
char *hostname;
char *ipv4;
char *ipv6;
size_t size;
struct in_addr i4;
struct in6_addr i6;
struct sockaddr_in v4;
struct sockaddr_in6 v6;
const struct sockaddr *sa4;
const struct sockaddr *sa6;
advertising = advertise;
if (! advertising)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Advertising not enabled on this hostlist server\n");
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Advertising enabled on this hostlist server\n");
advertisements = GNUNET_CONTAINER_multipeermap_create (8,
GNUNET_NO);
}
cfg = c;
stats = st;
peerinfo = GNUNET_PEERINFO_connect (cfg);
if (NULL == peerinfo)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not access PEERINFO service. Exiting.\n"));
return GNUNET_SYSERR;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg,
"HOSTLIST",
"HTTPPORT",
&port))
return GNUNET_SYSERR;
if ((0 == port) || (port > UINT16_MAX))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Invalid port number %llu. Exiting.\n"),
port);
return GNUNET_SYSERR;
}
if (GNUNET_SYSERR ==
GNUNET_CONFIGURATION_get_value_string (cfg,
"HOSTLIST",
"EXTERNAL_DNS_NAME",
&hostname))
hostname = GNUNET_RESOLVER_local_fqdn_get ();
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Hostlist service starts on %s:%llu\n"),
hostname, port);
if (NULL != hostname)
{
size = strlen (hostname);
if (size + 15 > MAX_URL_LEN)
{
GNUNET_break (0);
}
else
{
GNUNET_asprintf (&hostlist_uri,
"http://%s:%u/", hostname,
(unsigned int) port);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Address to obtain hostlist: `%s'\n"),
hostlist_uri);
}
GNUNET_free (hostname);
}
if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV4"))
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST",
"BINDTOIP", &ipv4))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
}
}
else
ipv4 = NULL;
if (GNUNET_CONFIGURATION_have_value (cfg, "HOSTLIST", "BINDTOIPV6"))
{
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, "HOSTLIST",
"BINDTOIP", &ipv6))
{
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
}
}
else
ipv6 = NULL;
sa4 = NULL;
if (NULL != ipv4)
{
if (1 == inet_pton (AF_INET, ipv4, &i4))
{
memset (&v4, 0, sizeof (v4));
v4.sin_family = AF_INET;
v4.sin_addr = i4;
v4.sin_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
v4.sin_len = sizeof (v4);
#endif
sa4 = (const struct sockaddr *) &v4;
}
else
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"),
ipv4);
GNUNET_free (ipv4);
}
sa6 = NULL;
if (NULL != ipv6)
{
if (1 == inet_pton (AF_INET6, ipv6, &i6))
{
memset (&v6, 0, sizeof (v6));
v6.sin6_family = AF_INET6;
v6.sin6_addr = i6;
v6.sin6_port = htons (port);
#if HAVE_SOCKADDR_IN_SIN_LEN
v6.sin6_len = sizeof (v6);
#endif
sa6 = (const struct sockaddr *) &v6;
}
else
GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
_("`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"),
ipv6);
GNUNET_free (ipv6);
}
daemon_handle_v6 = MHD_start_daemon (MHD_USE_IPv6 | MHD_USE_DEBUG,
(uint16_t) port,
&accept_policy_callback, NULL,
&access_handler_callback, NULL,
MHD_OPTION_CONNECTION_LIMIT,
(unsigned int) 128,
MHD_OPTION_PER_IP_CONNECTION_LIMIT,
(unsigned int) 32,
MHD_OPTION_CONNECTION_TIMEOUT,
(unsigned int) 16,
MHD_OPTION_CONNECTION_MEMORY_LIMIT,
(size_t) (16 * 1024),
MHD_OPTION_SOCK_ADDR,
sa6,
MHD_OPTION_END);
daemon_handle_v4 = MHD_start_daemon (MHD_NO_FLAG | MHD_USE_DEBUG,
(uint16_t) port,
&accept_policy_callback, NULL,
&access_handler_callback, NULL,
MHD_OPTION_CONNECTION_LIMIT,
(unsigned int) 128,
MHD_OPTION_PER_IP_CONNECTION_LIMIT,
(unsigned int) 32,
MHD_OPTION_CONNECTION_TIMEOUT,
(unsigned int) 16,
MHD_OPTION_CONNECTION_MEMORY_LIMIT,
(size_t) (16 * 1024),
MHD_OPTION_SOCK_ADDR,
sa4,
MHD_OPTION_END);
if ( (NULL == daemon_handle_v6) &&
(NULL == daemon_handle_v4) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Could not start hostlist HTTP server on port %u\n"),
(unsigned short) port);
return GNUNET_SYSERR;
}
core = co;
*server_ch = &connect_handler;
*server_dh = &disconnect_handler;
if (NULL != daemon_handle_v4)
hostlist_task_v4 = prepare_daemon (daemon_handle_v4);
if (NULL != daemon_handle_v6)
hostlist_task_v6 = prepare_daemon (daemon_handle_v6);
notify = GNUNET_PEERINFO_notify (cfg,
GNUNET_NO,
&process_notify, NULL);
return GNUNET_OK;
}