/*
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_by_id_ (uint32_t id,
- const struct GNUNET_CONFIGURATION_Handle
- *cfg)
+ const struct GNUNET_CONFIGURATION_Handle *cfg)
{
return GNUNET_TESTBED_host_create_with_id (id, NULL, NULL, cfg, 0);
}
*/
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);
*cfg,
struct GNUNET_TESTBED_Host ***hosts)
{
- //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);
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);
}
/**
* 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);
}
-/**
- * handle for host registration
- */
-struct GNUNET_TESTBED_HostRegistrationHandle
-{
- /**
- * The host being registered
- */
- struct GNUNET_TESTBED_Host *host;
-
- /**
- * The controller at which this host is being registered
- */
- struct GNUNET_TESTBED_Controller *c;
-
- /**
- * The Registartion completion callback
- */
- GNUNET_TESTBED_HostRegistrationCompletion cc;
-
- /**
- * The closure for above callback
- */
- void *cc_cls;
-};
-
-
/**
* Register a host with the controller
*
(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);
}
-/**
- * Handler for GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM message from
- * controller (testbed service)
- *
- * @param c the controller handler
- * @param msg message received
- * @return GNUNET_YES if we can continue receiving from service; GNUNET_NO if
- * not
- */
-int
-GNUNET_TESTBED_host_handle_addhostconfirm_ (struct GNUNET_TESTBED_Controller *c,
- const struct
- GNUNET_TESTBED_HostConfirmedMessage
- *msg)
-{
- struct GNUNET_TESTBED_HostRegistrationHandle *rh;
- char *emsg;
- uint16_t msg_size;
-
- rh = c->rh;
- if (NULL == rh)
- {
- return GNUNET_OK;
- }
- if (GNUNET_TESTBED_host_get_id_ (rh->host) != ntohl (msg->host_id))
- {
- LOG_DEBUG ("Mismatch in host id's %u, %u of host confirm msg\n",
- GNUNET_TESTBED_host_get_id_ (rh->host), ntohl (msg->host_id));
- return GNUNET_OK;
- }
- c->rh = NULL;
- msg_size = ntohs (msg->header.size);
- if (sizeof (struct GNUNET_TESTBED_HostConfirmedMessage) == msg_size)
- {
- LOG_DEBUG ("Host %u successfully registered\n", ntohl (msg->host_id));
- GNUNET_TESTBED_mark_host_registered_at_ (rh->host, c);
- rh->cc (rh->cc_cls, NULL);
- GNUNET_free (rh);
- return GNUNET_OK;
- }
- /* We have an error message */
- emsg = (char *) &msg[1];
- if ('\0' !=
- emsg[msg_size - sizeof (struct GNUNET_TESTBED_HostConfirmedMessage)])
- {
- GNUNET_break (0);
- GNUNET_free (rh);
- return GNUNET_NO;
- }
- LOG (GNUNET_ERROR_TYPE_ERROR, _("Adding host %u failed with error: %s\n"),
- ntohl (msg->host_id), emsg);
- rh->cc (rh->cc_cls, emsg);
- GNUNET_free (rh);
- return GNUNET_OK;
-}
-
-
/**
* Resolves the hostname of the host to an ip address
*