/*
This file is part of GNUnet
- (C) 2008, 2009, 2012 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2008, 2009, 2012 GNUnet e.V.
GNUnet is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
You should have received a copy of the GNU General Public License
along with GNUnet; see the file COPYING. If not, write to the
- Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA.
+ Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
*/
/**
char *hostkeys_data;
/**
- * memory map for 'hostkeys_data'.
+ * memory map for @e hostkeys_data.
*/
struct GNUNET_DISK_MapHandle *map;
*/
struct GNUNET_ARM_Handle *ah;
- /**
- * Handle to ARM monitoring
- */
- struct GNUNET_ARM_MonitorHandle *mh;
-
/**
* The config of the peer
*/
* startup. This function loads such keys into memory from a file.
*
* @param system the testing system handle
- * @return GNUNET_OK on success; GNUNET_SYSERR on error
+ * @return #GNUNET_OK on success; #GNUNET_SYSERR on error
*/
static int
hostkeys_load (struct GNUNET_TESTING_System *system)
unsigned int cnt;
GNUNET_assert (NULL != testdir);
- system = GNUNET_malloc (sizeof (struct GNUNET_TESTING_System));
- if (NULL == (system->tmppath = getenv ("GNUNET_TESTING_PREFIX")))
+ 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);
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);
HIGH_PORT);
}
+
static void
cleanup_shared_service_instance (struct SharedServiceInstance *i)
{
GNUNET_free (i);
}
+
static int
start_shared_service_instance (struct SharedServiceInstance *i)
{
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);
/**
* Release reservation of a TCP or UDP port for a peer
- * (used during GNUNET_TESTING_peer_destroy).
+ * (used during #GNUNET_TESTING_peer_destroy()).
*
* @param system system to use for reservation tracking
* @param port reserved port to release
* @param system the testing system handle
* @param key_number desired pre-created hostkey to obtain
* @param id set to the peer's identity (hash of the public
- * key; if NULL, GNUNET_SYSERR is returned immediately
+ * key; if NULL, NULL 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;
if (key_number >= system->total_hostkeys)
{
LOG (GNUNET_ERROR_TYPE_ERROR,
- _("Key number %u does not exist\n"), key_number);
+ _("Key number %u does not exist\n"),
+ key_number);
return NULL;
}
- private_key = GNUNET_new (struct GNUNET_CRYPTO_EccPrivateKey);
- memcpy (private_key,
+ private_key = GNUNET_new (struct GNUNET_CRYPTO_EddsaPrivateKey);
+ GNUNET_memcpy (private_key,
system->hostkeys_data +
(key_number * GNUNET_TESTING_HOSTKEYFILESIZE),
GNUNET_TESTING_HOSTKEYFILESIZE);
- GNUNET_CRYPTO_ecc_key_get_public_for_signature (private_key,
- &id->public_key);
+ GNUNET_CRYPTO_eddsa_key_get_public (private_key,
+ &id->public_key);
return private_key;
}
* @param value value of the option
*/
static void
-update_config (void *cls, const char *section, const char *option,
+update_config (void *cls,
+ const char *section,
+ const char *option,
const char *value)
{
struct UpdateContext *uc = cls;
GNUNET_free (allowed_hosts);
}
+
static struct SharedServiceInstance *
associate_shared_service (struct GNUNET_TESTING_System *system,
struct SharedService *ss,
* system. The default configuration will be available in PATHS section under
* 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'.
+ * by #GNUNET_TESTING_peer_configure().
*
* @param system system to use to coordinate resource usage
* @param cfg template configuration to update
- * @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
*/
int
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);
{
/* No prefix */
GNUNET_asprintf(&peer->main_binary, "%s", libexec_binary);
- peer->args = strdup ("");
+ peer->args = GNUNET_strdup ("");
}
else
- peer->args = strdup (libexec_binary);
+ {
+ peer->args = GNUNET_strdup (libexec_binary);
+ }
peer->system = system;
peer->key_number = key_number;
GNUNET_free (libexec_binary);
{
if (NULL != peer->id)
{
- memcpy (id, peer->id, sizeof (struct GNUNET_PeerIdentity));
+ GNUNET_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));
- memcpy (id, peer->id, sizeof (struct GNUNET_PeerIdentity));
+ GNUNET_memcpy (id, peer->id, sizeof (struct GNUNET_PeerIdentity));
}
* Start the peer.
*
* @param peer peer to start
- * @return GNUNET_OK on success, GNUNET_SYSERR on error (i.e. peer already running)
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error (i.e. peer already running)
*/
int
GNUNET_TESTING_peer_start (struct GNUNET_TESTING_Peer *peer)
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,
}
-/**
- * Start a service at a peer using its ARM service
- *
- * @param peer the peer whose service has to be started
- * @param service_name name of the service to start
- * @param timeout how long should the ARM API try to send the request to start
- * the service
- * @param cont the callback to call with result and status from ARM API
- * @param cont_cls the closure for the above callback
- * @return GNUNET_OK upon successfully queuing the service start request;
- * GNUNET_SYSERR upon error
- */
-int
-GNUNET_TESTING_peer_service_start (struct GNUNET_TESTING_Peer *peer,
- const char *service_name,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_ARM_ResultCallback cont,
- void *cont_cls)
-{
- if (NULL == peer->ah)
- return GNUNET_SYSERR;
- GNUNET_ARM_request_service_start (peer->ah,
- service_name,
- GNUNET_OS_INHERIT_STD_ALL,
- timeout,
- cont, cont_cls);
- return GNUNET_OK;
-}
-
-
-/**
- * Stop a service at a peer using its ARM service
- *
- * @param peer the peer whose service has to be stopped
- * @param service_name name of the service to stop
- * @param timeout how long should the ARM API try to send the request to stop
- * the service
- * @param cont the callback to call with result and status from ARM API
- * @param cont_cls the closure for the above callback
- * @return GNUNET_OK upon successfully queuing the service stop request;
- * GNUNET_SYSERR upon error
- */
-int
-GNUNET_TESTING_peer_service_stop (struct GNUNET_TESTING_Peer *peer,
- const char *service_name,
- struct GNUNET_TIME_Relative timeout,
- GNUNET_ARM_ResultCallback cont,
- void *cont_cls)
-{
- if (NULL == peer->ah)
- return GNUNET_SYSERR;
- GNUNET_ARM_request_service_stop (peer->ah,
- service_name,
- timeout,
- cont, cont_cls);
- return GNUNET_OK;
-}
-
-
/**
* Sends SIGTERM to the peer's main process
*
* @param peer the handle to the peer
- * @return GNUNET_OK if successful; GNUNET_SYSERR if the main process is NULL
+ * @return #GNUNET_OK if successful; #GNUNET_SYSERR if the main process is NULL
* or upon any error while sending SIGTERM
*/
int
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++)
{
* Waits for a peer to terminate. The peer's main process will also be destroyed.
*
* @param peer the handle to the peer
- * @return GNUNET_OK if successful; GNUNET_SYSERR if the main process is NULL
+ * @return #GNUNET_OK if successful; #GNUNET_SYSERR if the main process is NULL
* or upon any error while waiting
*/
int
* Stop the peer.
*
* @param peer peer to stop
- * @return GNUNET_OK on success, GNUNET_SYSERR on error
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
*/
int
GNUNET_TESTING_peer_stop (struct GNUNET_TESTING_Peer *peer)
* Function called whenever we connect to or disconnect from ARM.
*
* @param cls closure
- * @param connected GNUNET_YES if connected, GNUNET_NO if disconnected,
- * GNUNET_SYSERR on error.
+ * @param connected #GNUNET_YES if connected, #GNUNET_NO if disconnected,
+ * #GNUNET_SYSERR on error.
*/
static void
disconn_status (void *cls,
return;
}
GNUNET_break (GNUNET_OK == GNUNET_TESTING_peer_wait (peer));
- GNUNET_ARM_disconnect_and_free (peer->ah);
+ GNUNET_ARM_disconnect (peer->ah);
peer->ah = NULL;
peer->cb (peer->cb_cls, peer, GNUNET_YES);
}
* @param peer the peer to stop
* @param cb the callback to signal peer shutdown
* @param cb_cls closure for the above callback
- * @return GNUNET_OK upon successfully giving the request to the ARM API (this
- * does not mean that the peer is successfully stopped); GNUNET_SYSERR
+ * @return #GNUNET_OK upon successfully giving the request to the ARM API (this
+ * does not mean that the peer is successfully stopped); #GNUNET_SYSERR
* upon any error.
*/
int
GNUNET_TESTING_peer_stop_async_cancel (struct GNUNET_TESTING_Peer *peer)
{
GNUNET_assert (NULL != peer->ah);
- GNUNET_ARM_disconnect_and_free (peer->ah);
+ GNUNET_ARM_disconnect (peer->ah);
peer->ah = NULL;
}
if (NULL != peer->main_process)
GNUNET_TESTING_peer_stop (peer);
if (NULL != peer->ah)
- GNUNET_ARM_disconnect_and_free (peer->ah);
- if (NULL != peer->mh)
- GNUNET_ARM_monitor_disconnect_and_free (peer->mh);
+ GNUNET_ARM_disconnect (peer->ah);
GNUNET_free (peer->cfgfile);
if (NULL != peer->cfg)
GNUNET_CONFIGURATION_destroy (peer->cfg);
* Starts a peer using the given configuration and then invokes the
* given callback. This function ALSO initializes the scheduler loop
* and should thus be called directly from "main". The testcase
- * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
+ * should self-terminate by invoking #GNUNET_SCHEDULER_shutdown().
*
* @param testdir only the directory name without any path. This is used for
* all service homes; the directory will be created in a temporary
* @param cfgfilename name of the configuration file to use;
* use NULL to only run with defaults
* @param tm main function of the testcase
- * @param tm_cls closure for 'tm'
+ * @param tm_cls closure for @a tm
* @return 0 on success, 1 on error
*/
int
* Callback to be called when SCHEDULER has been started
*
* @param cls the ServiceContext
- * @param tc the TaskContext
*/
static void
-service_run_main (void *cls,
- const struct GNUNET_SCHEDULER_TaskContext *tc)
+service_run_main (void *cls)
{
struct ServiceContext *sc = cls;
* Starts a service using the given configuration and then invokes the
* given callback. This function ALSO initializes the scheduler loop
* and should thus be called directly from "main". The testcase
- * should self-terminate by invoking 'GNUNET_SCHEDULER_shutdown'.
+ * should self-terminate by invoking #GNUNET_SCHEDULER_shutdown().
*
* This function is useful if the testcase is for a single service
* and if that service doesn't itself depend on other services.
* @param cfgfilename name of the configuration file to use;
* use NULL to only run with defaults
* @param tm main function of the testcase
- * @param tm_cls closure for 'tm'
+ * @param tm_cls closure for @a tm
* @return 0 on success, 1 on error
*/
int
char *binary;
char *libexec_binary;
- GNUNET_log_setup (testdir, "WARNING", NULL);
+ GNUNET_log_setup (testdir,
+ "WARNING",
+ NULL);
system = GNUNET_TESTING_system_create (testdir, "127.0.0.1", NULL, NULL);
if (NULL == system)
return 1;
{
/* No prefix */
GNUNET_asprintf(&peer->main_binary, "%s", libexec_binary);
- peer->args = strdup ("");
+ peer->args = GNUNET_strdup ("");
}
else
- peer->args = strdup (libexec_binary);
+ peer->args = GNUNET_strdup (libexec_binary);
GNUNET_free (libexec_binary);
GNUNET_free (binary);
char *ret;
char *dot;
- memcpy (sbuf, argv0, slen);
+ GNUNET_memcpy (sbuf, argv0, slen);
ret = strrchr (sbuf, '_');
if (NULL == ret)
return NULL;
projects / oweals / gnunet.git / blobdiff