* The TESTING system handle for starting peers locally
*/
struct GNUNET_TESTING_System *system;
-
+
/**
* Event mask of event to be responded in this context
*/
uint32_t dest;
/**
- * The host destination is reachable thru
+ * The destination host is reachable thru
*/
uint32_t thru;
};
+/**
+ * Context information used while linking controllers
+ */
+struct LinkControllersContext;
+
+
/**
* Structure representing a connected(directly-linked) controller
*/
*/
struct GNUNET_TESTBED_Controller *controller;
+ /**
+ * The configuration of the slave. Cannot be NULL
+ */
+ struct GNUNET_CONFIGURATION_Handle *cfg;
+
+ /**
+ * handle to lcc which is associated with this slave startup. Should be set to
+ * NULL when the slave has successfully started up
+ */
+ struct LinkControllersContext *lcc;
+
/**
* The id of the host this controller is running on
*/
/**
- * A locally started peer
+ * A peer
*/
struct Peer
{
*/
struct Peer *peer;
- /**
- * The other peer
- */
- struct Peer *other_peer;
-
/**
* Transport handle of the first peer to get its HELLO
*/
*/
char *emsg;
+ /**
+ * Operation context for suboperations
+ */
+ struct OperationContext *opc;
+
+ /**
+ * Controller of peer 2; NULL if the peer is local
+ */
+ struct GNUNET_TESTBED_Controller *peer2_controller;
+
/**
* The peer identity of the first peer
*/
*/
GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+ /**
+ * The id of peer A
+ */
+ uint32_t peer_id;
+
+ /**
+ * The id of peer B
+ */
+ uint32_t other_peer_id;
+
+ /**
+ * Number of times we tried to send hello; used to increase delay in offering
+ * hellos
+ */
+ uint16_t retries;
+};
+
+
+/**
+ * Context information for RequestOverlayConnect
+ * operations. RequestOverlayConnect is used when peers A, B reside on different
+ * hosts and the host controller for peer B is asked by the host controller of
+ * peer A to make peer B connect to peer A
+ */
+struct RequestOverlayConnectContext
+{
+ /**
+ * The transport handle of peer B
+ */
+ struct GNUNET_TRANSPORT_Handle *th;
+
+ /**
+ * Peer A's HELLO
+ */
+ struct GNUNET_MessageHeader *hello;
+
+ /**
+ * The peer identity of peer A
+ */
+ struct GNUNET_PeerIdentity a_id;
+
+ /**
+ * Task for offering HELLO of A to B and doing try_connect
+ */
+ GNUNET_SCHEDULER_TaskIdentifier attempt_connect_task_id;
+
+ /**
+ * Task to timeout RequestOverlayConnect
+ */
+ GNUNET_SCHEDULER_TaskIdentifier timeout_rocc_task_id;
+
+ /**
+ * Number of times we tried to send hello; used to increase delay in offering
+ * hellos
+ */
+ uint16_t retries;
+
};
*/
uint64_t operation_id;
- /**
- * Pointer to the slave handle if we are directly starting/connecting to the controller
- */
- struct Slave *slave;
};
*/
static struct Context *master_context;
+/**
+ * Our hostname; we give this to all the peers we start
+ */
+static char *hostname;
+
/***********/
/* Handles */
/***********/
static struct Slave **slave_list;
/**
- * A list of peers we own locally
+ * A list of peers we know about
*/
static struct Peer **peer_list;
{
ptr = GNUNET_realloc (ptr, new_size);
if (new_size > size)
- ptr = memset (ptr + size, 0, new_size - size);
+ (void) memset (ptr + size, 0, new_size - size);
return ptr;
}
host_list_add (struct GNUNET_TESTBED_Host *host)
{
uint32_t host_id;
+ uint32_t orig_size;
host_id = GNUNET_TESTBED_host_get_id_ (host);
+ orig_size = host_list_size;
if (host_list_size <= host_id)
{
+ while (host_list_size <= host_id)
+ host_list_size += LIST_GROW_STEP;
host_list =
TESTBED_realloc (host_list,
- sizeof (struct GNUNET_TESTBED_Host *) * host_list_size,
- sizeof (struct GNUNET_TESTBED_Host *) *
- (host_list_size + LIST_GROW_STEP));
- host_list_size += LIST_GROW_STEP;
+ sizeof (struct GNUNET_TESTBED_Host *) * orig_size,
+ sizeof (struct GNUNET_TESTBED_Host *)
+ * host_list_size);
}
if (NULL != host_list[host_id])
{
static void
route_list_add (struct Route *route)
{
+ uint32_t orig_size;
+
+ orig_size = route_list_size;
if (route->dest >= route_list_size)
{
+ while (route->dest >= route_list_size)
+ route_list_size += LIST_GROW_STEP;
route_list =
- TESTBED_realloc (route_list, sizeof (struct Route *) * route_list_size,
- sizeof (struct Route *) * (route_list_size +
- LIST_GROW_STEP));
- route_list_size += LIST_GROW_STEP;
+ TESTBED_realloc (route_list,
+ sizeof (struct Route *) * orig_size,
+ sizeof (struct Route *) * route_list_size);
}
GNUNET_assert (NULL == route_list[route->dest]);
route_list[route->dest] = route;
peer_list =
TESTBED_realloc (peer_list, sizeof (struct Peer *) * orig_size,
sizeof (struct Peer *) * peer_list_size);
- }
+ }
GNUNET_assert (NULL == peer_list[peer->id]);
peer_list[peer->id] = peer;
}
uint16_t msize;
msize = ntohs (msg->size);
+ LOG_DEBUG ("Relaying message with type: %u, size: %u\n", ntohs (msg->type),
+ msize);
dup_msg = GNUNET_malloc (msize);
(void) memcpy (dup_msg, msg, msize);
queue_message (fopc->client, dup_msg);
/**
* Callback to signal successfull startup of the controller process
*
- * @param cls the closure from GNUNET_TESTBED_controller_start()
+ * @param cls the handle to the slave whose status is to be found here
* @param cfg the configuration with which the controller has been started;
* NULL if status is not GNUNET_OK
* @param status GNUNET_OK if the startup is successfull; GNUNET_SYSERR if not,
slave_status_callback (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg,
int status)
{
- struct LinkControllersContext *lcc = cls;
+ struct Slave *slave = cls;
+ struct LinkControllersContext *lcc;
+ lcc = slave->lcc;
if (GNUNET_SYSERR == status)
{
- lcc->slave->controller_proc = NULL;
+ slave->controller_proc = NULL;
+ slave_list[slave->host_id] = NULL;
+ if (NULL != slave->cfg)
+ GNUNET_CONFIGURATION_destroy (slave->cfg);
+ GNUNET_free (slave);
+ slave = NULL;
LOG (GNUNET_ERROR_TYPE_WARNING, "Unexpected slave shutdown\n");
GNUNET_SCHEDULER_shutdown (); /* We too shutdown */
- return;
+ goto clean_lcc;
}
- lcc->slave->controller =
- GNUNET_TESTBED_controller_connect (cfg, host_list[lcc->slave->host_id],
+ slave->controller =
+ GNUNET_TESTBED_controller_connect (cfg, host_list[slave->host_id],
master_context->event_mask,
- &slave_event_callback, lcc->slave);
- if (NULL != lcc->slave->controller)
+ &slave_event_callback, slave);
+ if (NULL != slave->controller)
+ {
send_operation_success_msg (lcc->client, lcc->operation_id);
+ slave->cfg = GNUNET_CONFIGURATION_dup (cfg);
+ }
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);
+ GNUNET_TESTBED_controller_stop (slave->controller_proc);
+ slave_list[slave->host_id] = NULL;
+ GNUNET_free (slave);
+ slave = NULL;
+ }
+
+ clean_lcc:
+ if (NULL != lcc)
+ {
+ if (NULL != lcc->client)
+ {
+ GNUNET_SERVER_receive_done (lcc->client, GNUNET_OK);
+ GNUNET_SERVER_client_drop (lcc->client);
+ lcc->client = NULL;
+ }
+ GNUNET_free (lcc);
+ }
+ if (NULL != slave)
+ slave->lcc = NULL;
}
if (NULL != master_context)
{
- GNUNET_break (0);
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ LOG_DEBUG ("We are being connected to laterally\n");
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
msg = (const struct GNUNET_TESTBED_InitMessage *) message;
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);
+ GNUNET_TESTING_system_create ("testbed", master_context->master_ip, hostname);
host =
GNUNET_TESTBED_host_create_with_id (master_context->host_id, NULL, NULL,
0);
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);
+ LOG_DEBUG ("-------hostname: %s\n", hostname);
if (0 != username_length)
LOG_DEBUG ("-------username: %s\n", username);
else
if ((delegated_host_id >= host_list_size) ||
(NULL == host_list[delegated_host_id]))
{
- LOG (GNUNET_ERROR_TYPE_WARNING, "Delegated host not registered with us\n");
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Delegated host %u not registered with us\n", delegated_host_id);
GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
GNUNET_TESTBED_controller_connect (cfg, host_list[slave->host_id],
master_context->event_mask,
&slave_event_callback, slave);
- GNUNET_CONFIGURATION_destroy (cfg);
+ slave->cfg = cfg;
if (NULL != slave->controller)
send_operation_success_msg (client, GNUNET_ntohll (msg->operation_id));
else
lcc->operation_id = GNUNET_ntohll (msg->operation_id);
GNUNET_SERVER_client_keep (client);
lcc->client = client;
- lcc->slave = slave;
+ slave->lcc = lcc;
slave->controller_proc =
GNUNET_TESTBED_controller_start (master_context->master_ip,
host_list[slave->host_id], cfg,
- &slave_status_callback, lcc);
+ &slave_status_callback, slave);
GNUNET_CONFIGURATION_destroy (cfg);
new_route = GNUNET_malloc (sizeof (struct Route));
new_route->dest = delegated_host_id;
new_route->thru = master_context->host_id;
route_list_add (new_route);
- GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
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);
+ if (1 != msg->is_subordinate)
+ {
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ if ((delegated_host_id < route_list_size)
+ && (NULL != route_list[delegated_host_id]))
+ {
+ GNUNET_break_op (0); /* Are you trying to link delegated host twice
+ with is subordinate flag set to GNUNET_YES? */
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
new_route = GNUNET_malloc (sizeof (struct Route));
new_route->dest = delegated_host_id;
new_route->thru = route->dest;
route_list_add (new_route);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
peer = peer_list[peer_id];
if (GNUNET_YES == peer->is_remote)
{
- /* FIXME: forward to sub controller */
- GNUNET_break (0);
+ struct ForwardedOperationContext *fopc;
+
+ 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;
}
LOG_DEBUG ("Cleaning up occ\n");
GNUNET_free_non_null (occ->emsg);
GNUNET_free_non_null (occ->hello);
+ GNUNET_SERVER_client_drop (occ->client);
+ if (NULL != occ->opc)
+ GNUNET_TESTBED_forward_operation_msg_cancel_ (occ->opc);
if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task)
GNUNET_SCHEDULER_cancel (occ->send_hello_task);
if (NULL != occ->ch)
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);
}
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->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);
}
if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
return;
GNUNET_assert (NULL != occ->hello);
- if (GNUNET_YES == occ->other_peer->is_remote)
+ other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
+ if (NULL != occ->peer2_controller)
{
struct GNUNET_TESTBED_RequestConnectMessage *msg;
uint16_t msize;
uint16_t hello_size;
+ LOG_DEBUG ("Offering HELLO of %s to %s via Remote Overlay Request\n",
+ GNUNET_i2s (&occ->peer_identity), other_peer_str);
hello_size = ntohs (occ->hello->size);
msize = sizeof (struct GNUNET_TESTBED_RequestConnectMessage) + hello_size;
msg = GNUNET_malloc (msize);
msg->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT);
msg->header.size = htons (msize);
- msg->peer = htonl (occ->peer->id);
+ msg->peer = htonl (occ->other_peer_id);
msg->operation_id = GNUNET_htonll (occ->op_id);
(void) memcpy (&msg->peer_identity, &occ->peer_identity,
sizeof (struct GNUNET_PeerIdentity));
memcpy (msg->hello, occ->hello, hello_size);
- GNUNET_TESTBED_queue_message_ (occ->other_peer->details.remote.controller,
- &msg->header);
+ GNUNET_TESTBED_queue_message_ (occ->peer2_controller, &msg->header);
}
else
{
- other_peer_str = GNUNET_strdup (GNUNET_i2s (&occ->other_peer_identity));
LOG_DEBUG ("Offering HELLO of %s to %s\n",
GNUNET_i2s (&occ->peer_identity), other_peer_str);
- GNUNET_free (other_peer_str);
GNUNET_TRANSPORT_offer_hello (occ->p2th, occ->hello, NULL, NULL);
GNUNET_TRANSPORT_try_connect (occ->p2th, &occ->peer_identity);
+ occ->send_hello_task =
+ GNUNET_SCHEDULER_add_delayed
+ (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+ 100 * (pow (2, occ->retries++))),
+ &send_hello, occ);
}
- occ->send_hello_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &send_hello, occ);
+ GNUNET_free (other_peer_str);
}
/**
/**
- * Function called whenever there is an update to the
- * HELLO of peers in the OverlayConnectClosure
+ * Function called whenever there is an update to the HELLO of peers in the
+ * OverlayConnectClosure. If we have a valid HELLO, we connect to the peer 2's
+ * transport and offer peer 1's HELLO and ask peer 2 to connect to peer 1
*
* @param cls closure
* @param hello our updated HELLO
GNUNET_TRANSPORT_disconnect (occ->p1th);
occ->p1th = NULL;
GNUNET_free_non_null (occ->emsg);
- if (GNUNET_NO == occ->other_peer->is_remote)
+ if (NULL == occ->peer2_controller)
{
occ->p2th =
- GNUNET_TRANSPORT_connect (occ->other_peer->details.local.cfg,
+ GNUNET_TRANSPORT_connect (peer_list[occ->other_peer_id]->details.local.cfg,
&occ->other_peer_identity, NULL, NULL, NULL,
NULL);
if (NULL == occ->p2th)
{
- occ->emsg = GNUNET_strdup ("Cannot connect to TRANSPORT of peer B");
+ GNUNET_asprintf (&occ->emsg, "Cannot connect to TRANSPORT of %s\n",
+ GNUNET_i2s (&occ->other_peer_identity));
GNUNET_SCHEDULER_cancel (occ->timeout_task);
occ->timeout_task = GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
return;
if ((NULL == server) || (NULL == my_identity))
goto error_return;
GNUNET_free (occ->emsg);
+ occ->ch = server;
occ->emsg = NULL;
memcpy (&occ->peer_identity, my_identity,
sizeof (struct GNUNET_PeerIdentity));
}
+/**
+ * Callback to be called when forwarded get peer config operation as part of
+ * overlay connect is successfull. Connection to Peer 1's core is made and is
+ * checked for new connection from peer 2
+ *
+ * @param cls ForwardedOperationContext
+ * @param msg the peer create success message
+ */
+static void
+overlay_connect_get_config (void *cls, const struct GNUNET_MessageHeader *msg)
+{
+ struct OverlayConnectContext *occ = cls;
+ const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *cmsg;
+ const struct GNUNET_CORE_MessageHandler no_handlers[] = {
+ {NULL, 0, 0}
+ };
+
+ occ->opc = NULL;
+ if (GNUNET_MESSAGE_TYPE_TESTBED_PEERCONFIG != ntohs (msg->type))
+ goto error_return;
+ cmsg = (const struct GNUNET_TESTBED_PeerConfigurationInformationMessage *)
+ msg;
+ memcpy (&occ->other_peer_identity, &cmsg->peer_identity,
+ sizeof (struct GNUNET_PeerIdentity));
+ GNUNET_free_non_null (occ->emsg);
+ 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);
+ if (NULL == occ->ch)
+ goto error_return;
+ return;
+
+ error_return:
+ GNUNET_SCHEDULER_cancel (occ->timeout_task);
+ occ->timeout_task =
+ GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
+}
+
+
/**
* Handler for GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT messages
*
const struct GNUNET_CORE_MessageHandler no_handlers[] = {
{NULL, 0, 0}
};
+ struct Peer *peer;
+ uint64_t operation_id;
uint32_t p1;
uint32_t p2;
p2 = ntohl (msg->peer2);
GNUNET_assert (p1 < peer_list_size);
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 */
- GNUNET_assert (GNUNET_NO == peer_list[p1]->is_remote);
+ peer = peer_list[p1];
+ operation_id = GNUNET_ntohll (msg->operation_id);
+ if (GNUNET_YES == peer->is_remote)
+ {
+ struct ForwardedOperationContext *fopc;
+
+ fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ GNUNET_SERVER_client_keep (client);
+ fopc->client = client;
+ fopc->operation_id = operation_id;
+ LOG_DEBUG ("Forwarding overlay connect\n");
+ fopc->opc =
+ GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.controller,
+ operation_id, message,
+ &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;
+ }
occ = GNUNET_malloc (sizeof (struct OverlayConnectContext));
GNUNET_SERVER_client_keep (client);
occ->client = client;
+ occ->peer_id = p1;
+ occ->other_peer_id = p2;
occ->peer = peer_list[p1];
- occ->other_peer = peer_list[p2];
- occ->op_id = GNUNET_ntohll (msg->operation_id);
- /* Get the identity of the second peer */
- GNUNET_TESTING_peer_get_identity (occ->other_peer->details.local.peer,
+ occ->op_id = GNUNET_ntohll (msg->operation_id);
+ if ((p2 >= peer_list_size) || (NULL == peer_list[p2]))
+ {
+ uint32_t peer2_host_id;
+
+ peer2_host_id = ntohl (msg->peer2_host_id);
+ if ((peer2_host_id >= slave_list_size)
+ || (NULL ==slave_list[peer2_host_id]))
+ {
+ struct GNUNET_TESTBED_NeedControllerConfig *reply;
+
+ GNUNET_free (occ);
+ reply = GNUNET_malloc (sizeof (struct
+ GNUNET_TESTBED_NeedControllerConfig));
+ reply->header.size = htons (sizeof (struct
+ GNUNET_TESTBED_NeedControllerConfig));
+ reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_NEEDCONTROLLERCONFIG);
+ reply->controller_host_id = msg->peer2_host_id;
+ reply->operation_id = msg->operation_id;
+ queue_message (client, &reply->header);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ else
+ {
+ occ->peer2_controller = slave_list[peer2_host_id]->controller;
+ if (NULL == occ->peer2_controller)
+ {
+ GNUNET_break (0); /* What's going on? */
+ GNUNET_SERVER_client_drop (client);
+ GNUNET_free (occ);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ }
+ }
+ else
+ {
+ if (GNUNET_YES == peer_list[occ->other_peer_id]->is_remote)
+ occ->peer2_controller = peer_list[occ->other_peer_id]->details.remote.controller;
+ }
+ /* Get the identity of the second peer */
+ if (NULL != occ->peer2_controller)
+ {
+ struct GNUNET_TESTBED_PeerGetConfigurationMessage cmsg;
+
+ cmsg.header.size =
+ htons (sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage));
+ cmsg.header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_GETPEERCONFIG);
+ cmsg.peer_id = msg->peer2;
+ cmsg.operation_id = msg->operation_id;
+ occ->opc =
+ GNUNET_TESTBED_forward_operation_msg_ (occ->peer2_controller,
+ occ->op_id, &cmsg.header,
+ &overlay_connect_get_config,
+ occ);
+ occ->emsg =
+ GNUNET_strdup ("Timeout while getting peer identity of peer B\n");
+ occ->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 30),
+ &timeout_overlay_connect, occ);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ GNUNET_TESTING_peer_get_identity (peer_list[occ->other_peer_id]->details.local.peer,
&occ->other_peer_identity);
/* Connect to the core of 1st peer and wait for the 2nd peer to connect */
occ->emsg = GNUNET_strdup ("Timeout while connecting to CORE");
GNUNET_SCHEDULER_add_now (&timeout_overlay_connect, occ);
else
occ->timeout_task =
- GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
- (GNUNET_TIME_UNIT_SECONDS, 30),
- &timeout_overlay_connect, occ);
+ GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+ (GNUNET_TIME_UNIT_SECONDS, 30),
+ &timeout_overlay_connect, occ);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+
+/**
+ * Function to cleanup RequestOverlayConnectContext and any associated tasks
+ * with it
+ *
+ * @param rocc the RequestOverlayConnectContext
+ */
+static void
+cleanup_rocc (struct RequestOverlayConnectContext *rocc)
+{
+ if (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id)
+ GNUNET_SCHEDULER_cancel (rocc->attempt_connect_task_id);
+ if (GNUNET_SCHEDULER_NO_TASK != rocc->timeout_rocc_task_id)
+ GNUNET_SCHEDULER_cancel (rocc->timeout_rocc_task_id);
+ GNUNET_TRANSPORT_disconnect (rocc->th);
+ GNUNET_free_non_null (rocc->hello);
+ GNUNET_free (rocc);
+}
+
+
+/**
+ * Task to timeout rocc and cleanit up
+ *
+ * @param cls the RequestOverlayConnectContext
+ * @param tc the TaskContext from scheduler
+ */
+static void
+timeout_rocc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct RequestOverlayConnectContext *rocc = cls;
+
+ rocc->timeout_rocc_task_id = GNUNET_SCHEDULER_NO_TASK;
+ cleanup_rocc (rocc);
+}
+
+
+/**
+ * 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
+transport_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer,
+ const struct GNUNET_ATS_Information * ats,
+ uint32_t ats_count)
+{
+ struct RequestOverlayConnectContext *rocc = cls;
+
+ LOG_DEBUG ("Request Overlay connect notify\n");
+ if (0 != memcmp (new_peer, &rocc->a_id, sizeof (struct GNUNET_PeerIdentity)))
+ return;
+ LOG_DEBUG ("Peer %4s connected\n", GNUNET_i2s (&rocc->a_id));
+ cleanup_rocc (rocc);
+}
+
+
+/**
+ * Task to offer the HELLO message to the peer and ask it to connect to the peer
+ * whose identity is in RequestOverlayConnectContext
+ *
+ * @param cls the RequestOverlayConnectContext
+ * @param tc the TaskContext from scheduler
+ */
+static void
+attempt_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct RequestOverlayConnectContext *rocc = cls;
+
+ rocc->attempt_connect_task_id = GNUNET_SCHEDULER_NO_TASK;
+ GNUNET_TRANSPORT_offer_hello (rocc->th, rocc->hello, NULL, NULL);
+ GNUNET_TRANSPORT_try_connect (rocc->th, &rocc->a_id);
+ rocc->attempt_connect_task_id =
+ GNUNET_SCHEDULER_add_delayed
+ (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+ 100 * (pow (2, rocc->retries++))),
+ &attempt_connect_task, rocc);
+}
+
+
+/**
+ * Handler for GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT messages
+ *
+ * @param cls NULL
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_overlay_request_connect (void *cls, struct GNUNET_SERVER_Client *client,
+ const struct GNUNET_MessageHeader *message)
+{
+ const struct GNUNET_TESTBED_RequestConnectMessage *msg;
+ struct RequestOverlayConnectContext *rocc;
+ struct Peer *peer;
+ uint32_t peer_id;
+ uint16_t msize;
+ uint16_t hsize;
+
+ msize = ntohs (message->size);
+ if (sizeof (struct GNUNET_TESTBED_RequestConnectMessage) >= msize)
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ msg = (const struct GNUNET_TESTBED_RequestConnectMessage *) message;
+ if ((NULL == msg->hello) ||
+ (GNUNET_MESSAGE_TYPE_HELLO != ntohs (msg->hello->type)))
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ hsize = ntohs (msg->hello->size);
+ if ((sizeof (struct GNUNET_TESTBED_RequestConnectMessage) + hsize) != msize)
+ {
+ GNUNET_break (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ peer_id = ntohl (msg->peer);
+ if ((peer_id >= peer_list_size) || (NULL == (peer = peer_list[peer_id])))
+ {
+ GNUNET_break_op (0);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ if (GNUNET_YES == peer->is_remote)
+ {
+ struct GNUNET_MessageHeader *msg2;
+
+ msg2 = GNUNET_malloc (msize);
+ (void) memcpy (msg2, message, msize);
+ GNUNET_TESTBED_queue_message_ (peer->details.remote.controller, msg2);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ rocc = GNUNET_malloc (sizeof (struct RequestOverlayConnectContext));
+ rocc->th = GNUNET_TRANSPORT_connect (peer->details.local.cfg, NULL, rocc,
+ NULL, &transport_connect_notify, NULL);
+ if (NULL == rocc->th)
+ {
+ GNUNET_break (0);
+ GNUNET_free (rocc);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
+ }
+ memcpy (&rocc->a_id, &msg->peer_identity,
+ sizeof (struct GNUNET_PeerIdentity));
+ rocc->hello = GNUNET_malloc (hsize);
+ memcpy (rocc->hello, msg->hello, hsize);
+ rocc->attempt_connect_task_id =
+ GNUNET_SCHEDULER_add_now (&attempt_connect_task, rocc);
+ rocc->timeout_rocc_task_id =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT, &timeout_rocc_task, rocc);
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+
+/**
+ * Handler for GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG messages
+ *
+ * @param cls NULL
+ * @param client identification of the client
+ * @param message the actual message
+ */
+static void
+handle_slave_get_config (void *cls, struct GNUNET_SERVER_Client *client,
+ const struct GNUNET_MessageHeader *message)
+{
+ struct GNUNET_TESTBED_SlaveGetConfigurationMessage *msg;
+ struct Slave *slave;
+ struct GNUNET_TESTBED_SlaveConfiguration *reply;
+ char *config;
+ char *xconfig;
+ size_t config_size;
+ size_t xconfig_size;
+ size_t reply_size;
+ uint64_t op_id;
+ uint32_t slave_id;
+
+ msg = (struct GNUNET_TESTBED_SlaveGetConfigurationMessage *) message;
+ slave_id = ntohl (msg->slave_id);
+ op_id = GNUNET_ntohll (msg->operation_id);
+ if ((slave_list_size <= slave_id) || (NULL == slave_list[slave_id]))
+ {
+ send_operation_fail_msg (client, op_id, "Slave not found");
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ slave = slave_list[slave_id];
+ if (NULL == slave->cfg)
+ {
+ send_operation_fail_msg (client, op_id,
+ "Configuration not found (slave not started by me)");
+ GNUNET_SERVER_receive_done (client, GNUNET_OK);
+ return;
+ }
+ config = GNUNET_CONFIGURATION_serialize (slave->cfg, &config_size);
+ xconfig_size = GNUNET_TESTBED_compress_config_ (config, config_size,
+ &xconfig);
+ GNUNET_free (config);
+ reply_size = xconfig_size + sizeof (struct GNUNET_TESTBED_SlaveConfiguration);
+ GNUNET_break (reply_size <= UINT16_MAX);
+ GNUNET_break (config_size <= UINT16_MAX);
+ reply = GNUNET_realloc (xconfig, reply_size);
+ (void) memmove (&reply[1], reply, xconfig_size);
+ reply->header.type = htons (GNUNET_MESSAGE_TYPE_TESTBED_SLAVECONFIG);
+ reply->header.size = htons ((uint16_t) reply_size);
+ reply->slave_id = msg->slave_id;
+ reply->operation_id = msg->operation_id;
+ reply->config_size = htons ((uint16_t) config_size);
+ queue_message (client, &reply->header);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
for (id = 0; id < slave_list_size; id++)
if (NULL != slave_list[id])
{
+ if (NULL != slave_list[id]->cfg)
+ GNUNET_CONFIGURATION_destroy (slave_list[id]->cfg);
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);
+ GNUNET_free (slave_list[id]);
}
+ GNUNET_free_non_null (slave_list);
if (NULL != master_context)
{
GNUNET_free_non_null (master_context->master_ip);
GNUNET_free (master_context);
master_context = NULL;
}
+ GNUNET_free_non_null (hostname);
}
sizeof (struct GNUNET_TESTBED_PeerGetConfigurationMessage)},
{&handle_overlay_connect, NULL, GNUNET_MESSAGE_TYPE_TESTBED_OLCONNECT,
sizeof (struct GNUNET_TESTBED_OverlayConnectMessage)},
+ {&handle_overlay_request_connect, NULL, GNUNET_MESSAGE_TYPE_TESTBED_REQUESTCONNECT,
+ 0},
+ {handle_slave_get_config, NULL, GNUNET_MESSAGE_TYPE_TESTBED_GETSLAVECONFIG,
+ sizeof (struct GNUNET_TESTBED_SlaveGetConfigurationMessage)},
{NULL}
};
+ GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string
+ (cfg, "testbed", "HOSTNAME", &hostname));
GNUNET_SERVER_add_handlers (server, message_handlers);
GNUNET_SERVER_disconnect_notify (server, &client_disconnect_cb, NULL);
- ss_map = GNUNET_CONTAINER_multihashmap_create (5);
+ ss_map = GNUNET_CONTAINER_multihashmap_create (5, GNUNET_NO);
shutdown_task_id =
GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
&shutdown_task, NULL);
projects / oweals / gnunet.git / blobdiff