/*
This file is part of GNUnet
- (C) 2008--2013 Christian Grothoff (and other contributing authors)
+ Copyright (C) 2008--2013 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.
*/
/**
*/
struct GNUNET_TESTBED_Host *
GNUNET_TESTBED_host_create_with_id (uint32_t id, const char *hostname,
- const char *username,
+ const char *username,
const struct GNUNET_CONFIGURATION_Handle
*cfg,
uint16_t port)
LOG (GNUNET_ERROR_TYPE_WARNING, "Host with id: %u already created\n", id);
return NULL;
}
- host = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_Host));
+ host = GNUNET_new (struct GNUNET_TESTBED_Host);
host->hostname = (NULL != hostname) ? GNUNET_strdup (hostname) : NULL;
host->username = (NULL != username) ? GNUNET_strdup (username) : NULL;
host->id = id;
host->port = (0 == port) ? 22 : port;
host->cfg = GNUNET_CONFIGURATION_dup (cfg);
host->opq_parallel_overlay_connect_operations =
- GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_ADAPTIVE,
+ GNUNET_TESTBED_operation_queue_create_ (OPERATION_QUEUE_TYPE_ADAPTIVE,
UINT_MAX);
new_size = host_list_size;
while (id >= new_size)
static uint32_t uid_generator;
if (NULL == hostname)
- return GNUNET_TESTBED_host_create_with_id (0, hostname, username,
+ return GNUNET_TESTBED_host_create_with_id (0, hostname, username,
cfg, port);
return GNUNET_TESTBED_host_create_with_id (++uid_generator, hostname,
username, cfg, port);
//struct GNUNET_TESTBED_Host **host_array;
struct GNUNET_TESTBED_Host *starting_host;
char *data;
- char *buf;
+ char *buf;
char *username;
char *hostname;
regex_t rex;
}
if (GNUNET_OK !=
GNUNET_DISK_file_size (filename, &fs, GNUNET_YES, GNUNET_YES))
- fs = 0;
+ fs = 0;
if (0 == fs)
{
LOG (GNUNET_ERROR_TYPE_WARNING, _("Hosts file %s has no data\n"), filename);
return 0;
- }
+ }
data = GNUNET_malloc (fs);
if (fs != GNUNET_DISK_fn_read (filename, data, fs))
{
"^(([[:alnum:]]+)@)?" /* username */
"([[:alnum:]]+[-[:alnum:]_\\.]+)" /* hostname */
"(:([[:digit:]]{1,5}))?", /* port */
- REG_EXTENDED | REG_ICASE));
+ REG_EXTENDED | REG_ICASE));
while (offset < (fs - 1))
- {
+ {
offset++;
if (((data[offset] == '\n')) && (buf != &data[offset]))
{
}
if (-1 != pmatch[5].rm_so)
{
- (void) SSCANF (buf + pmatch[5].rm_so, "%5hd", &port);
+ (void) SSCANF (buf + pmatch[5].rm_so, "%5hd", &port);
}
size = pmatch[3].rm_eo - pmatch[3].rm_so;
hostname = GNUNET_malloc (size + 1);
(void) GNUNET_TESTBED_host_create (hostname, username, cfg, port);
count++;
GNUNET_free_non_null (username);
- GNUNET_free (hostname);
+ GNUNET_free (hostname);
buf = &data[offset + 1];
}
else if ((data[offset] == '\n') || (data[offset] == '\0'))
simple_resolve (const char *host)
{
struct addrinfo *res;
- const struct sockaddr_in *in_addr;
+ const struct sockaddr_in *in_addr;
char *hostip;
struct addrinfo hint;
unsigned int rc;
GNUNET_CONFIGURATION_Handle *cfg,
struct GNUNET_TESTBED_Host ***hosts)
{
-#if !ENABLE_LL
- LOG (GNUNET_ERROR_TYPE_ERROR,
+#if !ENABLE_SUPERMUC
+ LOG (GNUNET_ERROR_TYPE_ERROR,
_("The function %s is only available when compiled with (--with-ll)\n"),
__func__);
GNUNET_assert (0);
#else
const char *hostfile;
-
+
if (NULL == (hostfile = getenv ("MP_SAVEHOSTFILE")))
{
GNUNET_break (0);
return;
}
}
- rc = GNUNET_malloc (sizeof (struct RegisteredController));
+ rc = GNUNET_new (struct RegisteredController);
rc->controller = controller;
GNUNET_CONTAINER_DLL_insert_tail (host->rc_head, host->rc_tail, rc);
}
for (argp = 0; NULL != argv[argp]; argp++) ;
argv_dup = GNUNET_malloc (sizeof (char *) * (argp + 1));
for (argp = 0; NULL != argv[argp]; argp++)
- argv_dup[argp] = strdup (argv[argp]);
+ argv_dup[argp] = GNUNET_strdup (argv[argp]);
return argv_dup;
}
* should not mention `-p' (port) option and destination address as these will
* be set locally in the function from its parameteres. If the environmental
* variable is not found then it defaults to `ssh -o BatchMode=yes -o
- * NoHostAuthenticationForLocalhost=yes'
+ * NoHostAuthenticationForLocalhost=yes -o StrictHostkeyChecking=no -o
+ * PasswordAuthentication=noc'
*
* @param port the destination port number
* @param hostname the hostname of the target host
"BatchMode=yes",
"-o",
"NoHostAuthenticationForLocalhost=yes",
+ "-o",
+ "StrictHostKeyChecking=no",
+ "-o",
+ "PasswordAuthentication=no",
"%h",
NULL
};
}
if (NULL != append_args)
{
- for (append_cnt = 0; NULL != append_args[append_cnt]; append_cnt++)
+ for (append_cnt = 0; NULL != append_args[append_cnt]; append_cnt++)
GNUNET_array_append (rshell_args, cnt, GNUNET_strdup (append_args[append_cnt]));
}
GNUNET_array_append (rshell_args, cnt, NULL);
GNUNET_assert (NULL != cp->shandle);
cp->shandle = NULL;
GNUNET_free (cp->msg);
+ cp->msg = NULL;
}
static char *const binary_argv[] = {
HELPER_TESTBED_BINARY, NULL
};
-
+
GNUNET_assert (NULL != host);
GNUNET_assert (NULL != (cfg = GNUNET_TESTBED_host_get_cfg_ (host)));
hostname = NULL;
host->locked = GNUNET_YES;
API_VIOLATION (GNUNET_NO == host->controller_started,
"Attempting to start a controller on a host which is already started a controller");
- cp = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ControllerProc));
+ cp = GNUNET_new (struct GNUNET_TESTBED_ControllerProc);
if (0 == GNUNET_TESTBED_host_get_id_ (host))
{
cp->helper =
GNUNET_asprintf (&port, "%u", host->port);
LOG_DEBUG ("Starting remote connection to destination %s\n", hostname);
if (GNUNET_OK !=
- GNUNET_CONFIGURATION_get_value_string (cfg, "testbed",
+ GNUNET_CONFIGURATION_get_value_filename (cfg, "testbed",
"HELPER_BINARY_PATH",
&helper_binary_path_args[0]))
helper_binary_path_args[0] =
argstr = GNUNET_strdup ("");
for (cnt = 0; NULL != cp->helper_argv[cnt]; cnt++)
{
- aux = argstr;
+ aux = argstr;
GNUNET_assert (0 < GNUNET_asprintf (&argstr, "%s %s", aux, cp->helper_argv[cnt]));
GNUNET_free (aux);
}
free_argv (cproc->helper_argv);
cproc->host->controller_started = GNUNET_NO;
cproc->host->locked = GNUNET_NO;
+ GNUNET_free_non_null (cproc->msg);
GNUNET_free (cproc);
}
/**
* Task id for the habitability check task
*/
- GNUNET_SCHEDULER_TaskIdentifier habitability_check_task;
+ struct GNUNET_SCHEDULER_Task * habitability_check_task;
/**
* How long we wait before checking the process status. Should grow
* Task for checking whether a host is habitable or not
*
* @param cls GNUNET_TESTBED_HostHabitableCheckHandle
- * @param tc the scheduler task context
*/
static void
-habitability_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+habitability_check (void *cls)
{
struct GNUNET_TESTBED_HostHabitableCheckHandle *h = cls;
void *cb_cls;
enum GNUNET_OS_ProcessStatusType type;
int ret;
- h->habitability_check_task = GNUNET_SCHEDULER_NO_TASK;
+ h->habitability_check_task = NULL;
ret = GNUNET_OS_process_status (h->auxp, &type, &code);
if (GNUNET_SYSERR == ret)
{
const char *hostname;
char *port;
- h = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_HostHabitableCheckHandle));
+ 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_string (config, "testbed",
+ 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_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);
free_argv (rsh_args);
h->auxp =
GNUNET_OS_start_process_vap (GNUNET_NO, GNUNET_OS_INHERIT_STD_ERR, NULL,
- NULL, h->helper_argv[0], h->helper_argv);
+ NULL, NULL, h->helper_argv[0], h->helper_argv);
if (NULL == h->auxp)
{
GNUNET_break (0); /* Cannot exec SSH? */
*handle)
{
GNUNET_SCHEDULER_cancel (handle->habitability_check_task);
- (void) GNUNET_OS_process_kill (handle->auxp, SIGTERM);
+ (void) GNUNET_OS_process_kill (handle->auxp, GNUNET_TERM_SIG);
(void) GNUNET_OS_process_wait (handle->auxp);
GNUNET_OS_process_destroy (handle->auxp);
free_argv (handle->helper_argv);
(NULL == hostname) ? "localhost" : hostname);
return NULL;
}
- rh = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_HostRegistrationHandle));
+ rh = GNUNET_new (struct GNUNET_TESTBED_HostRegistrationHandle);
rh->host = host;
rh->c = controller;
GNUNET_assert (NULL != cc);
*
* @param h the host handle
* @param op the operation to queue in the given host's parally overlay connect
- * queue
+ * queue
*/
void
-GNUNET_TESTBED_host_queue_oc_ (struct GNUNET_TESTBED_Host *h,
+GNUNET_TESTBED_host_queue_oc_ (struct GNUNET_TESTBED_Host *h,
struct GNUNET_TESTBED_Operation *op)
-{
+{
GNUNET_TESTBED_operation_queue_insert_
(h->opq_parallel_overlay_connect_operations, op);
}