*/
struct GNUNET_SERVER_Client *client;
+ /**
+ * Handle for operations which are forwarded while linking controllers
+ */
+ struct ForwardedOperationContext *fopc;
+
/**
* The id of the operation which created this context
*/
*/
uint32_t other_peer_id;
- /**
- * Number of times we tried to send hello; used to increase delay in offering
- * hellos
- */
- uint16_t retries;
};
*/
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;
-
};
*/
struct ForwardedOperationContext
{
+ /**
+ * The next pointer for DLL
+ */
+ struct ForwardedOperationContext *next;
+
+ /**
+ * The prev pointer for DLL
+ */
+ struct ForwardedOperationContext *prev;
+
/**
* The generated operation context
*/
*/
uint64_t operation_id;
+ /**
+ * The type of the operation which is forwarded
+ */
+ enum OperationType type;
+
};
*/
static struct RequestOverlayConnectContext *roccq_tail;
+/**
+ * DLL head for forwarded operation contexts
+ */
+static struct ForwardedOperationContext *fopcq_head;
+
+/**
+ * DLL tail for forwarded operation contexts
+ */
+static struct ForwardedOperationContext *fopcq_tail;
+
/**
* Array of hosts
*/
/**
- * Callback to be called when forwarded link controllers operation is
- * successfull. We have to relay the reply msg back to the client
+ * Callback to relay the reply msg of a forwarded operation back to the client
*
* @param cls ForwardedOperationContext
- * @param msg the peer create success message
+ * @param msg the message to relay
*/
static void
forwarded_operation_reply_relay (void *cls,
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);
+ dup_msg = GNUNET_copy_message (msg);
queue_message (fopc->client, dup_msg);
GNUNET_SERVER_client_drop (fopc->client);
GNUNET_SCHEDULER_cancel (fopc->timeout_task);
+ GNUNET_CONTAINER_DLL_remove (fopcq_head, fopcq_tail, fopc);
GNUNET_free (fopc);
}
/**
- * Task to free resources when forwarded link controllers has been timedout
+ * Task to free resources when forwarded operation has been timedout
*
* @param cls the ForwardedOperationContext
* @param tc the task context from scheduler
LOG (GNUNET_ERROR_TYPE_WARNING, "A forwarded operation has timed out\n");
send_operation_fail_msg (fopc->client, fopc->operation_id, "Timeout");
GNUNET_SERVER_client_drop (fopc->client);
+ GNUNET_CONTAINER_DLL_remove (fopcq_head, fopcq_tail, fopc);
GNUNET_free (fopc);
}
+/**
+ * The Link Controller forwarding task
+ *
+ * @param cls the LCFContext
+ * @param tc the Task context from scheduler
+ */
+static void
+lcf_proc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
+
+
+/**
+ * Callback to be called when forwarded link controllers operation is
+ * successfull. We have to relay the reply msg back to the client
+ *
+ * @param cls the LCFContext
+ * @param msg the message to relay
+ */
+static void
+lcf_forwarded_operation_reply_relay (void *cls,
+ const struct GNUNET_MessageHeader *msg)
+{
+ struct LCFContext *lcf = cls;
+
+ GNUNET_assert (NULL != lcf->fopc);
+ forwarded_operation_reply_relay (lcf->fopc, msg);
+ lcf->fopc = NULL;
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
+}
+
+
+/**
+ * Task to free resources when forwarded link controllers has been timedout
+ *
+ * @param cls the LCFContext
+ * @param tc the task context from scheduler
+ */
+static void
+lcf_forwarded_operation_timeout (void *cls,
+ const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+ struct LCFContext *lcf = cls;
+
+ GNUNET_assert (NULL != lcf->fopc);
+ lcf->fopc->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+ forwarded_operation_timeout (lcf->fopc, tc);
+ lcf->fopc = NULL;
+ GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id);
+ lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
+}
+
+
/**
* The Link Controller forwarding task
*
{
struct LCFContext *lcf = cls;
struct LCFContextQueue *lcfq;
- struct ForwardedOperationContext *fopc;
lcf_proc_task_id = GNUNET_SCHEDULER_NO_TASK;
switch (lcf->state)
}
break;
case SLAVE_HOST_REGISTERED:
- fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
- fopc->client = lcf->client;
- fopc->operation_id = lcf->operation_id;
- fopc->opc =
+ lcf->fopc = GNUNET_malloc (sizeof (struct ForwardedOperationContext));
+ lcf->fopc->client = lcf->client;
+ lcf->fopc->operation_id = lcf->operation_id;
+ lcf->fopc->type = OP_LINK_CONTROLLERS;
+ lcf->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_forwarded_operation_reply_relay,
+ lcf);
+ lcf->fopc->timeout_task =
+ GNUNET_SCHEDULER_add_delayed (TIMEOUT, &lcf_forwarded_operation_timeout,
+ lcf);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, lcf->fopc);
lcf->state = FINISHED;
- lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
break;
case FINISHED:
lcfq = lcfq_head;
fopc->client = rhc->client;
fopc->operation_id = focc->operation_id;
fopc->cls = rhc;
+ fopc->type = OP_OVERLAY_CONNECT;
fopc->opc =
GNUNET_TESTBED_forward_operation_msg_ (rhc->gateway->controller,
focc->operation_id, focc->orig_msg,
fopc->timeout_task =
GNUNET_SCHEDULER_add_delayed (TIMEOUT, &forwarded_overlay_connect_timeout,
fopc);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
}
master_context->client = client;
master_context->host_id = ntohl (msg->host_id);
master_context->master_ip = GNUNET_strdup (controller_hostname);
- LOG_DEBUG ("Master Controller IP: %s\n", master_context->master_ip);
+ LOG_DEBUG ("Our IP: %s\n", master_context->master_ip);
master_context->system =
GNUNET_TESTING_system_create ("testbed", master_context->master_ip, hostname);
host =
peer_create_success_cb (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct ForwardedOperationContext *fopc = cls;
- struct GNUNET_MessageHeader *dup_msg;
struct Peer *remote_peer;
- GNUNET_SCHEDULER_cancel (fopc->timeout_task);
if (ntohs (msg->type) == GNUNET_MESSAGE_TYPE_TESTBED_PEERCREATESUCCESS)
{
GNUNET_assert (NULL != fopc->cls);
remote_peer = fopc->cls;
peer_list_add (remote_peer);
}
- dup_msg = GNUNET_copy_message (msg);
- queue_message (fopc->client, dup_msg);
- GNUNET_SERVER_client_drop (fopc->client);
- GNUNET_free (fopc);
+ forwarded_operation_reply_relay (fopc, msg);
}
/**
* Function to destroy a peer
*
- * @param the peer structure to destroy
+ * @param peer the peer structure to destroy
*/
static void
destroy_peer (struct Peer *peer)
peer_destroy_success_cb (void *cls, const struct GNUNET_MessageHeader *msg)
{
struct ForwardedOperationContext *fopc = cls;
- struct GNUNET_MessageHeader *dup_msg;
struct Peer *remote_peer;
- GNUNET_SCHEDULER_cancel (fopc->timeout_task);
if (GNUNET_MESSAGE_TYPE_TESTBED_GENERICOPSUCCESS == ntohs (msg->type))
{
remote_peer = fopc->cls;
if (0 == remote_peer->reference_cnt)
destroy_peer (remote_peer);
}
- dup_msg = GNUNET_copy_message (msg);
- queue_message (fopc->client, dup_msg);
- GNUNET_SERVER_client_drop (fopc->client);
- GNUNET_free (fopc);
+ forwarded_operation_reply_relay (fopc, msg);
}
fo_ctxt->client = client;
fo_ctxt->operation_id = GNUNET_ntohll (msg->operation_id);
fo_ctxt->cls = peer; //slave_list[route->dest]->controller;
+ fo_ctxt->type = OP_PEER_CREATE;
fo_ctxt->opc =
GNUNET_TESTBED_forward_operation_msg_ (slave_list [route->dest]->controller,
fo_ctxt->operation_id,
fo_ctxt->timeout_task =
GNUNET_SCHEDULER_add_delayed (TIMEOUT, &peer_create_forward_timeout,
fo_ctxt);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fo_ctxt);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
}
GNUNET_SERVER_client_keep (client);
fopc->client = client;
fopc->cls = peer;
+ fopc->type = OP_PEER_DESTROY;
fopc->operation_id = GNUNET_ntohll (msg->operation_id);
fopc->opc =
GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.slave->controller,
fopc->timeout_task =
GNUNET_SCHEDULER_add_delayed (TIMEOUT, &forwarded_operation_timeout,
fopc);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
GNUNET_SERVER_client_keep (client);
fopc->client = client;
fopc->operation_id = GNUNET_ntohll (msg->operation_id);
+ fopc->type = OP_PEER_START;
fopc->opc =
GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.slave->controller,
fopc->operation_id, &msg->header,
fopc->timeout_task =
GNUNET_SCHEDULER_add_delayed (TIMEOUT, &forwarded_operation_timeout,
fopc);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
GNUNET_SERVER_client_keep (client);
fopc->client = client;
fopc->operation_id = GNUNET_ntohll (msg->operation_id);
+ fopc->type = OP_PEER_STOP;
fopc->opc =
GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.slave->controller,
fopc->operation_id, &msg->header,
fopc->timeout_task =
GNUNET_SCHEDULER_add_delayed (TIMEOUT, &forwarded_operation_timeout,
fopc);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
GNUNET_SERVER_client_keep (client);
fopc->client = client;
fopc->operation_id = GNUNET_ntohll (msg->operation_id);
+ fopc->type = OP_PEER_INFO;
fopc->opc =
GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.slave->controller,
fopc->operation_id, &msg->header,
fopc);
fopc->timeout_task =
GNUNET_SCHEDULER_add_delayed (TIMEOUT, &forwarded_operation_timeout,
- fopc);
+ fopc);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
occ->send_hello_task =
GNUNET_SCHEDULER_add_delayed
(GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
- 100 * (pow (2, occ->retries++))),
+ 100 + GNUNET_CRYPTO_random_u32
+ (GNUNET_CRYPTO_QUALITY_WEAK, 500)),
&send_hello, occ);
}
GNUNET_free (other_peer_str);
/* rhc is now set to the existing one from the hash map by
reghost_match_iterator() */
/* if queue is empty then ignore creating focc and proceed with
- normal forwarding */
- if (NULL == rhc->focc_dll_head)
+ normal forwarding */
+ if (RHC_OL_CONNECT == rhc->state)
skip_focc = GNUNET_YES;
}
if (GNUNET_NO == skip_focc)
{
struct ForwardedOverlayConnectContext *focc;
- uint16_t msize;
- msize = sizeof (struct GNUNET_TESTBED_OverlayConnectMessage);
focc = GNUNET_malloc (sizeof (struct ForwardedOverlayConnectContext));
focc->peer1 = p1;
focc->peer2 = p2;
focc->peer2_host_id = peer2_host_id;
- focc->orig_msg = GNUNET_malloc (msize);
- (void) memcpy (focc->orig_msg, message, msize);
+ focc->orig_msg = GNUNET_copy_message (message);
focc->operation_id = operation_id;
GNUNET_CONTAINER_DLL_insert_tail (rhc->focc_dll_head,
rhc->focc_dll_tail,
GNUNET_SERVER_client_keep (client);
fopc->client = client;
fopc->operation_id = operation_id;
+ fopc->type = OP_OVERLAY_CONNECT;
fopc->opc =
GNUNET_TESTBED_forward_operation_msg_ (peer->details.remote.slave->controller,
operation_id, message,
fopc->timeout_task =
GNUNET_SCHEDULER_add_delayed (TIMEOUT, &forwarded_operation_timeout,
fopc);
+ GNUNET_CONTAINER_DLL_insert_tail (fopcq_head, fopcq_tail, fopc);
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
}
if ((peer2_host_id >= slave_list_size)
|| (NULL ==slave_list[peer2_host_id]))
{
- struct GNUNET_TESTBED_NeedControllerConfig *reply;
-
- LOG_DEBUG ("Need controller configuration for connecting peers %u and %u\n",
- p1, p2);
- 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);
+ LOG (GNUNET_ERROR_TYPE_WARNING,
+ "Configuration of peer2's controller missing for connecting peers"
+ "%u and %u\n", p1, p2);
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
return;
}
- else
+ peer2_controller = slave_list[peer2_host_id]->controller;
+ if (NULL == peer2_controller)
{
- //occ->peer2_controller = slave_list[peer2_host_id]->controller;
- peer2_controller = slave_list[peer2_host_id]->controller;
- if (NULL == peer2_controller)
- {
- GNUNET_break (0); /* What's going on? */
- GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
- return;
- }
+ GNUNET_break (0); /* What's going on? */
+ GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+ return;
}
}
else
rocc->attempt_connect_task_id =
GNUNET_SCHEDULER_add_delayed
(GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
- 100 * (pow (2, rocc->retries++))),
+ 100 + GNUNET_CRYPTO_random_u32
+ (GNUNET_CRYPTO_QUALITY_WEAK, 500)),
&attempt_connect_task, rocc);
}
op_id = GNUNET_ntohll (msg->operation_id);
if ((slave_list_size <= slave_id) || (NULL == slave_list[slave_id]))
{
+ /* FIXME: Add forwardings for this type of message here.. */
send_operation_fail_msg (client, op_id, "Slave not found");
GNUNET_SERVER_receive_done (client, GNUNET_OK);
return;
cleanup_focc (focc);
}
if (NULL != rhc->sub_op)
- GNUNET_TESTBED_operation_cancel (rhc->sub_op);
+ GNUNET_TESTBED_operation_done (rhc->sub_op);
if (NULL != rhc->client)
GNUNET_SERVER_client_drop (rhc->client);
GNUNET_free (value);
struct LCFContextQueue *lcfq;
struct OverlayConnectContext *occ;
struct RequestOverlayConnectContext *rocc;
+ struct ForwardedOperationContext *fopc;
uint32_t id;
shutdown_task_id = GNUNET_SCHEDULER_NO_TASK;
(void) GNUNET_CONTAINER_multihashmap_iterate (ss_map, &ss_map_free_iterator,
NULL);
GNUNET_CONTAINER_multihashmap_destroy (ss_map);
+ /* cleanup any remaining forwarded operations */
+ while (NULL != (fopc = fopcq_head))
+ {
+ GNUNET_CONTAINER_DLL_remove (fopcq_head, fopcq_tail, fopc);
+ GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc);
+ if (GNUNET_SCHEDULER_NO_TASK != fopc->timeout_task)
+ GNUNET_SCHEDULER_cancel (fopc->timeout_task);
+ GNUNET_SERVER_client_drop (fopc->client);
+ switch (fopc->type)
+ {
+ case OP_PEER_CREATE:
+ GNUNET_free (fopc->cls);
+ break;
+ case OP_PEER_START:
+ case OP_PEER_STOP:
+ case OP_PEER_DESTROY:
+ case OP_PEER_INFO:
+ case OP_OVERLAY_CONNECT:
+ case OP_LINK_CONTROLLERS:
+ case OP_GET_SLAVE_CONFIG:
+ break;
+ case OP_FORWARDED:
+ GNUNET_assert (0);
+ };
+ GNUNET_free (fopc);
+ }
if (NULL != lcfq_head)
{
if (GNUNET_SCHEDULER_NO_TASK != lcf_proc_task_id)
if (client == master_context->client)
{
LOG (GNUNET_ERROR_TYPE_DEBUG, "Master client disconnected\n");
- GNUNET_SERVER_client_drop (client);
/* should not be needed as we're terminated by failure to read
* from stdin, but if stdin fails for some reason, this shouldn't
* hurt for now --- might need to revise this later if we ever
projects / oweals / gnunet.git / blobdiff