/**
* Handle network size estimate clients.
*
* @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)
{
cfg = c;
nc = GNUNET_notification_context_create (1);
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);
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_shutdown (&shutdown_task,
NULL);
}
/**
* Test whether the configuration has proper values for connection
* (UNIXPATH || (PORT && HOSTNAME)).
*
* @param service_name name of service to connect to
* @param cfg configuration to use
* @return #GNUNET_OK if the configuration is valid, #GNUNET_SYSERR if not
*/
static int
test_service_configuration (const char *service_name,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
int ret = GNUNET_SYSERR;
char *hostname = NULL;
unsigned long long port;
#if AF_UNIX
char *unixpath = NULL;
if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH", &unixpath)) &&
(0 < strlen (unixpath)))
ret = GNUNET_OK;
GNUNET_free_non_null (unixpath);
#endif
if ( (GNUNET_YES ==
GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) &&
(GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_number (cfg, service_name, "PORT", &port)) &&
(port <= 65535) && (0 != port) &&
(GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_string (cfg, service_name, "HOSTNAME",
&hostname)) &&
(0 != strlen (hostname)) )
ret = GNUNET_OK;
GNUNET_free_non_null (hostname);
return ret;
}
/**
* Initiate core 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;
GSC_cfg = c;
GSC_server = server;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (GSC_cfg, "GNUNETD", "HOSTKEY",
&keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_
("Core service is lacking HOSTKEY configuration setting. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
return;
}
GSC_stats = GNUNET_STATISTICS_create ("core", GSC_cfg);
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &shutdown_task,
NULL);
GNUNET_SERVER_suspend (server);
GSC_TYPEMAP_init ();
GST_keygen = GNUNET_CRYPTO_rsa_key_create_start (keyfile, &key_generation_cb, NULL);
GNUNET_free (keyfile);
if (NULL == GST_keygen)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Transport service is unable to access hostkey. Exiting.\n"));
GNUNET_SCHEDULER_shutdown ();
}
}
static int
setup_alice (const struct GNUNET_CONFIGURATION_Handle * cfg)
{
char* keyfile;
struct GNUNET_CRYPTO_RsaPrivateKey *key;
struct GNUNET_NAMESTORE_RecordData rd;
cfg_handles[2] = GNUNET_CONFIGURATION_dup (cfg);
GNUNET_assert (NULL != cfg);
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return GNUNET_SYSERR;
}
key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
if (NULL == key)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
nh[2] = GNUNET_NAMESTORE_connect (cfg_handles[2]);
if (NULL == nh[2])
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
rd.expiration_time = UINT64_MAX;
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (nh[2], key, "bob", &rd, &cont_ns, nh[2]);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up alice gns\n");
gh = GNUNET_GNS_connect (cfg_handles[2]);
if (NULL == gh)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to gns\n");
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
return GNUNET_SYSERR;
}
GNUNET_CRYPTO_rsa_key_free (key);
GNUNET_free (keyfile);
alice_is_setup = GNUNET_YES;
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Setting up alice done\n");
return GNUNET_OK;
}
/**
* Obtain the location of ".my.cnf".
*
* @param cfg our configuration
* @param section the section
* @return NULL on error
*/
static char *
get_my_cnf_path (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *section)
{
char *cnffile;
char *home_dir;
struct stat st;
#ifndef WINDOWS
struct passwd *pw;
#endif
int configured;
#ifndef WINDOWS
pw = getpwuid (getuid ());
if (!pw)
{
GNUNET_log_from_strerror (GNUNET_ERROR_TYPE_ERROR, "mysql", "getpwuid");
return NULL;
}
if (GNUNET_YES == GNUNET_CONFIGURATION_have_value (cfg, section, "CONFIG"))
{
GNUNET_assert (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_filename (cfg, section,
"CONFIG",
&cnffile));
configured = GNUNET_YES;
}
else
{
home_dir = GNUNET_strdup (pw->pw_dir);
GNUNET_asprintf (&cnffile, "%s/.my.cnf", home_dir);
GNUNET_free (home_dir);
configured = GNUNET_NO;
}
#else
home_dir = (char *) GNUNET_malloc (_MAX_PATH + 1);
plibc_conv_to_win_path ("~/", home_dir);
GNUNET_asprintf (&cnffile, "%s/.my.cnf", home_dir);
GNUNET_free (home_dir);
configured = GNUNET_NO;
#endif
GNUNET_log_from (GNUNET_ERROR_TYPE_INFO, "mysql",
_("Trying to use file `%s' for MySQL configuration.\n"),
cnffile);
if ((0 != STAT (cnffile, &st)) || (0 != ACCESS (cnffile, R_OK)) ||
(!S_ISREG (st.st_mode)))
{
if (configured == GNUNET_YES)
GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "mysql",
_("Could not access file `%s': %s\n"), cnffile,
STRERROR (errno));
GNUNET_free (cnffile);
return NULL;
}
return cnffile;
}
/**
* 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);
}
/**
* Get the name of the file where we will
* write the PID of the service.
*
* @param sctx service context
* @return name of the file for the process ID
*/
static char *
get_pid_file_name (struct GNUNET_SERVICE_Context *sctx)
{
char *pif;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, sctx->service_name,
"PIDFILE", &pif))
return NULL;
return pif;
}
/**
* Get the name of the user that'll be used
* to provide the service.
*
* @param sctx service context
* @return value of the 'USERNAME' option
*/
static char *
get_user_name (struct GNUNET_SERVICE_Context *sctx)
{
char *un;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, sctx->service_name,
"USERNAME", &un))
return NULL;
return un;
}
static void
do_check (void *cls,
const struct GNUNET_CONFIGURATION_Handle *ccfg,
struct GNUNET_TESTING_Peer *peer)
{
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
struct GNUNET_NAMESTORE_RecordData rd;
char* alice_keyfile;
char* ip = TEST_IP;
struct in_addr web;
cfg = ccfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* put records into namestore */
namestore_handle = GNUNET_NAMESTORE_connect(cfg);
if (NULL == namestore_handle)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to connect to namestore\n");
end_badly_now ();
return;
}
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&alice_keyfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to get key from cfg\n");
end_badly_now ();
return;
}
alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
GNUNET_free (alice_keyfile);
rd.expiration_time = UINT64_MAX;
GNUNET_assert (1 == inet_pton (AF_INET, ip, &web));
rd.data_size = sizeof(struct in_addr);
rd.data = &web;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
nsqe = GNUNET_NAMESTORE_record_create (namestore_handle,
alice_key,
TEST_RECORD_NAME,
&rd,
&commence_testing,
NULL);
GNUNET_CRYPTO_rsa_key_free (alice_key);
}
/**
* Create a new private key by reading our peer's key from
* the file specified in the configuration.
*
* @param cfg the configuration to use
* @return new private key, NULL on error (for example,
* permission denied)
*/
struct GNUNET_CRYPTO_EddsaPrivateKey *
GNUNET_CRYPTO_eddsa_key_create_from_configuration (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
struct GNUNET_CRYPTO_EddsaPrivateKey *priv;
char *fn;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "PEER", "PRIVATE_KEY", &fn))
return NULL;
priv = GNUNET_CRYPTO_eddsa_key_create_from_file (fn);
GNUNET_free (fn);
return priv;
}
/**
* Checks whether a host can be used to start testbed service
*
* @param host the host to check
* @param config the configuration handle to lookup the path of the testbed
* helper
* @param cb the callback to call to inform about habitability of the given host
* @param cb_cls the closure for the callback
* @return NULL upon any error or a handle which can be passed to
* GNUNET_TESTBED_is_host_habitable_cancel()
*/
struct GNUNET_TESTBED_HostHabitableCheckHandle *
GNUNET_TESTBED_is_host_habitable (const struct GNUNET_TESTBED_Host *host,
const struct GNUNET_CONFIGURATION_Handle
*config,
GNUNET_TESTBED_HostHabitableCallback cb,
void *cb_cls)
{
struct GNUNET_TESTBED_HostHabitableCheckHandle *h;
char **rsh_args;
char **rsh_suffix_args;
char *stat_args[3];
const char *hostname;
char *port;
h = GNUNET_new (struct GNUNET_TESTBED_HostHabitableCheckHandle);
h->cb = cb;
h->cb_cls = cb_cls;
h->host = host;
hostname = (NULL == host->hostname) ? "127.0.0.1" : host->hostname;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (config, "testbed",
"HELPER_BINARY_PATH",
&stat_args[1]))
stat_args[1] =
GNUNET_OS_get_libexec_binary_path (HELPER_TESTBED_BINARY);
GNUNET_asprintf (&port, "%u", host->port);
rsh_args = gen_rsh_args (port, hostname, host->username);
GNUNET_free (port);
port = NULL;
stat_args[0] = "stat";
stat_args[2] = NULL;
rsh_suffix_args = gen_rsh_suffix_args ((const char **) stat_args);
GNUNET_free (stat_args[1]);
h->helper_argv = join_argv ((const char **) rsh_args,
(const char **) rsh_suffix_args);
free_argv (rsh_suffix_args);
free_argv (rsh_args);
h->auxp =
GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR, NULL,
NULL, NULL, h->helper_argv[0], h->helper_argv);
if (NULL == h->auxp)
{
GNUNET_break (0); /* Cannot exec SSH? */
GNUNET_free (h);
return NULL;
}
h->wait_time = GNUNET_TIME_STD_BACKOFF (h->wait_time);
h->habitability_check_task =
GNUNET_SCHEDULER_add_delayed (h->wait_time, &habitability_check, h);
return h;
}
/**
* Read existing private key from file or create a new one if it does not exist
* yet.
* Returns the private key on success, NULL on error.
*/
static struct GNUNET_CRYPTO_RsaPrivateKey *
init_private_key (const struct GNUNET_CONFIGURATION_Handle *cfg,
const char *nick_name)
{
char *home;
char *keyfile;
struct GNUNET_CRYPTO_RsaPrivateKey *privKey;
#if DEBUG_CHAT
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing private key\n");
#endif
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "chat", "HOME", &home))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Configuration option `%s' in section `%s' missing\n"),
"HOME", "chat");
return NULL;
}
GNUNET_DISK_directory_create (home);
if (GNUNET_OK != GNUNET_DISK_directory_test (home))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to access chat home directory `%s'\n"), home);
GNUNET_free (home);
return NULL;
}
/* read or create private key */
keyfile =
GNUNET_malloc (strlen (home) + strlen (NICK_IDENTITY_PREFIX) +
strlen (nick_name) + 2);
strcpy (keyfile, home);
GNUNET_free (home);
if (keyfile[strlen (keyfile) - 1] != DIR_SEPARATOR)
strcat (keyfile, DIR_SEPARATOR_STR);
strcat (keyfile, NICK_IDENTITY_PREFIX);
strcat (keyfile, nick_name);
privKey = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
if (NULL == privKey)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
_("Failed to create/open key in file `%s'\n"), keyfile);
}
GNUNET_free (keyfile);
return privKey;
}
void
delete_existing_db (const struct GNUNET_CONFIGURATION_Handle *cfg)
{
char *afsdir;
if (GNUNET_OK ==
GNUNET_CONFIGURATION_get_value_filename (cfg, "namestore-sqlite",
"FILENAME", &afsdir))
{
if (GNUNET_OK == GNUNET_DISK_file_test (afsdir))
if (GNUNET_OK == GNUNET_DISK_file_test (afsdir))
if (GNUNET_OK == GNUNET_DISK_directory_remove(afsdir))
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Deleted existing database `%s' \n", afsdir);
GNUNET_free (afsdir);
}
}
/**
* 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);
}
/**
* Lookup the private key for the zone
*
* @param zone the zone we want a private key for
* @return NULL of not found else the key
*/
struct GNUNET_CRYPTO_RsaPrivateKey*
lookup_private_key(struct GNUNET_CRYPTO_ShortHashCode *zone)
{
char* keydir;
struct GNUNET_CRYPTO_ShortHashAsciiEncoded zonename;
char* location;
struct GNUNET_CRYPTO_RsaPrivateKey *key = NULL;
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Looking for private key\n");
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (GNS_cfg,
"namestore",
"ZONEFILE_DIRECTORY", &keydir))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"No zonefile directory!\n");
return NULL;
}
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Zonefile directory is %s\n", keydir);
GNUNET_CRYPTO_short_hash_to_enc (zone, &zonename);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Zonefile is %s.zkey\n", &zonename);
GNUNET_asprintf(&location, "%s%s%s.zkey", keydir,
DIR_SEPARATOR_STR, &zonename);
GNUNET_log (GNUNET_ERROR_TYPE_INFO,
"Checking for %s\n", location);
if (GNUNET_YES == GNUNET_DISK_file_test (location))
key = GNUNET_CRYPTO_rsa_key_create_from_file (location);
GNUNET_free(location);
GNUNET_free(keydir);
return key;
}
/**
* Write our current proof to disk.
*/
static void
write_proof ()
{
char *proof;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg,
"NSE",
"PROOFFILE",
&proof))
return;
if (sizeof (my_proof) !=
GNUNET_DISK_fn_write (proof,
&my_proof,
sizeof (my_proof),
GNUNET_DISK_PERM_USER_READ |
GNUNET_DISK_PERM_USER_WRITE))
GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
"write",
proof);
GNUNET_free (proof);
}
/**
* Try connecting to the server using UNIX domain sockets.
*
* @param service_name name of service to connect to
* @param cfg configuration to use
* @return NULL on error, connection to UNIX otherwise
*/
static struct GNUNET_CONNECTION_Handle *
try_unixpath (const char *service_name,
const struct GNUNET_CONFIGURATION_Handle *cfg)
{
#if AF_UNIX
struct GNUNET_CONNECTION_Handle *connection;
char *unixpath;
struct sockaddr_un s_un;
unixpath = NULL;
if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH", &unixpath)) &&
(0 < strlen (unixpath)))
{
/* We have a non-NULL unixpath, need to validate it */
if (strlen (unixpath) >= sizeof (s_un.sun_path))
{
LOG (GNUNET_ERROR_TYPE_WARNING,
_("UNIXPATH `%s' too long, maximum length is %llu\n"), unixpath,
(unsigned long long) sizeof (s_un.sun_path));
unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
LOG (GNUNET_ERROR_TYPE_INFO,
_("Using `%s' instead\n"), unixpath);
if (NULL == unixpath)
return NULL;
}
connection = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg, unixpath);
if (NULL != connection)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Connected to unixpath `%s'!\n",
unixpath);
GNUNET_free (unixpath);
return connection;
}
}
GNUNET_free_non_null (unixpath);
#endif
return NULL;
}
/**
* Write the current index information list to disk.
*/
static void
write_index_list ()
{
struct GNUNET_BIO_WriteHandle *wh;
char *fn;
struct IndexInfo *pos;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"fs", "INDEXDB");
return;
}
wh = GNUNET_BIO_write_open (fn);
if (NULL == wh)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
_("Could not open `%s'.\n"), fn);
GNUNET_free (fn);
return;
}
for (pos = indexed_files_head; NULL != pos; pos = pos->next)
if ((GNUNET_OK !=
GNUNET_BIO_write (wh, &pos->file_id, sizeof (struct GNUNET_HashCode))) ||
(GNUNET_OK != GNUNET_BIO_write_string (wh, pos->filename)))
break;
if (GNUNET_OK != GNUNET_BIO_write_close (wh))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
_("Error writing `%s'.\n"), fn);
GNUNET_free (fn);
return;
}
GNUNET_free (fn);
}
/**
* 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));
}
static void
do_check (void *cls,
const struct GNUNET_CONFIGURATION_Handle *ccfg,
struct GNUNET_TESTING_Peer *peer)
{
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
struct GNUNET_CRYPTO_ShortHashCode bob_hash;
struct GNUNET_CRYPTO_RsaSignature *sig;
char* alice_keyfile;
struct srv_data *srv_data;
struct GNUNET_TIME_Absolute et;
cfg = ccfg;
die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT, &end_badly, NULL);
/* put records into namestore */
namestore_handle = GNUNET_NAMESTORE_connect(cfg);
if (NULL == namestore_handle)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
end_badly_now();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&alice_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
end_badly_now();
return;
}
alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
struct GNUNET_NAMESTORE_RecordData rd;
char* ip = TEST_IP;
struct in_addr *sipserver = GNUNET_malloc (sizeof (struct in_addr));
srv_data = GNUNET_malloc (sizeof (struct srv_data) + strlen (TEST_SRV_NAME) + 1);
uint16_t srv_weight = 60;
uint16_t srv_prio = 50;
uint16_t srv_port = 5060;
rd.expiration_time = UINT64_MAX;
GNUNET_assert(1 == inet_pton (AF_INET, ip, sipserver));
GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
rd.flags = GNUNET_NAMESTORE_RF_AUTHORITY;
GNUNET_NAMESTORE_record_create (namestore_handle,
alice_key,
TEST_AUTHORITY_NAME,
&rd,
NULL,
NULL);
rd.data_size = sizeof (struct in_addr);
rd.data = sipserver;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
sig = GNUNET_NAMESTORE_create_signature(bob_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
TEST_RECORD_NAME,
&rd, 1);
et.abs_value = rd.expiration_time;
GNUNET_NAMESTORE_record_put (namestore_handle,
&bob_pkey,
TEST_RECORD_NAME,
et,
1,
&rd,
sig,
NULL,
NULL);
GNUNET_free (sig);
rd.data_size = sizeof (struct srv_data)+strlen(TEST_SRV_NAME)+1;
srv_data->port = srv_port;
srv_data->prio = srv_prio;
srv_data->weight = srv_weight;
strcpy((char*)&srv_data[1], TEST_SRV_NAME);
rd.data = srv_data;
rd.record_type = GNUNET_GNS_RECORD_SRV;
sig = GNUNET_NAMESTORE_create_signature(bob_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
TEST_RECORD_NAME_SRV,
&rd, 1);
et.abs_value = rd.expiration_time;
GNUNET_NAMESTORE_record_put (namestore_handle,
&bob_pkey,
TEST_RECORD_NAME_SRV,
et,
1,
&rd,
sig,
&commence_testing,
NULL);
GNUNET_free (alice_keyfile);
GNUNET_free (srv_data);
GNUNET_free (sipserver);
GNUNET_free (sig);
GNUNET_CRYPTO_rsa_key_free (bob_key);
GNUNET_CRYPTO_rsa_key_free (alice_key);
}
/**
* Read index information from disk.
*/
static void
read_index_list ()
{
struct GNUNET_BIO_ReadHandle *rh;
char *fn;
struct IndexInfo *pos;
char *fname;
struct GNUNET_HashCode hc;
size_t slen;
char *emsg;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (cfg, "FS", "INDEXDB", &fn))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
"fs", "INDEXDB");
return;
}
if (GNUNET_NO == GNUNET_DISK_file_test (fn))
{
/* no index info yet */
GNUNET_free (fn);
return;
}
rh = GNUNET_BIO_read_open (fn);
if (NULL == rh)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR | GNUNET_ERROR_TYPE_BULK,
_("Could not open `%s'.\n"), fn);
GNUNET_free (fn);
return;
}
while ((GNUNET_OK ==
GNUNET_BIO_read (rh, "Hash of indexed file", &hc,
sizeof (struct GNUNET_HashCode))) &&
(GNUNET_OK ==
GNUNET_BIO_read_string (rh, "Name of indexed file", &fname,
1024 * 16)) && (fname != NULL))
{
slen = strlen (fname) + 1;
pos = GNUNET_malloc (sizeof (struct IndexInfo) + slen);
pos->file_id = hc;
pos->filename = (const char *) &pos[1];
memcpy (&pos[1], fname, slen);
if (GNUNET_SYSERR ==
GNUNET_CONTAINER_multihashmap_put (ifm, &pos->file_id, pos,
GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
{
GNUNET_free (pos);
}
else
{
GNUNET_CONTAINER_DLL_insert (indexed_files_head,
indexed_files_tail,
pos);
}
GNUNET_free (fname);
}
if (GNUNET_OK != GNUNET_BIO_read_close (rh, &emsg))
GNUNET_free (emsg);
GNUNET_free (fn);
}
/**
* Initialize the database connections and associated
* data structures (create tables and indices
* as needed as well).
*
* @param plugin the plugin context (state for this module)
* @return GNUNET_OK on success
*/
static int
database_setup (struct Plugin *plugin)
{
char *filename;
if (GNUNET_OK !=
GNUNET_CONFIGURATION_get_value_filename (plugin->cfg, "peerstore-sqlite",
"FILENAME", &filename))
{
GNUNET_log_config_missing (GNUNET_ERROR_TYPE_ERROR, "peerstore-sqlite",
"FILENAME");
return GNUNET_SYSERR;
}
if (GNUNET_OK != GNUNET_DISK_file_test (filename))
{
if (GNUNET_OK != GNUNET_DISK_directory_create_for_file (filename))
{
GNUNET_break (0);
GNUNET_free (filename);
return GNUNET_SYSERR;
}
}
/* filename should be UTF-8-encoded. If it isn't, it's a bug */
plugin->fn = filename;
/* Open database and precompile statements */
if (SQLITE_OK != sqlite3_open (plugin->fn, &plugin->dbh))
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Unable to initialize SQLite: %s.\n"),
sqlite3_errmsg (plugin->dbh));
return GNUNET_SYSERR;
}
sql_exec (plugin->dbh, "PRAGMA temp_store=MEMORY");
sql_exec (plugin->dbh, "PRAGMA synchronous=OFF");
sql_exec (plugin->dbh, "PRAGMA legacy_file_format=OFF");
sql_exec (plugin->dbh, "PRAGMA auto_vacuum=INCREMENTAL");
sql_exec (plugin->dbh, "PRAGMA encoding=\"UTF-8\"");
sql_exec (plugin->dbh, "PRAGMA page_size=4096");
sqlite3_busy_timeout (plugin->dbh, BUSY_TIMEOUT_MS);
/* Create tables */
sql_exec (plugin->dbh,
"CREATE TABLE IF NOT EXISTS peerstoredata (\n"
" sub_system TEXT NOT NULL,\n" " peer_id BLOB NOT NULL,\n"
" key TEXT NOT NULL,\n" " value BLOB NULL,\n"
" expiry sqlite3_uint64 NOT NULL" ");");
sqlite3_create_function (plugin->dbh, "UINT64_LT", 2, SQLITE_UTF8, NULL,
&sqlite3_lessthan, NULL, NULL);
/* Create Indices */
if (SQLITE_OK !=
sqlite3_exec (plugin->dbh,
"CREATE INDEX IF NOT EXISTS peerstoredata_key_index ON peerstoredata (sub_system, peer_id, key)",
NULL, NULL, NULL))
{
LOG (GNUNET_ERROR_TYPE_ERROR, _("Unable to create indices: %s.\n"),
sqlite3_errmsg (plugin->dbh));
return GNUNET_SYSERR;
}
/* Prepare statements */
sql_prepare (plugin->dbh,
"INSERT INTO peerstoredata (sub_system, peer_id, key, value, expiry) VALUES (?,?,?,?,?);",
&plugin->insert_peerstoredata);
sql_prepare (plugin->dbh,
"SELECT * FROM peerstoredata" " WHERE sub_system = ?",
&plugin->select_peerstoredata);
sql_prepare (plugin->dbh,
"SELECT * FROM peerstoredata" " WHERE sub_system = ?"
" AND peer_id = ?", &plugin->select_peerstoredata_by_pid);
sql_prepare (plugin->dbh,
"SELECT * FROM peerstoredata" " WHERE sub_system = ?"
" AND key = ?", &plugin->select_peerstoredata_by_key);
sql_prepare (plugin->dbh,
"SELECT * FROM peerstoredata" " WHERE sub_system = ?"
" AND peer_id = ?" " AND key = ?",
&plugin->select_peerstoredata_by_all);
sql_prepare (plugin->dbh,
"DELETE FROM peerstoredata" " WHERE UINT64_LT(expiry, ?)",
&plugin->expire_peerstoredata);
sql_prepare (plugin->dbh,
"DELETE FROM peerstoredata" " WHERE sub_system = ?"
" AND peer_id = ?" " AND key = ?",
&plugin->delete_peerstoredata);
return GNUNET_OK;
}
/**
* 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 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);
}
static void
do_lookup(void *cls, const struct GNUNET_PeerIdentity *id,
const struct GNUNET_CONFIGURATION_Handle *_cfg,
struct GNUNET_TESTING_Daemon *d, const char *emsg)
{
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded alice_pkey;
struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded bob_pkey;
struct GNUNET_CRYPTO_RsaPrivateKey *alice_key;
struct GNUNET_CRYPTO_RsaPrivateKey *bob_key;
struct GNUNET_CRYPTO_RsaSignature *sig;
char* alice_keyfile;
cfg = _cfg;
GNUNET_SCHEDULER_cancel (die_task);
/* put records into namestore */
namestore_handle = GNUNET_NAMESTORE_connect(cfg);
if (NULL == namestore_handle)
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to connect to namestore\n");
ok = -1;
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&alice_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
ok = -1;
return;
}
alice_key = GNUNET_CRYPTO_rsa_key_create_from_file (alice_keyfile);
bob_key = GNUNET_CRYPTO_rsa_key_create_from_file (KEYFILE_BOB);
GNUNET_CRYPTO_rsa_key_get_public (alice_key, &alice_pkey);
GNUNET_CRYPTO_rsa_key_get_public (bob_key, &bob_pkey);
struct GNUNET_NAMESTORE_RecordData rd;
char* ip = TEST_IP;
struct in_addr *web = GNUNET_malloc(sizeof(struct in_addr));
rd.expiration = GNUNET_TIME_UNIT_FOREVER_ABS;
GNUNET_assert(1 == inet_pton (AF_INET, ip, web));
GNUNET_CRYPTO_short_hash(&bob_pkey, sizeof(bob_pkey), &bob_hash);
rd.data_size = sizeof(struct GNUNET_CRYPTO_ShortHashCode);
rd.data = &bob_hash;
rd.record_type = GNUNET_GNS_RECORD_PKEY;
GNUNET_NAMESTORE_record_create (namestore_handle,
alice_key,
TEST_AUTHORITY_NAME,
&rd,
NULL,
NULL);
rd.data_size = sizeof(struct in_addr);
rd.data = web;
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
sig = GNUNET_NAMESTORE_create_signature(bob_key,
GNUNET_TIME_UNIT_FOREVER_ABS,
TEST_RECORD_NAME,
&rd, 1);
GNUNET_NAMESTORE_record_put (namestore_handle,
&bob_pkey,
TEST_RECORD_NAME,
rd.expiration,
1,
&rd,
sig,
&commence_testing,
NULL);
GNUNET_free(sig);
GNUNET_CRYPTO_rsa_key_free(bob_key);
GNUNET_CRYPTO_rsa_key_free(alice_key);
}
/**
* 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 ();
}
/**
* 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 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);
}
static void
run (void *cls,
const struct GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTING_Peer *peer)
{
enum MHD_FLAG flags;
struct GNUNET_CRYPTO_EcdsaPrivateKey *host_key;
struct GNUNET_GNSRECORD_Data rd;
char *zone_keyfile;
namestore = GNUNET_NAMESTORE_connect (cfg);
GNUNET_assert (NULL != namestore);
flags = MHD_USE_DEBUG;
mhd = MHD_start_daemon (flags,
PORT,
NULL, NULL,
&mhd_ahc, NULL,
MHD_OPTION_END);
GNUNET_assert (NULL != mhd);
mhd_main ();
tmp_cfgfile = GNUNET_DISK_mktemp ("test_gns_proxy_tmp.conf");
if (NULL == tmp_cfgfile)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to create tmp cfg!\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_write ((struct GNUNET_CONFIGURATION_Handle *)cfg,
tmp_cfgfile))
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Failed to write tmp cfg\n");
do_shutdown ();
return;
}
proxy_proc = GNUNET_OS_start_process (GNUNET_NO,
GNUNET_OS_INHERIT_STD_ALL,
NULL,
NULL,
NULL,
"gnunet-gns-proxy",
"gnunet-gns-proxy",
"-c", tmp_cfgfile, NULL);
if (NULL == proxy_proc)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
"Unable to start proxy\n");
do_shutdown ();
return;
}
if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (cfg, "gns",
"ZONEKEY",
&zone_keyfile))
{
GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Failed to get key from cfg\n");
return;
}
host_key = GNUNET_CRYPTO_ecdsa_key_create_from_file (zone_keyfile);
rd.expiration_time = GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us;
GNUNET_assert (GNUNET_OK == GNUNET_GNSRECORD_string_to_value (GNUNET_DNSPARSER_TYPE_A,
"127.0.0.1",
(void**)&rd.data,
&rd.data_size));
rd.record_type = GNUNET_DNSPARSER_TYPE_A;
GNUNET_NAMESTORE_record_create (namestore,
host_key,
"www",
&rd,
&commence_testing,
NULL);
GNUNET_free ((void**)rd.data);
GNUNET_free (zone_keyfile);
GNUNET_free (host_key);
}
/**
* 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);
}
