{
/**
* Prefix (i.e. "/tmp/gnunet-testing/") we prepend to each
- * SERVICEHOME. */
+ * GNUNET_HOME.
+ */
char *tmppath;
/**
*
* @param testdir only the directory name without any path. This is used for
* all service homes; the directory will be created in a temporary
- * location depending on the underlying OS
+ * location depending on the underlying OS. This variable will be
+ * overridden with the value of the environmental variable
+ * GNUNET_TESTING_PREFIX, if it exists.
* @param trusted_ip the ip address which will be set as TRUSTED HOST in all
* service configurations generated to allow control connections from
* this ip. This can either be a single ip address or a network address
unsigned int cnt;
GNUNET_assert (NULL != testdir);
- system = GNUNET_malloc (sizeof (struct GNUNET_TESTING_System));
- system->tmppath = GNUNET_DISK_mkdtemp (testdir);
+ system = GNUNET_new (struct GNUNET_TESTING_System);
+ if (NULL == (system->tmppath = getenv (GNUNET_TESTING_PREFIX)))
+ system->tmppath = GNUNET_DISK_mkdtemp (testdir);
+ else
+ system->tmppath = GNUNET_strdup (system->tmppath);
system->lowport = lowport;
system->highport = highport;
if (NULL == system->tmppath)
for (cnt = 0; NULL != shared_services[cnt].service; cnt++)
{
tss = shared_services[cnt];
- ss = GNUNET_malloc (sizeof (struct SharedService));
+ ss = GNUNET_new (struct SharedService);
ss->sname = GNUNET_strdup (tss.service);
ss->cfg = GNUNET_CONFIGURATION_create ();
GNUNET_CONFIGURATION_iterate_section_values (tss.cfg, ss->sname,
&cfg_copy_iterator, ss->cfg);
GNUNET_CONFIGURATION_iterate_section_values (tss.cfg, "TESTING",
&cfg_copy_iterator, ss->cfg);
+ GNUNET_CONFIGURATION_iterate_section_values (tss.cfg, "PATHS",
+ &cfg_copy_iterator, ss->cfg);
ss->share = tss.share;
GNUNET_array_append (system->shared_services, system->n_shared_services,
ss);
*
* @param testdir only the directory name without any path. This is used for all
* service homes; the directory will be created in a temporary location
- * depending on the underlying OS
+ * depending on the underlying OS. This variable will be
+ * overridden with the value of the environmental variable
+ * GNUNET_TESTING_PREFIX, if it exists.
* @param trusted_ip the ip address which will be set as TRUSTED HOST in all
* service configurations generated to allow control connections from
* this ip. This can either be a single ip address or a network address
GNUNET_free (binary);
i->proc = GNUNET_OS_start_process (PIPE_CONTROL,
GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
- NULL, NULL,
+ NULL, NULL, NULL,
libexec_binary,
libexec_binary,
"-c",
stop_shared_service_instance (struct SharedServiceInstance *i)
{
GNUNET_break (0 == i->n_refs);
- if (0 != GNUNET_OS_process_kill (i->proc, SIGTERM))
+ if (0 != GNUNET_OS_process_kill (i->proc, GNUNET_TERM_SIG))
LOG (GNUNET_ERROR_TYPE_WARNING,
"Killing shared service instance (%s) failed\n", i->ss->sname);
(void) GNUNET_OS_process_wait (i->proc);
continue;
bind_status = GNUNET_NETWORK_socket_bind (socket,
ai->ai_addr,
- ai->ai_addrlen,
- 0);
+ ai->ai_addrlen);
GNUNET_NETWORK_socket_close (socket);
if (GNUNET_OK != bind_status)
break;
continue;
bind_status = GNUNET_NETWORK_socket_bind (socket,
ai->ai_addr,
- ai->ai_addrlen,
- 0);
+ ai->ai_addrlen);
GNUNET_NETWORK_socket_close (socket);
if (GNUNET_OK != bind_status)
break;
* key; if NULL, GNUNET_SYSERR is returned immediately
* @return NULL on error (not enough keys)
*/
-struct GNUNET_CRYPTO_EccPrivateKey *
+struct GNUNET_CRYPTO_EddsaPrivateKey *
GNUNET_TESTING_hostkey_get (const struct GNUNET_TESTING_System *system,
uint32_t key_number,
struct GNUNET_PeerIdentity *id)
{
- struct GNUNET_CRYPTO_EccPrivateKey *private_key;
+ struct GNUNET_CRYPTO_EddsaPrivateKey *private_key;
if ((NULL == id) || (NULL == system->hostkeys_data))
return NULL;
_("Key number %u does not exist\n"), key_number);
return NULL;
}
- private_key = GNUNET_new (struct GNUNET_CRYPTO_EccPrivateKey);
+ private_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPrivateKey);
memcpy (private_key,
system->hostkeys_data +
(key_number * GNUNET_TESTING_HOSTKEYFILESIZE),
GNUNET_TESTING_HOSTKEYFILESIZE);
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (private_key,
+ GNUNET_CRYPTO_eddsa_key_get_public (private_key,
&id->public_key);
return private_key;
}
/**
* The customized service home path for this peer
*/
- char *service_home;
+ char *gnunet_home;
/**
* Array of ports currently allocated to this peer. These ports will be
single_variable))
{
GNUNET_snprintf (uval, sizeof (uval), "%s/%s.sock",
- uc->service_home, section);
+ uc->gnunet_home, section);
value = uval;
}
else if ((GNUNET_YES ==
{
struct SharedServiceInstance *i;
struct GNUNET_CONFIGURATION_Handle *temp;
- char *service_home;
+ char *gnunet_home;
uint32_t port;
ss->n_peers++;
( (0 != ss->share)
&& (ss->n_instances < ((ss->n_peers + ss->share - 1) / ss->share)) ) )
{
- i = GNUNET_malloc (sizeof (struct SharedServiceInstance));
+ i = GNUNET_new (struct SharedServiceInstance);
i->ss = ss;
- (void) GNUNET_asprintf (&service_home, "%s/shared/%s/%u",
+ (void) GNUNET_asprintf (&gnunet_home, "%s/shared/%s/%u",
system->tmppath, ss->sname, ss->n_instances);
- (void) GNUNET_asprintf (&i->unix_sock, "%s/sock", service_home);
+ (void) GNUNET_asprintf (&i->unix_sock, "%s/sock", gnunet_home);
port = GNUNET_TESTING_reserve_port (system);
if (0 == port)
{
- GNUNET_free (service_home);
+ GNUNET_free (gnunet_home);
cleanup_shared_service_instance (i);
return NULL;
}
GNUNET_array_append (ss->instances, ss->n_instances, i);
temp = GNUNET_CONFIGURATION_dup (ss->cfg);
(void) GNUNET_asprintf (&i->port_str, "%u", port);
- (void) GNUNET_asprintf (&i->cfg_fn, "%s/config", service_home);
- GNUNET_CONFIGURATION_set_value_string (temp, "PATHS", "SERVICEHOME",
- service_home);
- GNUNET_free (service_home);
+ (void) GNUNET_asprintf (&i->cfg_fn, "%s/config", gnunet_home);
+ GNUNET_CONFIGURATION_set_value_string (temp, "PATHS", "GNUNET_HOME",
+ gnunet_home);
+ GNUNET_free (gnunet_home);
GNUNET_CONFIGURATION_set_value_string (temp, ss->sname, "UNIXPATH",
i->unix_sock);
GNUNET_CONFIGURATION_set_value_string (temp, ss->sname, "PORT",
* Create a new configuration using the given configuration as a template;
* ports and paths will be modified to select available ports on the local
* system. The default configuration will be available in PATHS section under
- * the option DEFAULTCONFIG after the call. SERVICE_HOME is also set in PATHS
+ * the option DEFAULTCONFIG after the call. GNUNET_HOME is also set in PATHS
* section to the temporary directory specific to this configuration. If we run
- * out of "*port" numbers, return SYSERR.
+ * out of "*port" numbers, return #GNUNET_SYSERR.
*
* This is primarily a helper function used internally
* by 'GNUNET_TESTING_peer_configure'.
* @param ports array with port numbers used in the created configuration.
* Will be updated upon successful return. Can be NULL
* @param nports the size of the `ports' array. Will be updated.
- * @return GNUNET_OK on success, GNUNET_SYSERR on error - the configuration will
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error - the configuration will
* be incomplete and should not be used there upon
*/
static int
uc.status = GNUNET_OK;
uc.ports = NULL;
uc.nports = 0;
- GNUNET_asprintf (&uc.service_home, "%s/%u", system->tmppath,
+ GNUNET_asprintf (&uc.gnunet_home, "%s/%u", system->tmppath,
system->path_counter++);
- GNUNET_asprintf (&default_config, "%s/config", uc.service_home);
+ GNUNET_asprintf (&default_config, "%s/config", uc.gnunet_home);
GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "DEFAULTCONFIG",
default_config);
GNUNET_CONFIGURATION_set_value_string (cfg, "arm", "CONFIG",
default_config);
GNUNET_free (default_config);
- GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "SERVICEHOME",
- uc.service_home);
+ GNUNET_CONFIGURATION_set_value_string (cfg, "PATHS", "GNUNET_HOME",
+ uc.gnunet_home);
/* make PORTs and UNIXPATHs unique */
GNUNET_CONFIGURATION_iterate (cfg, &update_config, &uc);
/* allow connections to services from system trusted_ip host */
GNUNET_CONFIGURATION_set_value_string (cfg,
"nat",
"USE_LOCALADDR", "YES");
- GNUNET_free (uc.service_home);
+ GNUNET_free (uc.gnunet_home);
if ((NULL != ports) && (NULL != nports))
{
*ports = uc.ports;
* Create a new configuration using the given configuration as a template;
* ports and paths will be modified to select available ports on the local
* system. The default configuration will be available in PATHS section under
- * the option DEFAULTCONFIG after the call. SERVICE_HOME is also set in PATHS
+ * the option DEFAULTCONFIG after the call. GNUNET_HOME is also set in PATHS
* section to the temporary directory specific to this configuration. If we run
* out of "*port" numbers, return SYSERR.
*
char *config_filename;
char *libexec_binary;
char *emsg_;
- struct GNUNET_CRYPTO_EccPrivateKey *pk;
+ struct GNUNET_CRYPTO_EddsaPrivateKey *pk;
uint16_t *ports;
struct SharedService *ss;
struct SharedServiceInstance **ss_instances;
ss = system->shared_services[cnt];
ss_instances[cnt] = associate_shared_service (system, ss, cfg);
if (NULL == ss_instances[cnt])
+ {
+ emsg_ = GNUNET_strdup ("FIXME");
goto err_ret;
+ }
}
GNUNET_assert (GNUNET_OK ==
- GNUNET_CONFIGURATION_get_value_string
+ GNUNET_CONFIGURATION_get_value_filename
(cfg, "PATHS", "DEFAULTCONFIG", &config_filename));
if (GNUNET_OK != GNUNET_CONFIGURATION_write (cfg, config_filename))
{
GNUNET_free (config_filename);
goto err_ret;
}
- peer = GNUNET_malloc (sizeof (struct GNUNET_TESTING_Peer));
+ peer = GNUNET_new (struct GNUNET_TESTING_Peer);
peer->ss_instances = ss_instances;
peer->cfgfile = config_filename; /* Free in peer_destroy */
peer->cfg = GNUNET_CONFIGURATION_dup (cfg);
peer->args = strdup ("");
}
else
+ {
peer->args = strdup (libexec_binary);
+ }
peer->system = system;
peer->key_number = key_number;
GNUNET_free (libexec_binary);
memcpy (id, peer->id, sizeof (struct GNUNET_PeerIdentity));
return;
}
- peer->id = GNUNET_malloc (sizeof (struct GNUNET_PeerIdentity));
+ peer->id = GNUNET_new (struct GNUNET_PeerIdentity);
GNUNET_free (GNUNET_TESTING_hostkey_get (peer->system,
peer->key_number,
peer->id));
return GNUNET_SYSERR;
i->n_refs++;
}
- peer->main_process = GNUNET_OS_start_process (PIPE_CONTROL,
- GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
- NULL, NULL,
- peer->main_binary,
- peer->main_binary,
- peer->args,
- "-c",
- peer->cfgfile,
- NULL);
+ peer->main_binary = GNUNET_CONFIGURATION_expand_dollar (peer->cfg, peer->main_binary);
+ peer->main_process = GNUNET_OS_start_process_s (PIPE_CONTROL,
+ GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
+ NULL,
+ peer->main_binary,
+ peer->args,
+ "-c",
+ peer->cfgfile,
+ NULL);
if (NULL == peer->main_process)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
GNUNET_break (0);
return GNUNET_SYSERR;
}
- if (0 != GNUNET_OS_process_kill (peer->main_process, SIGTERM))
+ if (0 != GNUNET_OS_process_kill (peer->main_process, GNUNET_TERM_SIG))
return GNUNET_SYSERR;
for (cnt = 0; cnt < peer->system->n_shared_services; cnt++)
{
projects / oweals / gnunet.git / blobdiff