#include "gnunet_service_lib.h"
#include "gnunet_server_lib.h"
#include "gnunet_transport_service.h"
+#include "gnunet_core_service.h"
+#include "gnunet_hello_lib.h"
#include <zlib.h>
#include "gnunet_testbed_service.h"
#define LOG_DEBUG(...) \
LOG (GNUNET_ERROR_TYPE_DEBUG, __VA_ARGS__)
-
+/**
+ * By how much should the arrays lists grow
+ */
#define LIST_GROW_STEP 10
+/**
+ * Default timeout for operations which may take some time
+ */
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 30)
+
+/**
+ * The main context information associated with the client which started us
+ */
struct Context
{
/**
};
-/**
- * Slave startup context
- */
-struct SlaveContext
-{
- /**
- * The slave corresponding to this context
- */
- struct Slave *slave;
-
- /**
- * The configuration used as a template while startup
- */
- struct GNUNET_CONFIGURATION_Handle *cfg;
-};
-
-
/**
* States of LCFContext
*/
*/
DELEGATED_HOST_REGISTERED,
+ /**
+ * The slave host has been registred at the forwarding controller
+ */
+ SLAVE_HOST_REGISTERED,
+
/**
* The context has been finished (may have error)
*/
*/
struct LCFContext
{
- /**
- * The serialized and compressed configuration
- */
- char *sxcfg;
-
/**
* The gateway which will pass the link message to delegated host
*/
struct Slave *gateway;
/**
- * The host registration handle while registered hosts in this context
+ * The controller link message that has to be forwarded to
*/
- struct GNUNET_TESTBED_HostRegistrationHandle *rhandle;
+ struct GNUNET_TESTBED_ControllerLinkMessage *msg;
/**
- * The size of the compressed serialized configuration
+ * The client which has asked to perform this operation
*/
- size_t sxcfg_size;
+ struct GNUNET_SERVER_Client *client;
/**
- * The size of the uncompressed configuration
+ * The host registration handle while registered hosts in this context
*/
- size_t scfg_size;
+ struct GNUNET_TESTBED_HostRegistrationHandle *rhandle;
/**
- * Should the delegated host be started by the slave host?
+ * The id of the operation which created this context
*/
- int is_subordinate;
+ uint64_t operation_id;
/**
* The state of this context
* The delegated host
*/
uint32_t delegated_host_id;
-
+
+ /**
+ * The slave host
+ */
+ uint32_t slave_host_id;
};
*/
struct Peer
{
- /**
- * The peer handle from testing API
- */
- struct GNUNET_TESTING_Peer *peer;
+ union
+ {
+ struct
+ {
+ /**
+ * The peer handle from testing API
+ */
+ struct GNUNET_TESTING_Peer *peer;
+
+ /**
+ * The modified (by GNUNET_TESTING_peer_configure) configuration this
+ * peer is configured with
+ */
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ } local;
+
+ struct
+ {
+ /**
+ * The controller this peer is started through
+ */
+ struct GNUNET_TESTBED_Controller *controller;
- /**
- * The modified (by GNUNET_TESTING_peer_configure) configuration this peer is
- * configured with
- */
- struct GNUNET_CONFIGURATION_Handle *cfg;
+ } remote;
+
+ } details;
/**
* Our local reference id for this peer
*/
uint32_t id;
+ /**
+ * Is this peer local created?
+ */
+ uint32_t is_remote;
+
};
+/**
+ * State information for overlay connect context
+ */
+enum OCCState
+ {
+ /**
+ * Initial state
+ */
+ OCC_STATE_INIT,
+
+ /**
+ * Peer 1 has connected to peer0
+ */
+ OCC_STATE_PEER0_SUCCESS,
+
+ /**
+ * Peer 2 has connected to peer1
+ */
+ OCC_STATE_PEER1_SUCCESS,
+
+ };
+
+
/**
* Context information for connecting 2 peers in overlay
*/
struct OverlayConnectContext
{
/**
- * peer 1
+ * The client which has requested for overlay connection
+ */
+ struct GNUNET_SERVER_Client *client;
+
+ /**
+ * the peer which has to connect to the other peer
+ */
+ struct Peer *peer;
+
+ /**
+ * The other peer
*/
- struct Peer *peer1;
+ struct Peer *other_peer;
/**
- * peer 2
+ * Transport handle of the first peer to offer second peer's HELLO
+ */
+ struct GNUNET_TRANSPORT_Handle *p1th;
+
+ /**
+ * Transport handle of other peer to get its HELLO
+ */
+ struct GNUNET_TRANSPORT_Handle *p2th;
+
+ /**
+ * Core handles of the peer which has to connect to other peer
*/
- struct Peer *peer2;
+ struct GNUNET_CORE_Handle *ch;
/**
- * Transport handle of peer1
+ * HELLO of the other peer
*/
- struct GNUNET_TRANSPORT_Handle *peer1_transport;
+ struct GNUNET_MessageHeader *hello;
/**
- * Transport handle of peer2
+ * Get hello handle for the other peer
*/
- struct GNUNET_TRANSPORT_Handle *peer2_transport;
+ struct GNUNET_TRANSPORT_GetHelloHandle *ghh;
+
+ /**
+ * The error message we send if this overlay connect operation has timed out
+ */
+ char *emsg;
/**
- * HELLO of peer1
+ * The peer identity of the first peer
*/
- struct GNUNET_MessageHeader *peer1_hello;
+ struct GNUNET_PeerIdentity peer_identity;
+
+ /**
+ * The peer identity of the other peer
+ */
+ struct GNUNET_PeerIdentity other_peer_identity;
+
+ /**
+ * The id of the operation responsible for creating this context
+ */
+ uint64_t op_id;
+
+ /**
+ * The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to
+ * connect to peer 2
+ */
+ GNUNET_SCHEDULER_TaskIdentifier send_hello_task;
/**
- * HELLO of peer2
+ * The id of the overlay connect timeout task
+ */
+ GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+ /**
+ * State information for determining whose HELLOs have been successfully
+ * exchanged
*/
- struct GNUNET_MessageHeader *peer2_hello;
+ enum OCCState state;
+
+};
+
+/**
+ * Context information for operations forwarded to subcontrollers
+ */
+struct ForwardedOperationContext
+{
/**
- * Get hello handle for peer1
+ * The generated operation context
*/
- struct GNUNET_TRANSPORT_GetHelloHandle *peer1_ghh;
+ struct OperationContext *opc;
+
+ /**
+ * The client to which we have to reply
+ */
+ struct GNUNET_SERVER_Client *client;
+
+ /**
+ * Closure pointer
+ */
+ void *cls;
+
+ /**
+ * Task ID for the timeout task
+ */
+ GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+
+ /**
+ * The id of the operation that has been forwarded
+ */
+ uint64_t operation_id;
+
+};
+
+
+/**
+ * Context information used while linking controllers
+ */
+struct LinkControllersContext
+{
+ /**
+ * The client which initiated the link controller operation
+ */
+ struct GNUNET_SERVER_Client *client;
+
+ /**
+ * The ID of the operation
+ */
+ uint64_t operation_id;
/**
- * Get hello handle for peer2
+ * Pointer to the slave handle if we are directly starting/connecting to the controller
*/
- struct GNUNET_TRANSPORT_GetHelloHandle *peer2_ghh;
+ struct Slave *slave;
};
+
/**
* The master context; generated with the first INIT message
*/
}
+/**
+ * Removes a the give peer from the peer array
+ *
+ * @param peer the peer to be removed
+ */
+static void
+peer_list_remove (struct Peer *peer)
+{
+ uint32_t id;
+
+ peer_list[peer->id] = NULL;
+ while (peer_list_size >= LIST_GROW_STEP)
+ {
+ for (id = peer_list_size - 1;
+ id > peer_list_size - LIST_GROW_STEP; id--)
+ if (NULL != peer_list[id])
+ break;
+ if (id != peer_list_size - LIST_GROW_STEP)
+ break;
+ peer_list_size -= LIST_GROW_STEP;
+ }
+ peer_list = GNUNET_realloc (peer_list, sizeof (struct GNUNET_TESTBED_Peer*)
+ * peer_list_size);
+}
+
+
+/**
+ * Finds the route with directly connected host as destination through which
+ * the destination host can be reached
+ *
+ * @param host_id the id of the destination host
+ * @return the route with directly connected destination host; NULL if no route
+ * is found
+ */
+static struct Route *
+find_dest_route (uint32_t host_id)
+{
+ struct Route *route;
+
+ while(NULL != (route = route_list[host_id]))
+ {
+ if (route->thru == master_context->host_id)
+ break;
+ host_id = route->thru;
+ }
+ return route;
+}
+
+
/**
* Routes message to a host given its host_id
*
}
+/**
+ * Send operation failure message to client
+ *
+ * @param client the client to which the failure message has to be sent to
+ * @param operation_id the id of the failed operation
+ * @param emsg the error message; can be NULL
+ */
+static void
+send_operation_fail_msg (struct GNUNET_SERVER_Client *client,
+ uint64_t operation_id,
+ const char *emsg)
+{
+ struct GNUNET_TESTBED_OperationFailureEventMessage *msg;
+ uint16_t msize;
+ uint16_t emsg_len;
+
+ msize = sizeof (struct GNUNET_TESTBED_OperationFailureEventMessage);
+ emsg_len = (NULL == emsg) ? 0 : strlen (emsg) + 1;
+ msize += emsg_len;
+ msg = GNUNET_malloc (msize);
+ msg->header.size = htons (msize);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_OPERATIONEVENT);
+ msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
+ msg->operation_id = GNUNET_htonll (operation_id);
+ if (0 != emsg_len)
+ memcpy (&msg[1], emsg, emsg_len);
+ queue_message (client, &msg->header);
+}
+
+
+/**
+ * Function to send generic operation success message to given client
+ *
+ * @param client the client to send the message to
+ * @param operation_id the id of the operation which was successful
+ */
+static void
+send_operation_success_msg (struct GNUNET_SERVER_Client *client,
+ uint64_t operation_id)
+{
+ struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *msg;
+ uint16_t msize;
+
+ msize = sizeof (struct GNUNET_TESTBED_GenericOperationSuccessEventMessage);
+ msg = GNUNET_malloc (msize);
+ msg->header.size = htons (msize);
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS);
+ msg->operation_id = GNUNET_htonll (operation_id);
+ msg->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
+ queue_message (client, &msg->header);
+}
+
+
/**
* The Link Controller forwarding task
*
{
case INIT:
if (NULL != emsg)
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Host registration failed with message: %s\n", emsg);
- lcf->state = FINISHED;
- lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
- return;
- }
+ goto registration_error;
lcf->state = DELEGATED_HOST_REGISTERED;
lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
break;
+ case DELEGATED_HOST_REGISTERED:
+ if (NULL != emsg)
+ goto registration_error;
+ lcf->state = SLAVE_HOST_REGISTERED;
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
+ break;
default:
GNUNET_assert (0); /* Shouldn't reach here */
}
+ return;
+
+ registration_error:
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Host registration failed with message: %s\n", emsg);
+ lcf->state = FINISHED;
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
+}
+
+
+/**
+ * Callback to be called when forwarded link controllers operation is
+ * successfull. We have to relay the reply msg back to the client
+ *
+ * @param cls ForwardedOperationContext
+ * @param msg the peer create success message
+ */
+static void
+forwarded_operation_reply_relay (void *cls,
+ const struct GNUNET_MessageHeader *msg)
+{
+ struct ForwardedOperationContext *fopc = cls;
+ struct GNUNET_MessageHeader *dup_msg;
+ uint16_t msize;
+
+ msize = ntohs (msg->size);
+ dup_msg = GNUNET_malloc (msize);
+ (void) memcpy (dup_msg, msg, msize);
+ queue_message (fopc->client, dup_msg);
+ GNUNET_SERVER_client_drop (fopc->client);
+ GNUNET_SCHEDULER_cancel (fopc->timeout_task);
+ GNUNET_free (fopc);
+}
+
+
+/**
+ * Task to free resources when forwarded link controllers has been timedout
+ *
+ * @param cls the ForwardedOperationContext
+ * @param tc the task context from scheduler
+ */
+static void
+forwarded_operation_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext
+ *tc)
+{
+ struct ForwardedOperationContext *fopc = cls;
+
+ GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc);
+ send_operation_fail_msg (fopc->client, fopc->operation_id, "Timeout");
+ GNUNET_SERVER_client_drop (fopc->client);
+ GNUNET_free (fopc);
}
{
struct LCFContext *lcf = cls;
struct LCFContextQueue *lcfq;
-
+ struct ForwardedOperationContext *fopc;
+
lcf_proc_task_id = GNUNET_SCHEDULER_NO_TASK;
switch (lcf->state)
{
lcf->rhandle =
GNUNET_TESTBED_register_host (lcf->gateway->controller,
host_list[lcf->delegated_host_id],
- lcf_proc_cc, lcf);
+ lcf_proc_cc, lcf);
}
else
{
}
break;
case DELEGATED_HOST_REGISTERED:
- GNUNET_TESTBED_controller_link_2 (lcf->gateway->controller,
- host_list[lcf->delegated_host_id],
- host_list[lcf->gateway->host_id],
- lcf->sxcfg, lcf->sxcfg_size,
- lcf->scfg_size,
- lcf->is_subordinate);
+ if (GNUNET_NO ==
+ GNUNET_TESTBED_is_host_registered_ (host_list[lcf->slave_host_id],
+ lcf->gateway->controller))
+ {
+ lcf->rhandle =
+ GNUNET_TESTBED_register_host (lcf->gateway->controller,
+ host_list[lcf->slave_host_id],
+ lcf_proc_cc, lcf);
+ }
+ else
+ {
+ lcf->state = SLAVE_HOST_REGISTERED;
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
+ }
+ break;
+ case SLAVE_HOST_REGISTERED:
+ fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ fopc->client = lcf->client;
+ fopc->operation_id = lcf->operation_id;
+ fopc->opc =
+ GNUNET_TESTBED_forward_operation_msg_ (lcf->gateway->controller,
+ lcf->operation_id,
+ &lcf->msg->header,
+ &forwarded_operation_reply_relay,
+ fopc);
+ fopc->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+ &forwarded_operation_timeout, fopc);
lcf->state = FINISHED;
- case FINISHED:
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
+ break;
+ case FINISHED:
lcfq = lcfq_head;
GNUNET_assert (lcfq->lcf == lcf);
- GNUNET_free (lcf->sxcfg);
+ GNUNET_free (lcf->msg);
GNUNET_free (lcf);
GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq);
GNUNET_free (lcfq);
* @param event information about the event
*/
static void
-slave_event_callback(void *cls,
- const struct GNUNET_TESTBED_EventInformation *event)
+slave_event_callback (void *cls,
+ const struct GNUNET_TESTBED_EventInformation *event)
{
GNUNET_break (0);
}
const struct GNUNET_CONFIGURATION_Handle *cfg,
int status)
{
- struct SlaveContext *sc = cls;
+ struct LinkControllersContext *lcc = cls;
if (GNUNET_SYSERR == status)
{
- sc->slave->controller_proc = NULL;
+ lcc->slave->controller_proc = NULL;
LOG (GNUNET_ERROR_TYPE_WARNING,
"Unexpected slave shutdown\n");
GNUNET_SCHEDULER_shutdown (); /* We too shutdown */
return;
}
- GNUNET_CONFIGURATION_destroy (sc->cfg);
- sc->slave->controller =
- GNUNET_TESTBED_controller_connect (cfg, host_list[sc->slave->host_id],
+ lcc->slave->controller =
+ GNUNET_TESTBED_controller_connect (cfg, host_list[lcc->slave->host_id],
master_context->event_mask,
- &slave_event_callback, sc->slave);
- GNUNET_free (sc);
+ &slave_event_callback, lcc->slave);
+ if (NULL != lcc->slave->controller)
+ send_operation_success_msg (lcc->client, lcc->operation_id);
+ else
+ send_operation_fail_msg (lcc->client, lcc->operation_id,
+ "Could not connect to delegated controller");
+ GNUNET_SERVER_client_drop (lcc->client);
+ GNUNET_free (lcc);
}
{
const struct GNUNET_TESTBED_InitMessage *msg;
struct GNUNET_TESTBED_Host *host;
- void *addr;
- size_t addrlen;
+ const char *controller_hostname;
+ uint16_t msize;
if (NULL != master_context)
{
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
- msg = (const struct GNUNET_TESTBED_InitMessage *) message;
+ msg = (const struct GNUNET_TESTBED_InitMessage *) message;
+ msize = ntohs (message->size);
+ if (msize <= sizeof (struct GNUNET_TESTBED_InitMessage))
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ msize -= sizeof (struct GNUNET_TESTBED_InitMessage);
+ controller_hostname = (const char *) &msg[1];
+ if ('\0' != controller_hostname[msize - 1])
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
master_context = GNUNET_malloc (sizeof (struct Context));
master_context->client = client;
master_context->host_id = ntohl (msg->host_id);
- GNUNET_assert (GNUNET_OK ==
- GNUNET_SERVER_client_get_address (client, &addr, &addrlen));
- master_context->master_ip = GNUNET_malloc (NI_MAXHOST);
- if (0 != getnameinfo (addr, addrlen, master_context->master_ip, NI_MAXHOST,
- NULL, 0, NI_NUMERICHOST))
- {
- LOG (GNUNET_ERROR_TYPE_WARNING,
- "Cannot determine the ip of master controller: %s\n", STRERROR (errno));
- GNUNET_free (addr);
- GNUNET_free (master_context->master_ip);
- GNUNET_assert (0);
- }
- GNUNET_free (addr);
- if (0 == strcasecmp (master_context->master_ip, "localhost"))
- { /* Hack for connections via unix sockets */
- LOG_DEBUG ("May be using local sockets - assuming loopback for master ip\n");
- GNUNET_free (master_context->master_ip);
- master_context->master_ip = strdup ("127.0.0.1");
- }
+ master_context->master_ip = GNUNET_strdup (controller_hostname);
LOG_DEBUG ("Master Controller IP: %s\n", master_context->master_ip);
master_context->system =
GNUNET_TESTING_system_create ("testbed", master_context->master_ip);
uint16_t username_length;
uint16_t hostname_length;
uint16_t reply_size;
+ uint16_t msize;
msg = (const struct GNUNET_TESTBED_AddHostMessage *) message;
- username_length = ntohs (msg->user_name_length);
- username_length = (0 == username_length) ? 0 : username_length + 1;
+ msize = ntohs (msg->header.size);
username = (char *) &(msg[1]);
+ username_length = ntohs (msg->user_name_length);
+ GNUNET_assert (msize > (sizeof (struct GNUNET_TESTBED_AddHostMessage)
+ + username_length + 1)); /* msg must contain hostname */
+ if (0 != username_length)
+ GNUNET_assert ('\0' == username[username_length]);
+ username_length = (0 == username_length) ? 0 : username_length + 1;
hostname = username + username_length;
- if (ntohs (message->size) <=
- (sizeof (struct GNUNET_TESTBED_AddHostMessage) + username_length))
- {
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return;
- }
- hostname_length = ntohs (message->size)
- - (sizeof (struct GNUNET_TESTBED_AddHostMessage) + username_length);
- if (strlen (hostname) != hostname_length - 1)
- {
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return;
- }
+ hostname_length = msize - (sizeof (struct GNUNET_TESTBED_AddHostMessage)
+ + username_length);
+ GNUNET_assert ('\0' == hostname[hostname_length - 1]);
+ GNUNET_assert (strlen (hostname) == hostname_length - 1);
host_id = ntohl (msg->host_id);
LOG_DEBUG ("Received ADDHOST message\n");
LOG_DEBUG ("-------host id: %u\n", host_id);
if (NULL != hostname) LOG_DEBUG ("-------hostname: %s\n", hostname);
if (0 != username_length) LOG_DEBUG ("-------username: %s\n", username);
- else LOG_DEBUG ("-------username: NULL\n");
+ else
+ {
+ LOG_DEBUG ("-------username: NULL\n");
+ username = NULL;
+ }
LOG_DEBUG ("-------ssh port: %u\n", ntohs (msg->ssh_port));
host = GNUNET_TESTBED_host_create_with_id (host_id, hostname, username,
ntohs (msg->ssh_port));
+ GNUNET_assert (NULL != host);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
reply_size = sizeof (struct GNUNET_TESTBED_HostConfirmedMessage);
if (GNUNET_OK != host_list_add (host))
{
- /* We are unable to add a host */
+ /* We are unable to add a host */
emsg = "A host exists with given host-id";
LOG_DEBUG ("%s: %u", emsg, host_id);
GNUNET_TESTBED_host_destroy (host);
reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_ADDHOSTCONFIRM);
reply->header.size = htons (reply_size);
reply->host_id = htonl (host_id);
- queue_message (client, (struct GNUNET_MessageHeader *) reply);
+ queue_message (client, &reply->header);
}
{
const struct GNUNET_TESTBED_ControllerLinkMessage *msg;
struct GNUNET_CONFIGURATION_Handle *cfg;
- struct SlaveContext *sc;
struct LCFContextQueue *lcfq;
struct Route *route;
struct Route *new_route;
LOG (GNUNET_ERROR_TYPE_WARNING, "Slave and delegated host are same\n");
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
- }
- msize -= sizeof (struct GNUNET_TESTBED_ControllerLinkMessage);
- config_size = ntohs (msg->config_size);
+ }
if (slave_host_id == master_context->host_id) /* Link from us */
{
struct Slave *slave;
-
+
+ msize -= sizeof (struct GNUNET_TESTBED_ControllerLinkMessage);
+ config_size = ntohs (msg->config_size);
if ((delegated_host_id < slave_list_size) &&
(NULL != slave_list[delegated_host_id])) /* We have already added */
{
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
- if (config_size == dest_size)
+ if (config_size != dest_size)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Uncompressed config size mismatch\n");
GNUNET_free (config);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
}
cfg = GNUNET_CONFIGURATION_create (); /* Free here or in lcfcontext */
if (GNUNET_OK != GNUNET_CONFIGURATION_deserialize (cfg, config, config_size,
return;
}
slave = GNUNET_malloc (sizeof (struct Slave));
- slave->host_id = delegated_host_id;
+ slave->host_id = delegated_host_id;
slave_list_add (slave);
- sc = GNUNET_malloc (sizeof (struct SlaveContext));
- sc->slave = slave;
- sc->cfg = cfg;
if (1 == msg->is_subordinate)
{
+ struct LinkControllersContext *lcc;
+ lcc = GNUNET_malloc (sizeof (struct LinkControllersContext));
+ lcc->operation_id = GNUNET_ntohll (msg->operation_id);
+ GNUNET_SERVER_client_keep (client);
+ lcc->client = client;
+ lcc->slave = slave;
slave->controller_proc =
GNUNET_TESTBED_controller_start (master_context->master_ip,
host_list[slave->host_id],
cfg, &slave_status_callback,
- sc);
- }
+ lcc);
+ }
+ else {
+ slave->controller =
+ GNUNET_TESTBED_controller_connect (cfg, host_list[slave->host_id],
+ master_context->event_mask,
+ &slave_event_callback, slave);
+ if (NULL != slave->controller)
+ send_operation_success_msg (client, GNUNET_ntohll (msg->operation_id));
+ else
+ send_operation_fail_msg (client, GNUNET_ntohll (msg->operation_id),
+ "Could not connect to delegated controller");
+ }
+ GNUNET_CONFIGURATION_destroy (cfg);
new_route = GNUNET_malloc (sizeof (struct Route));
new_route->dest = delegated_host_id;
new_route->thru = master_context->host_id;
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
- while (NULL != (route = route_list[slave_host_id]))
- {
- if (route->thru == master_context->host_id)
- break;
- slave_host_id = route->thru;
- }
- GNUNET_assert (NULL != route); /* because we add routes carefully */
- GNUNET_assert (route->dest < slave_list_size);
- GNUNET_assert (NULL != slave_list[route->dest]);
lcfq = GNUNET_malloc (sizeof (struct LCFContextQueue));
lcfq->lcf = GNUNET_malloc (sizeof (struct LCFContext));
lcfq->lcf->delegated_host_id = delegated_host_id;
- lcfq->lcf->is_subordinate =
- (1 == msg->is_subordinate) ? GNUNET_YES : GNUNET_NO;
+ lcfq->lcf->slave_host_id = slave_host_id;
+ route = find_dest_route (slave_host_id);
+ GNUNET_assert (NULL != route); /* because we add routes carefully */
+ GNUNET_assert (route->dest < slave_list_size);
+ GNUNET_assert (NULL != slave_list[route->dest]);
lcfq->lcf->state = INIT;
+ lcfq->lcf->operation_id = GNUNET_ntohll (msg->operation_id);
lcfq->lcf->gateway = slave_list[route->dest];
- lcfq->lcf->sxcfg_size = msize;
- lcfq->lcf->sxcfg = GNUNET_malloc (msize);
- lcfq->lcf->scfg_size = config_size;
- (void) memcpy (lcfq->lcf->sxcfg, &msg[1], msize);
+ lcfq->lcf->msg = GNUNET_malloc (msize);
+ (void) memcpy (lcfq->lcf->msg, msg, msize);
+ GNUNET_SERVER_client_keep (client);
+ lcfq->lcf->client = client;
if (NULL == lcfq_head)
{
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
GNUNET_CONTAINER_DLL_insert_tail (lcfq_head, lcfq_tail, lcfq);
- lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcfq);
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcfq->lcf);
}
else
GNUNET_CONTAINER_DLL_insert_tail (lcfq_head, lcfq_tail, lcfq);
+ /* FIXME: Adding a new route should happen after the controllers are linked
+ successfully */
GNUNET_SERVER_receive_done (client, GNUNET_OK);
new_route = GNUNET_malloc (sizeof (struct Route));
new_route->dest = delegated_host_id;
}
+/**
+ * The task to be executed if the forwarded peer create operation has been
+ * timed out
+ *
+ * @param cls the FowardedOperationContext
+ * @param tc the TaskContext from the scheduler
+ */
+static void
+peer_create_forward_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct ForwardedOperationContext *fo_ctxt = cls;
+
+ /* send error msg to client */
+ send_operation_fail_msg (fo_ctxt->client, fo_ctxt->operation_id,
+ "Timedout");
+ GNUNET_SERVER_client_drop (fo_ctxt->client);
+ GNUNET_TESTBED_forward_operation_msg_cancel_ (fo_ctxt->opc);
+ GNUNET_free (fo_ctxt);
+}
+
+
+/**
+ * Callback to be called when forwarded peer create operation is
+ * successfull. We have to relay the reply msg back to the client
+ *
+ * @param cls ForwardedOperationContext
+ * @param msg the peer create success message
+ */
+static void
+peer_create_success_cb (void *cls,
+ const struct GNUNET_MessageHeader *msg)
+{
+ struct ForwardedOperationContext *fo_ctxt = cls;
+ const struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *success_msg;
+ struct GNUNET_MessageHeader *dup_msg;
+ struct Peer *peer;
+ uint16_t msize;
+
+ GNUNET_SCHEDULER_cancel (fo_ctxt->timeout_task);
+ if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS)
+ {
+ success_msg
+ = (const struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *) msg;
+ peer = GNUNET_malloc (sizeof (struct Peer));
+ peer->is_remote = GNUNET_YES;
+ peer->id = ntohl (success_msg->peer_id);
+ GNUNET_assert (NULL != fo_ctxt->cls);
+ peer->details.remote.controller = fo_ctxt->cls;
+ peer_list_add (peer);
+ }
+ msize = ntohs (msg->size);
+ dup_msg = GNUNET_malloc (msize);
+ (void) memcpy (dup_msg, msg, msize);
+ queue_message (fo_ctxt->client, dup_msg);
+ GNUNET_SERVER_client_drop (fo_ctxt->client);
+ GNUNET_free (fo_ctxt);
+}
+
+
+
/**
* Handler for GNUNET_MESSAGE_TYPE_TESTBED_CREATEPEER messages
*
const struct GNUNET_TESTBED_PeerCreateMessage *msg;
struct GNUNET_TESTBED_PeerCreateSuccessEventMessage *reply;
struct GNUNET_CONFIGURATION_Handle *cfg;
+ struct ForwardedOperationContext *fo_ctxt;
+ struct Route *route;
+ struct Peer *peer;
char *config;
size_t dest_size;
int ret;
uint32_t config_size;
+ uint32_t host_id;
uint16_t msize;
return;
}
msg = (const struct GNUNET_TESTBED_PeerCreateMessage *) message;
- if (ntohl (msg->host_id) == master_context->host_id)
+ host_id = ntohl (msg->host_id);
+ if (host_id == master_context->host_id)
{
- struct Peer *peer;
char *emsg;
/* We are responsible for this peer */
}
GNUNET_free (config);
peer = GNUNET_malloc (sizeof (struct Peer));
- peer->cfg = cfg;
+ peer->is_remote = GNUNET_NO;
+ peer->details.local.cfg = cfg;
peer->id = ntohl (msg->peer_id);
LOG_DEBUG ("Creating peer with id: %u\n", peer->id);
- peer->peer = GNUNET_TESTING_peer_configure (master_context->system, peer->cfg,
- peer->id,
- NULL /* Peer id */,
- &emsg);
- if (NULL == peer->peer)
+ peer->details.local.peer =
+ GNUNET_TESTING_peer_configure (master_context->system,
+ peer->details.local.cfg, peer->id,
+ NULL /* Peer id */,
+ &emsg);
+ if (NULL == peer->details.local.peer)
{
LOG (GNUNET_ERROR_TYPE_WARNING, "Configuring peer failed: %s\n", emsg);
GNUNET_free (emsg);
+ GNUNET_free (peer);
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
-
- /* FIXME: Forward the peer to other host */
- GNUNET_break (0);
+
+ /* Forward peer create request */
+ route = find_dest_route (host_id);
+ if (NULL == route)
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ fo_ctxt = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ GNUNET_SERVER_client_keep (client);
+ fo_ctxt->client = client;
+ fo_ctxt->operation_id = GNUNET_ntohll (msg->operation_id);
+ fo_ctxt->cls = slave_list[route->dest]->controller;
+ fo_ctxt->opc =
+ GNUNET_TESTBED_forward_operation_msg_ (slave_list[route->dest]->controller,
+ fo_ctxt->operation_id,
+ &msg->header,
+ peer_create_success_cb, fo_ctxt);
+ fo_ctxt->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+ &peer_create_forward_timeout, fo_ctxt);
+
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
const struct GNUNET_MessageHeader *message)
{
const struct GNUNET_TESTBED_PeerDestroyMessage *msg;
- struct GNUNET_TESTBED_GenericOperationSuccessEventMessage *reply;
+ struct ForwardedOperationContext *fopc;
+ struct Peer *peer;
uint32_t peer_id;
- uint32_t id;
- uint16_t reply_size;
msg = (const struct GNUNET_TESTBED_PeerDestroyMessage *) message;
peer_id = ntohl (msg->peer_id);
LOG_DEBUG ("Received peer destory on peer: %u and operation id: %ul\n",
- peer_id, GNUNET_ntohll (msg->operation_id));
+ peer_id, GNUNET_ntohll (msg->operation_id));
if ((peer_list_size <= peer_id) || (NULL == peer_list[peer_id]))
{
- GNUNET_break (0);
- /* FIXME: Reply with failure event message or forward to slave controller */
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Asked to destroy a non existent peer with id: %u\n", peer_id);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
- }
- GNUNET_TESTING_peer_destroy (peer_list[peer_id]->peer);
- GNUNET_CONFIGURATION_destroy (peer_list[peer_id]->cfg);
- GNUNET_free (peer_list[peer_id]);
- peer_list[peer_id] = NULL;
- for (id = 0; id < LIST_GROW_STEP; id++)
- {
- if (((peer_id + id >= peer_list_size) ||
- (NULL != peer_list[peer_id])))
- break;
}
- if (LIST_GROW_STEP == id)
+ peer = peer_list[peer_id];
+ if (GNUNET_YES == peer->is_remote)
{
- peer_list_size -= LIST_GROW_STEP;
- peer_list = GNUNET_realloc (peer_list, peer_list_size);
+ /* Forward the destory message to sub controller */
+ fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ GNUNET_SERVER_client_keep (client);
+ fopc->client = client;
+ fopc->operation_id = GNUNET_ntohll (msg->operation_id);
+ fopc->opc =
+ GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.controller,
+ fopc->operation_id,
+ &msg->header,
+ &forwarded_operation_reply_relay,
+ fopc);
+ fopc->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+ &forwarded_operation_timeout, fopc);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
}
- reply_size =
- sizeof (struct GNUNET_TESTBED_GenericOperationSuccessEventMessage);
- reply = GNUNET_malloc (reply_size);
- reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS);
- reply->header.size = htons (reply_size);
- reply->operation_id = msg->operation_id;
- reply->event_type = htonl (GNUNET_TESTBED_ET_OPERATION_FINISHED);
- queue_message (client, &reply->header);
+ GNUNET_TESTING_peer_destroy (peer->details.local.peer);
+ GNUNET_CONFIGURATION_destroy (peer->details.local.cfg);
+ peer_list_remove (peer);
+ GNUNET_free (peer);
+ send_operation_success_msg (client, GNUNET_ntohll (msg->operation_id));
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
{
const struct GNUNET_TESTBED_PeerStartMessage *msg;
struct GNUNET_TESTBED_PeerEventMessage *reply;
+ struct ForwardedOperationContext *fopc;
+ struct Peer *peer;
uint32_t peer_id;
msg = (const struct GNUNET_TESTBED_PeerStartMessage *) message;
|| (NULL == peer_list[peer_id]))
{
GNUNET_break (0);
- /* FIXME: reply with failure message or forward to slave controller */
+ LOG (GNUNET_ERROR_TYPE_ERROR,
+ "Asked to start a non existent peer with id: %u\n", peer_id);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
- if (GNUNET_OK != GNUNET_TESTING_peer_start (peer_list[peer_id]->peer))
+ peer = peer_list[peer_id];
+ if (GNUNET_YES == peer->is_remote)
{
- /* FIXME: return FAILURE message */
- GNUNET_break (0);
+ fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ GNUNET_SERVER_client_keep (client);
+ fopc->client = client;
+ fopc->operation_id = GNUNET_ntohll (msg->operation_id);
+ fopc->opc =
+ GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.controller,
+ fopc->operation_id,
+ &msg->header,
+ &forwarded_operation_reply_relay,
+ fopc);
+ fopc->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+ &forwarded_operation_timeout, fopc);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ if (GNUNET_OK !=
+ GNUNET_TESTING_peer_start (peer->details.local.peer))
+ {
+ send_operation_fail_msg (client, GNUNET_ntohll (msg->operation_id),
+ "Failed to start");
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
{
const struct GNUNET_TESTBED_PeerStopMessage *msg;
struct GNUNET_TESTBED_PeerEventMessage *reply;
+ struct ForwardedOperationContext *fopc;
+ struct Peer *peer;
uint32_t peer_id;
msg = (const struct GNUNET_TESTBED_PeerStopMessage *) message;
peer_id = ntohl (msg->peer_id);
if ((peer_id >= peer_list_size) || (NULL == peer_list[peer_id]))
+ {
+ send_operation_fail_msg (client, GNUNET_ntohll (msg->operation_id),
+ "Peer not found");
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ peer = peer_list[peer_id];
+ if (GNUNET_YES == peer->is_remote)
{
- GNUNET_break (0); /* FIXME: route to slave? */
+ fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ GNUNET_SERVER_client_keep (client);
+ fopc->client = client;
+ fopc->operation_id = GNUNET_ntohll (msg->operation_id);
+ fopc->opc =
+ GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.controller,
+ fopc->operation_id,
+ &msg->header,
+ &forwarded_operation_reply_relay,
+ fopc);
+ fopc->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+ &forwarded_operation_timeout, fopc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
- if (GNUNET_OK != GNUNET_TESTING_peer_stop (peer_list[peer_id]->peer))
+ if (GNUNET_OK !=
+ GNUNET_TESTING_peer_stop (peer->details.local.peer))
{
- /* FIXME: return FAILURE message */
- GNUNET_break (0);
+ send_operation_fail_msg (client, GNUNET_ntohll (msg->operation_id),
+ "Failed to stop peer");
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
{
const struct GNUNET_TESTBED_PeerGetConfigurationMessage *msg;
struct GNUNET_TESTBED_PeerConfigurationInformationMessage *reply;
+ struct Peer *peer;
char *config;
char *xconfig;
size_t c_size;
peer_id = ntohl (msg->peer_id);
if ((peer_id >= peer_list_size) || (NULL == peer_list[peer_id]))
{
- /* FIXME: return FAILURE message */
+ send_operation_fail_msg (client, GNUNET_ntohll (msg->operation_id),
+ "Peer not found");
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ peer = peer_list[peer_id];
+ if (GNUNET_YES == peer->is_remote)
+ {
+ /* FIXME: forward to sub controller */
GNUNET_break (0);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
}
- config = GNUNET_CONFIGURATION_serialize (peer_list[peer_id]->cfg,
- &c_size);
+ config =
+ GNUNET_CONFIGURATION_serialize (peer_list[peer_id]->details.local.cfg,
+ &c_size);
xc_size = GNUNET_TESTBED_compress_config_ (config, c_size, &xconfig);
GNUNET_free (config);
msize = xc_size + sizeof (struct
reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG);
reply->peer_id = msg->peer_id;
reply->operation_id = msg->operation_id;
- GNUNET_TESTING_peer_get_identity (peer_list[peer_id]->peer,
+ GNUNET_TESTING_peer_get_identity (peer_list[peer_id]->details.local.peer,
&reply->peer_identity);
reply->config_size = htons ((uint16_t) c_size);
queue_message (client, &reply->header);
}
+/**
+ * Task for cleaing up overlay connect context structure
+ *
+ * @param cls the overlay connect context
+ * @param tc the task context
+ */
+static void
+occ_cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct OverlayConnectContext *occ = cls;
+
+ GNUNET_free_non_null (occ->emsg);
+ GNUNET_free_non_null (occ->hello);
+ if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task)
+ GNUNET_SCHEDULER_cancel (occ->send_hello_task);
+ if (NULL != occ->ch)
+ GNUNET_CORE_disconnect (occ->ch);
+ if (NULL != occ->ghh)
+ GNUNET_TRANSPORT_get_hello_cancel (occ->ghh);
+ if (NULL != occ->p1th)
+ GNUNET_TRANSPORT_disconnect (occ->p1th);
+ if (NULL != occ->p2th)
+ GNUNET_TRANSPORT_disconnect (occ->p2th);
+ GNUNET_free (occ);
+}
+
+
+/**
+ * Task which will be run when overlay connect request has been timed out
+ *
+ * @param cls the OverlayConnectContext
+ * @param tc the TaskContext
+ */
+static void
+timeout_overlay_connect (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct OverlayConnectContext *occ = cls;
+
+ occ->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ send_operation_fail_msg (occ->client, occ->op_id, occ->emsg);
+ GNUNET_SERVER_client_drop (occ->client);
+ occ_cleanup (occ, tc);
+}
+
+
+
+/**
+ * Function called to notify transport users that another
+ * peer connected to us.
+ *
+ * @param cls closure
+ * @param new_peer the peer that connected
+ * @param ats performance data
+ * @param ats_count number of entries in ats (excluding 0-termination)
+ */
+static void
+overlay_connect_notify (void *cls,
+ const struct GNUNET_PeerIdentity * new_peer,
+ const struct GNUNET_ATS_Information * ats,
+ unsigned int ats_count)
+{
+ struct OverlayConnectContext *occ = cls;
+ struct GNUNET_TESTBED_ConnectionEventMessage *msg;
+ char *new_peer_str;
+ char *other_peer_str;
+
+ LOG_DEBUG ("Overlay connect notify\n");
+ if (0 == memcmp (new_peer, &occ->peer_identity,
+ sizeof (struct GNUNET_PeerIdentity)))
+ return;
+ new_peer_str = GNUNET_strdup (GNUNET_i2s (new_peer));
+ other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
+ if (0 != memcmp (new_peer, &occ->other_peer_identity,
+ sizeof (struct GNUNET_PeerIdentity)))
+ {
+ LOG_DEBUG ("Unexpected peer %4s connected to peer %4s\n",
+ new_peer_str, other_peer_str);
+ GNUNET_free (new_peer_str);
+ GNUNET_free (other_peer_str);
+ return;
+ }
+ LOG_DEBUG ("Peer %4s connected to peer %4s\n", new_peer_str, other_peer_str);
+ GNUNET_free (new_peer_str);
+ GNUNET_free (other_peer_str);
+ if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task)
+ {
+ GNUNET_SCHEDULER_cancel (occ->send_hello_task);
+ occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK;
+ }
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task);
+ GNUNET_SCHEDULER_cancel (occ->timeout_task);
+ occ->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_free_non_null (occ->emsg);
+ occ->emsg = NULL;
+ GNUNET_TRANSPORT_disconnect (occ->p1th);
+ occ->p1th = NULL;
+ /* Peer 1 has connected connect to peer2 - now send overlay connect success message */
+ LOG_DEBUG ("Peers connected - Sending overlay connect success\n");
+ msg = GNUNET_malloc (sizeof (struct GNUNET_TESTBED_ConnectionEventMessage));
+ msg->header.size = htons (sizeof (struct
+ GNUNET_TESTBED_ConnectionEventMessage));
+ msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_PEERCONEVENT);
+ msg->event_type = htonl (GNUNET_TESTBED_ET_CONNECT);
+ msg->peer1 = htonl (occ->peer->id);
+ msg->peer2 = htonl (occ->other_peer->id);
+ msg->operation_id = GNUNET_htonll (occ->op_id);
+ queue_message (occ->client, &msg->header);
+ GNUNET_SERVER_client_drop (occ->client);
+ GNUNET_SCHEDULER_add_now (&occ_cleanup, occ);
+}
+
+
+static void
+send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct OverlayConnectContext *occ = cls;
+ char *other_peer_str;
+
+ occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK;
+ if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
+ return;
+ GNUNET_assert (NULL != occ->hello);
+ other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
+ LOG_DEBUG ("Offering HELLO of %s to %s\n", other_peer_str, GNUNET_i2s (&occ->peer_identity));
+ GNUNET_free (other_peer_str);
+ GNUNET_TRANSPORT_offer_hello (occ->p1th, occ->hello, NULL, NULL);
+ GNUNET_TRANSPORT_try_connect (occ->p1th, &occ->other_peer_identity);
+ occ->send_hello_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+ &send_hello, occ);
+}
+
+/**
+ * Test for checking whether HELLO message is empty
+ *
+ * @param cls empty flag to set
+ * @param address the HELLO
+ * @param expiration expiration of the HELLO
+ * @return
+ */
+static int
+test_address (void *cls, const struct GNUNET_HELLO_Address *address,
+ struct GNUNET_TIME_Absolute expiration)
+{
+ int *empty = cls;
+
+ *empty = GNUNET_NO;
+ return GNUNET_OK;
+}
+
/**
* Function called whenever there is an update to the
- * HELLO of this peer.
+ * HELLO of peers in the OverlayConnectClosure
*
* @param cls closure
* @param hello our updated HELLO
*/
static void
-hello_update_cb (void *cls,
- const struct GNUNET_MessageHeader *hello)
+hello_update_cb (void *cls, const struct GNUNET_MessageHeader *hello)
+{
+ struct OverlayConnectContext *occ = cls;
+ int empty;
+ uint16_t msize;
+
+ msize = ntohs (hello->size);
+ if (msize < 0)
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ "HELLO message of peer %s is of size 0\n",
+ &occ->other_peer_identity);
+ return;
+ }
+ empty = GNUNET_YES;
+ (void)
+ GNUNET_HELLO_iterate_addresses ((const struct GNUNET_HELLO_Message *) hello,
+ GNUNET_NO, &test_address, &empty);
+ if (GNUNET_YES == empty)
+ {
+ LOG_DEBUG ("HELLO of %s is empty\n", GNUNET_i2s (&occ->other_peer_identity));
+ return;
+ }
+ LOG_DEBUG ("Received HELLO of %s\n", GNUNET_i2s (&occ->other_peer_identity));
+ occ->hello = GNUNET_malloc (msize);
+ memcpy (occ->hello, hello, msize);
+ GNUNET_TRANSPORT_get_hello_cancel (occ->ghh);
+ occ->ghh = NULL;
+ GNUNET_TRANSPORT_disconnect (occ->p2th);
+ occ->p2th = NULL;
+ GNUNET_free_non_null (occ->emsg);
+ occ->emsg = GNUNET_strdup ("Timeout while offering HELLO to other peer");
+ occ->send_hello_task = GNUNET_SCHEDULER_add_now (&send_hello, occ);
+}
+
+
+/**
+ * Function called after GNUNET_CORE_connect has succeeded (or failed
+ * for good). Note that the private key of the peer is intentionally
+ * not exposed here; if you need it, your process should try to read
+ * the private key file directly (which should work if you are
+ * authorized...).
+ *
+ * @param cls closure
+ * @param server handle to the server, NULL if we failed
+ * @param my_identity ID of this peer, NULL if we failed
+ */
+static void
+core_startup_cb (void *cls, struct GNUNET_CORE_Handle * server,
+ const struct GNUNET_PeerIdentity *my_identity)
{
- GNUNET_break(0);
+ struct OverlayConnectContext *occ = cls;
+
+ GNUNET_free_non_null (occ->emsg);
+ occ->emsg = NULL;
+ memcpy (&occ->peer_identity, my_identity, sizeof (struct GNUNET_PeerIdentity));
+ occ->p1th =
+ GNUNET_TRANSPORT_connect (occ->peer->details.local.cfg,
+ &occ->peer_identity, NULL, NULL, NULL, NULL);
+ /* Connect to the transport of 2nd peer and get its HELLO message */
+ GNUNET_TESTING_peer_get_identity (occ->other_peer->details.local.peer,
+ &occ->other_peer_identity);
+ occ->p2th =
+ GNUNET_TRANSPORT_connect (occ->other_peer->details.local.cfg,
+ &occ->other_peer_identity,
+ NULL, NULL, NULL, NULL);
+ if ((NULL == occ->p1th) || (NULL == occ->p2th))
+ {
+ occ->emsg = GNUNET_strdup ("Cannot connect to TRANSPORTs of peers");
+ goto send_failure;
+ }
+ LOG_DEBUG ("Acquiring HELLO of peer %s\n", GNUNET_i2s
+ (&occ->other_peer_identity));
+ occ->emsg = GNUNET_strdup ("Timeout while acquiring HELLO message");
+ occ->ghh = GNUNET_TRANSPORT_get_hello (occ->p2th, &hello_update_cb, occ);
+ return;
+
+ send_failure:
+ GNUNET_SCHEDULER_cancel (occ->timeout_task);
+ occ->timeout_task = GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
}
{
const struct GNUNET_TESTBED_OverlayConnectMessage *msg;
struct OverlayConnectContext *occ;
+ struct GNUNET_CORE_MessageHandler no_handlers[] = {
+ {NULL, 0, 0}
+ };
uint32_t p1;
uint32_t p2;
GNUNET_assert (NULL != peer_list[p1]);
GNUNET_assert (p2 < peer_list_size);
GNUNET_assert (NULL != peer_list[p2]);
+ /* FIXME: Add cases where we have to forward overlay connect message to sub
+ controllers */
occ = GNUNET_malloc (sizeof (struct OverlayConnectContext));
- occ->peer1 = peer_list[p1];
- occ->peer2 = peer_list[p2];
- occ->peer1_transport = GNUNET_TRANSPORT_connect (occ->peer1->cfg, NULL, occ,
- NULL, NULL, NULL);
- occ->peer2_transport = GNUNET_TRANSPORT_connect (occ->peer2->cfg, NULL, occ,
- NULL, NULL, NULL);
- occ->peer1_ghh = GNUNET_TRANSPORT_get_hello (occ->peer1_transport, &hello_update_cb, occ);
- occ->peer2_ghh = GNUNET_TRANSPORT_get_hello (occ->peer2_transport, &hello_update_cb, occ);
+ GNUNET_SERVER_client_keep (client);
+ occ->client = client;
+ occ->state = OCC_STATE_INIT;
+ occ->peer = peer_list[p1];
+ occ->other_peer = peer_list[p2];
+ occ->op_id = GNUNET_ntohll (msg->operation_id);
+ occ->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 30),
+ &timeout_overlay_connect, occ);
+ /* Connect to the core of 1st peer and wait for the 2nd peer to connect */
+ occ->emsg = GNUNET_strdup ("Timeout while connecting to CORE");
+ occ->ch =
+ GNUNET_CORE_connect (occ->peer->details.local.cfg, occ, &core_startup_cb,
+ &overlay_connect_notify, NULL, NULL, GNUNET_NO, NULL,
+ GNUNET_NO, no_handlers);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
for (lcfq = lcfq_head; NULL != lcfq; lcfq = lcfq_head)
{
- GNUNET_free (lcfq->lcf->sxcfg);
+ GNUNET_free (lcfq->lcf->msg);
GNUNET_free (lcfq->lcf);
GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq);
GNUNET_free (lcfq);
for (id = 0; id < peer_list_size; id++)
if (NULL != peer_list[id])
{
- GNUNET_TESTING_peer_destroy (peer_list[id]->peer);
- GNUNET_CONFIGURATION_destroy (peer_list[id]->cfg);
+ if (GNUNET_NO == peer_list[id]->is_remote)
+ {
+ GNUNET_TESTING_peer_destroy (peer_list[id]->details.local.peer);
+ GNUNET_CONFIGURATION_destroy (peer_list[id]->details.local.cfg);
+ }
GNUNET_free (peer_list[id]);
}
GNUNET_free_non_null (peer_list);
for (id = 0; id < slave_list_size; id++)
if (NULL != slave_list[id])
{
- GNUNET_assert (NULL != slave_list[id]->controller);
- GNUNET_TESTBED_controller_disconnect (slave_list[id]->controller);
+ if (NULL != slave_list[id]->controller)
+ GNUNET_TESTBED_controller_disconnect (slave_list[id]->controller);
if (NULL != slave_list[id]->controller_proc)
GNUNET_TESTBED_controller_stop (slave_list[id]->controller_proc);
}
{
static const struct GNUNET_SERVER_MessageHandler message_handlers[] =
{
- {&handle_init, NULL, GNUNET_MESSAGE_TYPE_TESTBED_INIT,
- sizeof (struct GNUNET_TESTBED_InitMessage)},
+ {&handle_init, NULL, GNUNET_MESSAGE_TYPE_TESTBED_INIT, 0},
{&handle_add_host, NULL, GNUNET_MESSAGE_TYPE_TESTBED_ADDHOST, 0},
{&handle_configure_shared_service, NULL,
GNUNET_MESSAGE_TYPE_TESTBED_SERVICESHARE, 0},
*/
int main (int argc, char *const *argv)
{
+ //sleep (15); /* Debugging */
return
(GNUNET_OK ==
GNUNET_SERVICE_run (argc,
projects / oweals / gnunet.git / blobdiff