/**
* Process regex requests.
*
* @param cls closure
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_announce, NULL, GNUNET_MESSAGE_TYPE_REGEX_ANNOUNCE, 0},
{&handle_search, NULL, GNUNET_MESSAGE_TYPE_REGEX_SEARCH, 0},
{NULL, NULL, 0, 0}
};
my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration (cfg);
if (NULL == my_private_key)
{
GNUNET_SCHEDULER_shutdown ();
return;
}
dht = GNUNET_DHT_connect (cfg, 1024);
if (NULL == dht)
{
GNUNET_free (my_private_key);
my_private_key = NULL;
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_SCHEDULER_add_shutdown (&cleanup_task,
NULL);
nc = GNUNET_SERVER_notification_context_create (server, 1);
stats = GNUNET_STATISTICS_create ("regex", cfg);
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SERVER_disconnect_notify (server,
&handle_client_disconnect,
NULL);
}
static void
task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct sockaddr_in sa;
struct sockaddr *sap[2];
socklen_t slens[2];
sap[0] = (struct sockaddr *) &sa;
slens[0] = sizeof (sa);
sap[1] = NULL;
slens[1] = 0;
memset (&sa, 0, sizeof (sa));
#if HAVE_SOCKADDR_IN_SIN_LEN
sa.sin_len = sizeof (sa);
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
server =
GNUNET_SERVER_create (NULL, NULL, sap, slens,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 250), GNUNET_NO);
GNUNET_assert (server != NULL);
handlers[0].callback_cls = cls;
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SERVER_disconnect_notify (server, ¬ify_disconnect, cls);
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_CONFIGURATION_set_value_number (cfg, "test", "PORT", PORT);
GNUNET_CONFIGURATION_set_value_string (cfg, "test", "HOSTNAME", "localhost");
GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
"localhost");
client = GNUNET_CLIENT_connect ("test", cfg);
GNUNET_assert (client != NULL);
test_mq (client);
}
/**
* Initialize client subsystem.
*
* @param server the initialized server
*/
void
GDS_CLIENTS_init (struct GNUNET_SERVER_Handle *server)
{
static struct GNUNET_SERVER_MessageHandler plugin_handlers[] = {
{&handle_dht_local_put, NULL,
GNUNET_MESSAGE_TYPE_DHT_CLIENT_PUT, 0},
{&handle_dht_local_get, NULL,
GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET, 0},
{&handle_dht_local_get_stop, NULL,
GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_STOP,
sizeof (struct GNUNET_DHT_ClientGetStopMessage)},
{&handle_dht_local_monitor, NULL,
GNUNET_MESSAGE_TYPE_DHT_MONITOR_START,
sizeof (struct GNUNET_DHT_MonitorStartStopMessage)},
{&handle_dht_local_monitor_stop, NULL,
GNUNET_MESSAGE_TYPE_DHT_MONITOR_STOP,
sizeof (struct GNUNET_DHT_MonitorStartStopMessage)},
{&handle_dht_local_get_result_seen, NULL,
GNUNET_MESSAGE_TYPE_DHT_CLIENT_GET_RESULTS_KNOWN, 0},
{NULL, NULL, 0, 0}
};
forward_map = GNUNET_CONTAINER_multihashmap_create (1024, GNUNET_NO);
retry_heap = GNUNET_CONTAINER_heap_create (GNUNET_CONTAINER_HEAP_ORDER_MIN);
GNUNET_SERVER_add_handlers (server, plugin_handlers);
GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
}
static void
runner6 (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
GNUNET_SERVER_add_handlers (server, myhandlers);
GNUNET_CLIENT_service_test ("test_service6", cfg, GNUNET_TIME_UNIT_SECONDS,
&ready6, (void *) cfg);
}
/**
* First task run by the scheduler. Initializes the server and
* a client and asks for a transmission from the client to the
* server.
*
* @param cls NULL
*/
static void
task (void *cls)
{
struct sockaddr_in sa;
struct sockaddr *sap[2];
socklen_t slens[2];
struct GNUNET_MQ_Envelope *env;
struct GNUNET_MessageHeader *msg;
struct GNUNET_MQ_MessageHandler chandlers[] = {
GNUNET_MQ_hd_fixed_size (reply,
MY_TYPE,
struct GNUNET_MessageHeader,
cls),
GNUNET_MQ_handler_end ()
};
sap[0] = (struct sockaddr *) &sa;
slens[0] = sizeof (sa);
sap[1] = NULL;
slens[1] = 0;
memset (&sa, 0, sizeof (sa));
#if HAVE_SOCKADDR_IN_SIN_LEN
sa.sin_len = sizeof (sa);
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
server = GNUNET_SERVER_create (NULL, NULL,
sap, slens,
TIMEOUT, GNUNET_NO);
GNUNET_assert (server != NULL);
GNUNET_SERVER_add_handlers (server, handlers);
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_CONFIGURATION_set_value_number (cfg,
"test-server",
"PORT",
PORT);
GNUNET_CONFIGURATION_set_value_string (cfg,
"test-server",
"HOSTNAME",
"localhost");
GNUNET_CONFIGURATION_set_value_string (cfg,
"resolver",
"HOSTNAME",
"localhost");
mq = GNUNET_CLIENT_connect (cfg,
"test-server",
chandlers,
&mq_error_handler,
NULL);
GNUNET_assert (NULL != mq);
ok = 2;
env = GNUNET_MQ_msg (msg,
MY_TYPE);
GNUNET_MQ_send (mq,
env);
}
/**
* Process resolver requests.
*
* @param cls closure
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_get, NULL, GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST, 0},
{NULL, NULL, 0, 0}
};
GNUNET_SERVER_add_handlers (server, handlers);
}
/**
* Run a service startup sequence within an existing
* initialized system.
*
* @param service_name our service name
* @param cfg configuration to use
* @param options service options
* @return NULL on error, service handle
*/
struct GNUNET_SERVICE_Context *
GNUNET_SERVICE_start (const char *service_name,
const struct GNUNET_CONFIGURATION_Handle *cfg,
enum GNUNET_SERVICE_Options options)
{
int i;
struct GNUNET_SERVICE_Context *sctx;
sctx = GNUNET_new (struct GNUNET_SERVICE_Context);
sctx->ready_confirm_fd = -1; /* no daemonizing */
sctx->ret = GNUNET_OK;
sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
sctx->service_name = service_name;
sctx->cfg = cfg;
sctx->options = options;
/* setup subsystems */
if (GNUNET_OK != setup_service (sctx))
{
GNUNET_SERVICE_stop (sctx);
return NULL;
}
if (NULL != sctx->lsocks)
sctx->server =
GNUNET_SERVER_create_with_sockets (&check_access, sctx, sctx->lsocks,
sctx->timeout, sctx->require_found);
else
sctx->server =
GNUNET_SERVER_create (&check_access, sctx, sctx->addrs, sctx->addrlens,
sctx->timeout, sctx->require_found);
if (NULL == sctx->server)
{
GNUNET_SERVICE_stop (sctx);
return NULL;
}
#ifndef WINDOWS
if (NULL != sctx->addrs)
for (i = 0; NULL != sctx->addrs[i]; i++)
if ((AF_UNIX == sctx->addrs[i]->sa_family)
&& ('\0' != ((const struct sockaddr_un *)sctx->addrs[i])->sun_path[0]))
GNUNET_DISK_fix_permissions (((const struct sockaddr_un *)sctx->addrs[i])->sun_path,
sctx->match_uid,
sctx->match_gid);
#endif
sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
i = 0;
while ((sctx->my_handlers[i].callback != NULL))
sctx->my_handlers[i++].callback_cls = sctx;
GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
return sctx;
}
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_stop, NULL, GNUNET_MESSAGE_TYPE_ARM_STOP,
sizeof (struct GNUNET_MessageHeader)},
{NULL, NULL, 0, 0}
};
/* process client requests */
GNUNET_SERVER_add_handlers (server, handlers);
}
/**
* Process template requests.
*
* @param cls closure
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
/* FIXME: add handlers here! */
{NULL, NULL, 0, 0}
};
/* FIXME: do setup here */
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup_task,
NULL);
}
/**
* Main function that will be run.
*
* @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)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&test, NULL, GNUNET_MESSAGE_TYPE_NAT_TEST,
sizeof (struct GNUNET_NAT_TestMessage)},
{NULL, NULL, 0, 0}
};
unsigned int port;
struct sockaddr_in in4;
struct sockaddr_in6 in6;
socklen_t slen[] = {
sizeof (in4),
sizeof (in6),
0
};
struct sockaddr *sa[] = {
(struct sockaddr *) &in4,
(struct sockaddr *) &in6,
NULL
};
cfg = c;
if ((args[0] == NULL) || (1 != SSCANF (args[0], "%u", &port)) || (0 == port)
|| (65536 <= port))
{
FPRINTF (stderr,
_
("Please pass valid port number as the first argument! (got `%s')\n"),
args[0]);
return;
}
memset (&in4, 0, sizeof (in4));
memset (&in6, 0, sizeof (in6));
in4.sin_family = AF_INET;
in4.sin_port = htons ((uint16_t) port);
in6.sin6_family = AF_INET6;
in6.sin6_port = htons ((uint16_t) port);
#if HAVE_SOCKADDR_IN_SIN_LEN
in4.sin_len = sizeof (in4);
in6.sin6_len = sizeof (in6);
#endif
server =
GNUNET_SERVER_create (NULL, NULL, (struct sockaddr * const *) sa, slen,
GNUNET_TIME_UNIT_SECONDS, GNUNET_YES);
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
}
static void
task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct sockaddr_un un;
const char *unixpath = "/tmp/testsock";
size_t slen = strlen (unixpath);
struct sockaddr *sap[2];
socklen_t slens[2];
memset (&un, 0, sizeof (un));
un.sun_family = AF_UNIX;
memcpy (un.sun_path, unixpath, slen);
un.sun_path[slen] = '\0';
#if HAVE_SOCKADDR_IN_SIN_LEN
un.sun_len = (u_char) sizeof (un);
#endif
#if LINUX
un.sun_path[0] = '\0';
#endif
sap[0] = (struct sockaddr *) &un;
slens[0] = sizeof (un);
sap[1] = NULL;
slens[1] = 0;
server =
GNUNET_SERVER_create (NULL, NULL, sap, slens,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 250), GNUNET_NO);
GNUNET_assert (server != NULL);
handlers[0].callback_cls = cls;
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SERVER_disconnect_notify (server, ¬ify_disconnect, cls);
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_CONFIGURATION_set_value_string (cfg, "test", "UNIXPATH", unixpath);
GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
"localhost");
client = GNUNET_CLIENT_connect ("test", cfg);
GNUNET_assert (client != NULL);
GNUNET_CLIENT_notify_transmit_ready (client, 256,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 250),
GNUNET_NO, ¬ify_ready, NULL);
}
/**
* Start up peerinfo service.
*
* @param cls closure
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_hello, NULL, GNUNET_MESSAGE_TYPE_HELLO, 0},
{&handle_get, NULL, GNUNET_MESSAGE_TYPE_PEERINFO_GET,
sizeof (struct ListPeerMessage)},
{&handle_get_all, NULL, GNUNET_MESSAGE_TYPE_PEERINFO_GET_ALL,
sizeof (struct GNUNET_MessageHeader)},
{&handle_notify, NULL, GNUNET_MESSAGE_TYPE_PEERINFO_NOTIFY,
sizeof (struct GNUNET_MessageHeader)},
{NULL, NULL, 0, 0}
};
char *peerdir;
char *ip;
hostmap = GNUNET_CONTAINER_multihashmap_create (1024);
stats = GNUNET_STATISTICS_create ("peerinfo", cfg);
notify_list = GNUNET_SERVER_notification_context_create (server, 0);
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_filename (cfg, "peerinfo",
"HOSTS",
&networkIdDirectory));
GNUNET_DISK_directory_create (networkIdDirectory);
GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&cron_scan_directory_data_hosts, NULL);
GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
&cron_clean_data_hosts, NULL);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
GNUNET_SERVER_add_handlers (server, handlers);
ip = GNUNET_OS_installation_get_path (GNUNET_OS_IPK_DATADIR);
GNUNET_asprintf (&peerdir,
"%shellos",
ip);
GNUNET_free (ip);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Importing HELLOs from `%s'\n"),
peerdir);
GNUNET_DISK_directory_scan (peerdir,
&hosts_directory_scan_callback, NULL);
GNUNET_free (peerdir);
}
static void
task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct sockaddr_in sa;
struct sockaddr *sap[2];
socklen_t slens[2];
/* test that ill-configured client fails instantly */
GNUNET_assert (NULL == GNUNET_CLIENT_connect ("invalid-service", cfg));
/* test IPC between client and server */
sap[0] = (struct sockaddr *) &sa;
slens[0] = sizeof (sa);
sap[1] = NULL;
slens[1] = 0;
memset (&sa, 0, sizeof (sa));
#if HAVE_SOCKADDR_IN_SIN_LEN
sa.sin_len = sizeof (sa);
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
server =
GNUNET_SERVER_create (NULL, NULL, sap, slens,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 10000), GNUNET_NO);
GNUNET_assert (server != NULL);
handlers[0].callback_cls = cls;
handlers[1].callback_cls = cls;
GNUNET_SERVER_add_handlers (server, handlers);
client = GNUNET_CLIENT_connect (MYNAME, cfg);
GNUNET_assert (client != NULL);
GNUNET_assert (NULL !=
GNUNET_CLIENT_notify_transmit_ready (client,
sizeof (struct
GNUNET_MessageHeader),
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_SECONDS,5),
GNUNET_NO, &make_msg,
NULL));
GNUNET_CLIENT_receive (client, &recv_bounce, cls,
GNUNET_TIME_relative_multiply
(GNUNET_TIME_UNIT_MILLISECONDS, 10000));
}
static void
task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct sockaddr_in sa;
struct sockaddr *sap[2];
socklen_t slens[2];
sap[0] = (struct sockaddr *) &sa;
slens[0] = sizeof (sa);
sap[1] = NULL;
slens[1] = 0;
memset (&sa, 0, sizeof (sa));
#if HAVE_SOCKADDR_IN_SIN_LEN
sa.sin_len = sizeof (sa);
#endif
sa.sin_family = AF_INET;
sa.sin_port = htons (PORT);
server = GNUNET_SERVER_create (NULL, NULL, sap, slens, TIMEOUT, GNUNET_NO);
GNUNET_assert (server != NULL);
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SERVER_disconnect_notify (server, ¬ify_disconnect, NULL);
cfg = GNUNET_CONFIGURATION_create ();
GNUNET_CONFIGURATION_set_value_number (cfg, "test-server", "PORT", PORT);
GNUNET_CONFIGURATION_set_value_string (cfg, "test-server", "HOSTNAME",
"localhost");
GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
"localhost");
cc = GNUNET_CLIENT_connect ("test-server", cfg);
GNUNET_assert (cc != NULL);
GNUNET_assert (NULL !=
GNUNET_CLIENT_notify_transmit_ready (cc,
sizeof (struct
GNUNET_MessageHeader),
TIMEOUT, GNUNET_YES,
&transmit_initial_message,
NULL));
}
/**
* Start handling requests from clients.
*
* @param server server used to accept clients from.
*/
void
GST_clients_start (struct GNUNET_SERVER_Handle *server)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&clients_handle_start, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_START, sizeof (struct StartMessage)},
{&clients_handle_hello, NULL,
GNUNET_MESSAGE_TYPE_HELLO, 0},
{&clients_handle_send, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_SEND, 0},
{&clients_handle_request_connect, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_REQUEST_CONNECT,
sizeof (struct TransportRequestConnectMessage)},
{&clients_handle_address_to_string, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_ADDRESS_TO_STRING, 0},
{&clients_handle_monitor_peers, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_PEER_REQUEST,
sizeof (struct PeerMonitorMessage)},
{&clients_handle_monitor_validation, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_MONITOR_VALIDATION_REQUEST,
sizeof (struct ValidationMonitorMessage)},
{&GST_blacklist_handle_init, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_INIT,
sizeof (struct GNUNET_MessageHeader)},
{&GST_blacklist_handle_reply, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_BLACKLIST_REPLY,
sizeof (struct BlacklistMessage)},
{&GST_manipulation_set_metric, NULL,
GNUNET_MESSAGE_TYPE_TRANSPORT_TRAFFIC_METRIC, 0},
{NULL, NULL, 0, 0}
};
peer_nc = GNUNET_SERVER_notification_context_create (server, 0);
val_nc = GNUNET_SERVER_notification_context_create (server, 0);
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SERVER_disconnect_notify (server, &client_disconnect_notification,
NULL);
}
/**
* Process arm requests.
*
* @param cls closure
* @param serv the initialized server
* @param c configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *serv,
const struct GNUNET_CONFIGURATION_Handle *c)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_start, NULL, GNUNET_MESSAGE_TYPE_ARM_START, 0},
{&handle_stop, NULL, GNUNET_MESSAGE_TYPE_ARM_STOP, 0},
{&handle_shutdown, NULL, GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN,
sizeof (struct GNUNET_MessageHeader)},
{&handle_list, NULL, GNUNET_MESSAGE_TYPE_ARM_LIST,
sizeof (struct GNUNET_MessageHeader)},
{NULL, NULL, 0, 0}
};
char *defaultservices;
const char *pos;
struct ServiceList *sl;
cfg = c;
server = serv;
GNUNET_assert (serv != NULL);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
child_death_task =
GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
GNUNET_DISK_pipe_handle (sigpipe,
GNUNET_DISK_PIPE_END_READ),
&maint_child_death, NULL);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, "ARM", "GLOBAL_PREFIX",
&prefix_command))
prefix_command = GNUNET_strdup ("");
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_string (cfg, "ARM", "GLOBAL_POSTFIX",
&final_option))
final_option = GNUNET_strdup ("");
GNUNET_CONFIGURATION_iterate_sections (cfg, &setup_service, NULL);
/* start default services... */
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (cfg, "ARM", "DEFAULTSERVICES",
&defaultservices))
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_("Starting default services `%s'\n"), defaultservices);
if (0 < strlen (defaultservices))
{
for (pos = strtok (defaultservices, " "); NULL != pos;
pos = strtok (NULL, " "))
{
sl = find_service (pos);
if (NULL == sl)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Default service `%s' not configured correctly!\n"),
pos);
continue;
}
sl->is_default = GNUNET_YES;
start_process (sl);
}
}
GNUNET_free (defaultservices);
}
else
{
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
_
("No default services configured, GNUnet will not really start right now.\n"));
}
/* process client requests */
GNUNET_SERVER_add_handlers (server, handlers);
}
/**
* Process GNS requests.
*
* @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)
{
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Initializing GNS\n");
char* keyfile;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
unsigned long long max_parallel_bg_queries = 0;
unsigned long long default_lookup_timeout_secs = 0;
int ignore_pending = GNUNET_NO;
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_shorten, NULL, GNUNET_MESSAGE_TYPE_GNS_SHORTEN, 0},
{&handle_lookup, NULL, GNUNET_MESSAGE_TYPE_GNS_LOOKUP, 0},
{&handle_get_authority, NULL, GNUNET_MESSAGE_TYPE_GNS_GET_AUTH, 0}
};
GNS_cfg = c;
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (c, "gns",
"ZONEKEY", &keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"No private key for root zone specified!\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
"Using keyfile %s for root zone.\n", keyfile);
zone_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
GNUNET_CRYPTO_rsa_key_get_public (zone_key, &pkey);
GNUNET_CRYPTO_short_hash(&pkey,
sizeof(struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
&zone_hash);
GNUNET_free(keyfile);
/**
* handle to our local namestore
*/
namestore_handle = GNUNET_NAMESTORE_connect(c);
if (NULL == namestore_handle)
{
//FIXME do error handling;
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to the namestore!\n");
GNUNET_SCHEDULER_shutdown ();
return;
}
auto_import_pkey = GNUNET_NO;
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (c, "gns",
"AUTO_IMPORT_PKEY"))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Automatic PKEY import is enabled.\n");
auto_import_pkey = GNUNET_YES;
}
dht_max_update_interval = GNUNET_GNS_DHT_MAX_UPDATE_INTERVAL;
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (c, "gns",
"ZONE_PUT_INTERVAL",
&dht_max_update_interval))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"DHT zone update interval: %d\n",
dht_max_update_interval);
}
max_record_put_interval = 1;
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (c, "gns",
"RECORD_PUT_INTERVAL",
&max_record_put_interval))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Record put interval: %d\n",
max_record_put_interval);
}
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (c, "gns",
"MAX_PARALLEL_BACKGROUND_QUERIES",
&max_parallel_bg_queries))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Number of allowed parallel background queries: %d\n",
max_parallel_bg_queries);
}
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (c, "gns",
"AUTO_IMPORT_CONFIRMATION_REQ"))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Auto import requires user confirmation\n");
ignore_pending = GNUNET_YES;
}
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number(c, "gns",
"DEFAULT_LOOKUP_TIMEOUT",
&default_lookup_timeout_secs))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"Default lookup timeout: %ds\n", default_lookup_timeout_secs);
default_lookup_timeout = GNUNET_TIME_relative_multiply(
GNUNET_TIME_UNIT_SECONDS,
default_lookup_timeout_secs);
}
/**
* handle to the dht
*/
dht_handle = GNUNET_DHT_connect(c,
//max_parallel_bg_queries); //FIXME get ht_len from cfg
1024);
if (NULL == dht_handle)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Could not connect to DHT!\n");
}
if (gns_resolver_init(namestore_handle, dht_handle, zone_hash,
max_parallel_bg_queries,
ignore_pending)
== GNUNET_SYSERR)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Unable to initialize resolver!\n");
GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
return;
}
if (GNUNET_YES ==
GNUNET_CONFIGURATION_get_value_yesno (c, "gns", "HIJACK_DNS"))
{
GNUNET_log(GNUNET_ERROR_TYPE_INFO,
"DNS hijacking enabled... connecting to service.\n");
if (gns_interceptor_init(zone_hash, zone_key, c) == GNUNET_SYSERR)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
"Failed to enable the dns interceptor!\n");
}
}
/**
* Schedule periodic put
* for our records
* We have roughly an hour for all records;
*/
record_put_interval = GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS,
1);
zone_update_taskid = GNUNET_SCHEDULER_add_now (&update_zone_dht_start, NULL);
GNUNET_SERVER_add_handlers (server, handlers);
//FIXME
//GNUNET_SERVER_disconnect_notify (server,
// &client_disconnect_notification,
// NULL);
nc = GNUNET_SERVER_notification_context_create (server, 1);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
}
/**
* Handle network size estimate clients.
*
* @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)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{&handle_start_message, NULL,
GNUNET_MESSAGE_TYPE_IDENTITY_START, sizeof (struct GNUNET_MessageHeader)},
{&handle_get_default_message, NULL,
GNUNET_MESSAGE_TYPE_IDENTITY_GET_DEFAULT, 0},
{&handle_set_default_message, NULL,
GNUNET_MESSAGE_TYPE_IDENTITY_SET_DEFAULT, 0},
{&handle_create_message, NULL,
GNUNET_MESSAGE_TYPE_IDENTITY_CREATE, 0},
{&handle_rename_message, NULL,
GNUNET_MESSAGE_TYPE_IDENTITY_RENAME, 0},
{&handle_delete_message, NULL,
GNUNET_MESSAGE_TYPE_IDENTITY_DELETE, 0},
{NULL, NULL, 0, 0}
};
cfg = c;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "identity",
"EGODIR",
&ego_directory))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "identity", "EGODIR");
GNUNET_SCHEDULER_shutdown ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "identity",
"SUBSYSTEM_CFG",
&subsystem_cfg_file))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "identity", "SUBSYSTEM_CFG");
GNUNET_SCHEDULER_shutdown ();
return;
}
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Loading subsystem configuration `%s'\n",
subsystem_cfg_file);
subsystem_cfg = GNUNET_CONFIGURATION_create ();
if ( (GNUNET_YES ==
GNUNET_DISK_file_test (subsystem_cfg_file)) &&
(GNUNET_OK !=
GNUNET_CONFIGURATION_parse (subsystem_cfg,
subsystem_cfg_file)) )
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to parse subsystem identity configuration file `%s'\n"),
subsystem_cfg_file);
GNUNET_SCHEDULER_shutdown ();
return;
}
stats = GNUNET_STATISTICS_create ("identity", cfg);
GNUNET_SERVER_add_handlers (server, handlers);
nc = GNUNET_SERVER_notification_context_create (server, 1);
if (GNUNET_OK !=
GNUNET_DISK_directory_create (ego_directory))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to create directory `%s' for storing egos\n"),
ego_directory);
}
GNUNET_DISK_directory_scan (ego_directory,
&process_ego_file,
NULL);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
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);
}
/**
* Process sensordashboard requests.
*
* @param cls closure
* @param server the initialized server
* @param cfg configuration to use
*/
static void
run (void *cls, struct GNUNET_SERVER_Handle *server,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
static const struct GNUNET_SERVER_MessageHandler handlers[] = {
{NULL, NULL, 0, 0}
};
static struct GNUNET_CADET_MessageHandler cadet_handlers[] = {
{&handle_sensor_reading,
GNUNET_MESSAGE_TYPE_SENSOR_READING, 0},
{&handle_sensor_list_req,
GNUNET_MESSAGE_TYPE_SENSOR_LIST_REQ,
sizeof (struct GNUNET_MessageHeader)},
{&handle_sensor_full_req,
GNUNET_MESSAGE_TYPE_SENSOR_FULL_REQ,
sizeof (struct GNUNET_MessageHeader)},
{&handle_anomaly_report,
GNUNET_MESSAGE_TYPE_SENSOR_ANOMALY_REPORT,
sizeof (struct GNUNET_MessageHeader) +
sizeof (struct GNUNET_SENSOR_crypto_pow_block) +
sizeof (struct GNUNET_SENSOR_AnomalyReportMessage)},
{NULL, 0, 0}
};
static uint32_t cadet_ports[] = {
GNUNET_APPLICATION_TYPE_SENSORDASHBOARD,
GNUNET_APPLICATION_TYPE_SENSORUPDATE,
GNUNET_APPLICATION_TYPE_END
};
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "SENSOR", "SENSOR_DIR",
&sensor_dir))
sensor_dir = GNUNET_SENSOR_get_default_sensor_dir ();
sensors = GNUNET_SENSOR_load_all_sensors (sensor_dir);
GNUNET_assert (NULL != sensors);
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_number (cfg, "sensor-reporting",
"POW_MATCHING_BITS",
&pow_matching_bits))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "sensor-reporting",
"POW_MATCHING_BITS");
GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
return;
}
if (pow_matching_bits > sizeof (struct GNUNET_HashCode))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Matching bits value too large (%d > %d).\n", pow_matching_bits,
sizeof (struct GNUNET_HashCode));
GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
return;
}
cadet =
GNUNET_CADET_connect (cfg, NULL, &cadet_channel_created,
&cadet_channel_destroyed, cadet_handlers,
cadet_ports);
if (NULL == cadet)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to `%s' service.\n"), "CADET");
GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
return;
}
peerstore = GNUNET_PEERSTORE_connect (cfg);
if (NULL == peerstore)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to connect to `%s' service.\n"), "PEERSTORE");
GNUNET_SCHEDULER_add_now (&cleanup_task, NULL);
return;
}
GNUNET_SERVER_add_handlers (server, handlers);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &cleanup_task,
NULL);
}
/**
* Initial task for the service.
*
* @param cls service context
* @param tc unused
*/
static void
service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
{
struct GNUNET_SERVICE_Context *sctx = cls;
unsigned int i;
if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
return;
(void) GNUNET_SPEEDUP_start_ (sctx->cfg);
GNUNET_RESOLVER_connect (sctx->cfg);
if (NULL != sctx->lsocks)
sctx->server
= GNUNET_SERVER_create_with_sockets (&check_access, sctx, sctx->lsocks,
sctx->timeout, sctx->require_found);
else
sctx->server
= GNUNET_SERVER_create (&check_access, sctx, sctx->addrs, sctx->addrlens,
sctx->timeout, sctx->require_found);
if (NULL == sctx->server)
{
if (NULL != sctx->addrs)
for (i = 0; NULL != sctx->addrs[i]; i++)
LOG (GNUNET_ERROR_TYPE_INFO,
_("Failed to start `%s' at `%s'\n"),
sctx->service_name, GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
sctx->ret = GNUNET_SYSERR;
return;
}
#ifndef WINDOWS
if (NULL != sctx->addrs)
for (i = 0; NULL != sctx->addrs[i]; i++)
if ((AF_UNIX == sctx->addrs[i]->sa_family)
&& ('\0' != ((const struct sockaddr_un *)sctx->addrs[i])->sun_path[0]))
GNUNET_DISK_fix_permissions (((const struct sockaddr_un *)sctx->addrs[i])->sun_path,
sctx->match_uid,
sctx->match_gid);
#endif
if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN))
{
/* install a task that will kill the server
* process if the scheduler ever gets a shutdown signal */
sctx->shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task,
sctx);
}
sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers));
i = 0;
while (NULL != sctx->my_handlers[i].callback)
sctx->my_handlers[i++].callback_cls = sctx;
GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers);
if (-1 != sctx->ready_confirm_fd)
{
GNUNET_break (1 == WRITE (sctx->ready_confirm_fd, ".", 1));
GNUNET_break (0 == CLOSE (sctx->ready_confirm_fd));
sctx->ready_confirm_fd = -1;
write_pid_file (sctx, getpid ());
}
if (NULL != sctx->addrs)
{
i = 0;
while (NULL != sctx->addrs[i])
{
LOG (GNUNET_ERROR_TYPE_INFO, _("Service `%s' runs at %s\n"),
sctx->service_name, GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i]));
i++;
}
}
sctx->task (sctx->task_cls, sctx->server, sctx->cfg);
}
