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 ();
}
/**
* PEERINFO calls this function to let us know about a possible peer
* that we might want to connect to.
*
* @param cls closure (not used)
* @param peer potential peer to connect to
* @param hello HELLO for this peer (or NULL)
* @param err_msg NULL if successful, otherwise contains error message
*/
static void
process_peer (void *cls, const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Message *hello, const char *err_msg)
{
struct Peer *pos;
if (err_msg != NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Error in communication with PEERINFO service: %s\n"),
err_msg);
GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
peerinfo_notify = GNUNET_PEERINFO_notify (cfg, &process_peer, NULL);
return;
}
GNUNET_assert (peer != NULL);
if (0 == memcmp (&my_identity, peer, sizeof (struct GNUNET_PeerIdentity)))
return; /* that's me! */
if (hello == NULL)
{
/* free existing HELLO, if any */
pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
if (NULL != pos)
{
GNUNET_free_non_null (pos->hello);
pos->hello = NULL;
if (pos->filter != NULL)
{
GNUNET_CONTAINER_bloomfilter_free (pos->filter);
pos->filter = NULL;
}
if ((GNUNET_NO == pos->is_connected) && (GNUNET_NO == pos->is_friend) &&
(0 ==
GNUNET_TIME_absolute_get_remaining (pos->
greylisted_until).rel_value))
free_peer (NULL, &pos->pid.hashPubKey, pos);
}
return;
}
consider_for_advertising (hello);
pos = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey);
if (pos == NULL)
pos = make_peer (peer, hello, GNUNET_NO);
GNUNET_assert (NULL != pos);
if (GNUNET_YES == pos->is_connected)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Already connected to peer `%s'\n",
GNUNET_i2s (peer));
return;
}
if (GNUNET_TIME_absolute_get_remaining (pos->greylisted_until).rel_value > 0)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Already tried peer `%s' recently\n",
GNUNET_i2s (peer));
return; /* peer still greylisted */
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Considering connecting to peer `%s'\n",
GNUNET_i2s (peer));
schedule_attempt_connect (pos);
}
/**
* PEERINFO calls this function to let us know about a possible peer
* that we might want to connect to.
*
* @param cls closure (not used)
* @param peer potential peer to connect to
* @param hello HELLO for this peer (or NULL)
* @param err_msg NULL if successful, otherwise contains error message
*/
static void
process_peer (void *cls,
const struct GNUNET_PeerIdentity *peer,
const struct GNUNET_HELLO_Message *hello,
const char *err_msg)
{
struct Peer *pos;
if (NULL != err_msg)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
_("Error in communication with PEERINFO service: %s\n"),
err_msg);
GNUNET_PEERINFO_notify_cancel (peerinfo_notify);
peerinfo_notify = GNUNET_PEERINFO_notify (cfg,
GNUNET_NO,
&process_peer,
NULL);
return;
}
GNUNET_assert (NULL != peer);
if (0 == memcmp (&my_identity,
peer,
sizeof (struct GNUNET_PeerIdentity)))
return; /* that's me! */
if (NULL == hello)
{
/* free existing HELLO, if any */
pos = GNUNET_CONTAINER_multipeermap_get (peers,
peer);
if (NULL != pos)
{
GNUNET_free_non_null (pos->hello);
pos->hello = NULL;
if (NULL != pos->filter)
{
GNUNET_CONTAINER_bloomfilter_free (pos->filter);
pos->filter = NULL;
}
if ( (NULL == pos->mq) &&
(GNUNET_NO == pos->is_friend) )
free_peer (NULL,
&pos->pid,
pos);
}
return;
}
consider_for_advertising (hello);
pos = GNUNET_CONTAINER_multipeermap_get (peers,
peer);
if (NULL == pos)
pos = make_peer (peer,
hello,
GNUNET_NO);
attempt_connect (pos);
}
/**
* Function called after GNUNET_CORE_connect has succeeded
* (or failed for good).
*
* @param cls closure
* @param server handle to the server, NULL if we failed
* @param my_id ID of this peer, NULL if we failed
*/
static void
core_init (void *cls, struct GNUNET_CORE_Handle *server,
const struct GNUNET_PeerIdentity *my_id)
{
if (server == NULL)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Failed to connect to core service, can not manage topology!\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
handle = server;
my_identity = *my_id;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "I am peer `%s'\n", GNUNET_i2s (my_id));
peerinfo_notify = GNUNET_PEERINFO_notify (cfg, &process_peer, NULL);
}
/**
* 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();
}
}
/**
* 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;
}
/**
* Start the validation subsystem.
*/
void
GST_validation_start ()
{
validation_map = GNUNET_CONTAINER_multihashmap_create (VALIDATION_MAP_SIZE);
pnc = GNUNET_PEERINFO_notify (GST_cfg, &process_peerinfo_hello, NULL);
}
