new unified communication mechanism

4 files changed, 221 insertions, 114 deletions

diff --git a/src/experimentation/gnunet-daemon-experimentation.h b/src/experimentation/gnunet-daemon-experimentation.h
index 61dfd1b26..73499301a 100644
--- a/src/experimentation/gnunet-daemon-experimentation.h
+++ b/src/experimentation/gnunet-daemon-experimentation.h
@@ -166,8 +166,8 @@ struct Node
          */
         struct GNUNET_PeerIdentity *issuer_id;
 
-        struct ExperimentStartCtx *e_req_head;
-        struct ExperimentStartCtx *e_req_tail;
+        struct NodeComCtx *e_req_head;
+        struct NodeComCtx *e_req_tail;
 };
 
 struct Experimentation_Issuer
@@ -273,6 +273,13 @@ GED_nodes_rts (struct Node *n);
 int
 GED_nodes_request_start (struct Node *n, struct Experiment *e);
 
+/**
+ * Confirm a experiment START with a node
+ *
+ * @return GNUNET_NO if core was busy with sending, GNUNET_OK otherwise
+ */
+int
+GED_nodes_send_start_ack (struct Node *n, struct Experiment *e);
 
 /**
  * Start the nodes management
diff --git a/src/experimentation/gnunet-daemon-experimentation_nodes.c b/src/experimentation/gnunet-daemon-experimentation_nodes.c
index fca7e001c..8c3063ac9 100644
--- a/src/experimentation/gnunet-daemon-experimentation_nodes.c
+++ b/src/experimentation/gnunet-daemon-experimentation_nodes.c
@@ -63,6 +63,19 @@ struct GNUNET_CONTAINER_MultiHashMap *nodes_active;
  */
 struct GNUNET_CONTAINER_MultiHashMap *nodes_inactive;
 
+struct NodeComCtx
+{
+        struct NodeComCtx *prev;
+        struct NodeComCtx *next;
+
+        struct Node *n;
+        struct Experiment *e;
+
+        size_t size;
+        GNUNET_CONNECTION_TransmitReadyNotify notify;
+        void *notify_cls;
+};
+
 
 /**
  * Update statistics
@@ -96,7 +109,7 @@ static void update_stats (struct GNUNET_CONTAINER_MultiHashMap *m)
 
 
 /**
- * Clean up nodes
+ * Clean up node
  *
  * @param cls the hashmap to clean up
  * @param key key of the current node
@@ -104,11 +117,13 @@ static void update_stats (struct GNUNET_CONTAINER_MultiHashMap *m)
  * @return always GNUNET_OK
  */
 static int
-cleanup_nodes (void *cls,
+cleanup_node (void *cls,
                                                          const struct GNUNET_HashCode * key,
                                                          void *value)
 {
         struct Node *n;
+        struct NodeComCtx *e_cur;
+        struct NodeComCtx *e_next;
         struct GNUNET_CONTAINER_MultiHashMap *cur = cls;
 
         n = value;
@@ -117,11 +132,20 @@ cleanup_nodes (void *cls,
                 GNUNET_SCHEDULER_cancel (n->timeout_task);
                 n->timeout_task = GNUNET_SCHEDULER_NO_TASK;
         }
+
         if (NULL != n->cth)
         {
                 GNUNET_CORE_notify_transmit_ready_cancel (n->cth);
                 n->cth = NULL;
         }
+        e_next = n->e_req_head;
+        while (NULL != (e_cur = e_next))
+        {
+                e_next = e_cur->next;
+                GNUNET_CONTAINER_DLL_remove (n->e_req_head, n->e_req_tail, e_cur);
+                GNUNET_free (e_cur);
+        }
+
         GNUNET_free_non_null (n->issuer_id);
 
         GNUNET_CONTAINER_multihashmap_remove (cur, key, value);
@@ -159,6 +183,47 @@ core_startup_handler (void *cls,
         me = *my_identity;
 }
 
+void
+schedule_transmisson (struct NodeComCtx *e_ctx);
+
+size_t
+transmit_read_wrapper (void *cls, size_t bufsize, void *buf)
+{
+        struct NodeComCtx *e_ctx = cls;
+        struct NodeComCtx *next = NULL;
+
+        size_t res = e_ctx->notify (e_ctx->notify_cls, bufsize, buf);
+        e_ctx->n->cth = NULL;
+
+        GNUNET_CONTAINER_DLL_remove (e_ctx->n->e_req_head, e_ctx->n->e_req_tail, e_ctx);
+        next = e_ctx->n->e_req_head;
+        GNUNET_free (e_ctx);
+
+        if (NULL != next)
+        {
+                /* Schedule next message */
+                schedule_transmisson (next);
+        }
+        return res;
+}
+
+void
+schedule_transmisson (struct NodeComCtx *e_ctx)
+{
+        if (NULL != e_ctx->n->cth)
+                return;
+
+        e_ctx->n->cth = GNUNET_CORE_notify_transmit_ready (ch, GNUNET_NO, 0, FAST_TIMEOUT,
+                        &e_ctx->n->id, e_ctx->size, transmit_read_wrapper, e_ctx);
+        if (NULL == e_ctx->n->cth)
+        {
+                GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Cannot send message to peer `%s' for experiment `%s'\n"),
+                                GNUNET_i2s(&e_ctx->n->id), e_ctx->e->name);
+                GNUNET_free (e_ctx);
+        }
+
+}
+
 
 /**
  * Remove experimentation request due to timeout
@@ -242,6 +307,7 @@ size_t send_experimentation_request_cb (void *cls, size_t bufsize, void *buf)
 static void send_experimentation_request (const struct GNUNET_PeerIdentity *peer)
 {
         struct Node *n;
+        struct NodeComCtx *e_ctx;
         size_t size;
         size_t c_issuers;
 
@@ -253,9 +319,15 @@ static void send_experimentation_request (const struct GNUNET_PeerIdentity *peer
         n->id = *peer;
         n->timeout_task = GNUNET_SCHEDULER_add_delayed (EXP_RESPONSE_TIMEOUT, &remove_request, n);
         n->capabilities = NONE;
-        n->cth = GNUNET_CORE_notify_transmit_ready(ch, GNUNET_NO, 0,
-                                                                GNUNET_TIME_relative_get_forever_(),
-                                                                peer, size, send_experimentation_request_cb, n);
+
+        e_ctx = GNUNET_malloc (sizeof (struct NodeComCtx));
+        e_ctx->n = n;
+        e_ctx->e = NULL;
+        e_ctx->size = size;
+        e_ctx->notify = &send_experimentation_request_cb;
+        e_ctx->notify_cls = n;
+        GNUNET_CONTAINER_DLL_insert_tail(n->e_req_head, n->e_req_tail, e_ctx);
+        schedule_transmisson (e_ctx);
 
         GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_multihashmap_put (nodes_requested,
                         &peer->hashPubKey, n, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST));
@@ -362,7 +434,7 @@ static void node_make_active (struct Node *n)
         update_stats (nodes_active);
         GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Added peer `%s' as active node\n"),
                         GNUNET_i2s (&n->id));
-
+return;
         /* Request experiments for this node to start them */
         for (c1 = 0; c1 < n->issuer_count; c1++)
         {
@@ -382,6 +454,7 @@ static void handle_request (const struct GNUNET_PeerIdentity *peer,
                                                                                                                 const struct GNUNET_MessageHeader *message)
 {
         struct Node *n;
+        struct NodeComCtx *e_ctx;
         struct Experimentation_Request *rm = (struct Experimentation_Request *) message;
         struct Experimentation_Issuer *rmi = (struct Experimentation_Issuer *) &rm[1];
         int c1;
@@ -467,12 +540,15 @@ static void handle_request (const struct GNUNET_PeerIdentity *peer,
                 node_make_active (n);
 
         /* Send response */
-        n->cth = GNUNET_CORE_notify_transmit_ready (ch, GNUNET_NO, 0,
-                                                                GNUNET_TIME_relative_get_forever_(),
-                                                                peer,
-                                                                sizeof (struct Experimentation_Response) +
-                                                                GSE_my_issuer_count * sizeof (struct Experimentation_Issuer),
-                                                                send_response_cb, n);
+        e_ctx = GNUNET_malloc (sizeof (struct NodeComCtx));
+        e_ctx->n = n;
+        e_ctx->e = NULL;
+        e_ctx->size = sizeof (struct Experimentation_Response) + GSE_my_issuer_count * sizeof (struct Experimentation_Issuer);
+        e_ctx->notify = &send_response_cb;
+        e_ctx->notify_cls = n;
+
+        GNUNET_CONTAINER_DLL_insert_tail(n->e_req_head, n->e_req_tail, e_ctx);
+        schedule_transmisson (e_ctx);
 }
 
 
@@ -494,7 +570,6 @@ static void handle_response (const struct GNUNET_PeerIdentity *peer,
         unsigned int c1;
         unsigned int c2;
 
-
         if (ntohs (message->size) < sizeof (struct Experimentation_Response))
         {
                 GNUNET_break (0);
@@ -642,9 +717,6 @@ static void handle_start (const struct GNUNET_PeerIdentity *peer,
                 return;
         }
 
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received %s message from peer %s for experiment `%s'\n"),
-                        "START", GNUNET_i2s (peer), name);
-
         GED_scheduler_handle_start (n, e);
 }
 
@@ -714,9 +786,6 @@ static void handle_start_ack (const struct GNUNET_PeerIdentity *peer,
                 GNUNET_break (0);
                 return;
         }
-
-        GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Received %s message from peer %s for experiment `%s'\n"),
-                        "START_ACK", GNUNET_i2s (peer), name);
         GED_scheduler_handle_start_ack (n, e);
 }
 
@@ -814,7 +883,6 @@ void core_connect_handler (void *cls,
                 return; /* This peer is known as inactive  */
 
         send_experimentation_request (peer);
-
 }
 
 
@@ -827,12 +895,21 @@ void core_connect_handler (void *cls,
 void core_disconnect_handler (void *cls,
                            const struct GNUNET_PeerIdentity * peer)
 {
+        struct Node *n;
         if (GNUNET_YES == is_me(peer))
                 return;
 
         GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Disconnected from peer %s\n"),
                         GNUNET_i2s (peer));
 
+        if (NULL != (n = GNUNET_CONTAINER_multihashmap_get (nodes_requested, &peer->hashPubKey)))
+                cleanup_node (nodes_requested, &peer->hashPubKey, n);
+
+        if (NULL != (n = GNUNET_CONTAINER_multihashmap_get (nodes_active, &peer->hashPubKey)))
+                cleanup_node (nodes_active, &peer->hashPubKey, n);
+
+        if (NULL != (n = GNUNET_CONTAINER_multihashmap_get (nodes_inactive, &peer->hashPubKey)))
+                cleanup_node (nodes_inactive, &peer->hashPubKey, n);
 }
 
 
@@ -878,29 +955,16 @@ core_receive_handler (void *cls,
         return GNUNET_OK;
 }
 
-struct ExperimentStartCtx
-{
-        struct ExperimentStartCtx *prev;
-        struct ExperimentStartCtx *next;
-
-        struct Node *n;
-        struct Experiment *e;
-};
 
 size_t node_experiment_start_cb (void *cls, size_t bufsize, void *buf)
 {
-        struct ExperimentStartCtx *e_ctx = cls;
+        struct NodeComCtx *e_ctx = cls;
         struct GED_start_message *msg;
         size_t name_len;
         size_t size;
 
-        GNUNET_CONTAINER_DLL_remove (e_ctx->n->e_req_head, e_ctx->n->e_req_tail, e_ctx);
-        e_ctx->n->cth = NULL;
         if (NULL == buf)
-        {
-                GNUNET_free (e_ctx);
                 return 0;
-        }
 
         name_len = strlen(e_ctx->e->name) + 1;
         size = sizeof (struct GED_start_message) + name_len;
@@ -915,21 +979,63 @@ size_t node_experiment_start_cb (void *cls, size_t bufsize, void *buf)
 
         memcpy (buf, msg, size);
         GNUNET_free (msg);
-        GNUNET_free (e_ctx);
         return size;
 }
 
+size_t node_experiment_start_ack_cb (void *cls, size_t bufsize, void *buf)
+{
+        struct NodeComCtx *e_ctx = cls;
+        struct GED_start_ack_message *msg;
+        size_t name_len;
+        size_t size;
+        if (NULL == buf)
+                return 0;
 
+        name_len = strlen(e_ctx->e->name) + 1;
+        size = sizeof (struct GED_start_ack_message) + name_len;
+
+        msg = GNUNET_malloc (size);
+        msg->header.size = htons (size);
+        msg->header.type = htons (GNUNET_MESSAGE_TYPE_EXPERIMENTATION_START_ACK);
+        msg->issuer = e_ctx->e->issuer;
+        msg->version_nbo = GNUNET_TIME_absolute_hton(e_ctx->e->version);
+        msg->len_name = htonl (name_len);
+        memcpy (&msg[1], e_ctx->e->name, name_len);
+
+        memcpy (buf, msg, size);
+        GNUNET_free (msg);
+        return size;
+}
+
+
+
+
+/**
+ * Confirm a experiment START with a node
+ *
+ * @return GNUNET_NO if core was busy with sending, GNUNET_OK otherwise
+ */
 int
-GED_nodes_rts (struct Node *n)
+GED_nodes_send_start_ack (struct Node *n, struct Experiment *e)
 {
-        if (NULL == n->cth)
-                return GNUNET_YES;
-        else
-                return GNUNET_NO;
+        struct NodeComCtx *e_ctx;
+
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending %s for experiment request to peer `%s' for experiment `%s'\n"),
+                        "START_ACK" ,GNUNET_i2s(&n->id), e->name);
+
+        e_ctx = GNUNET_malloc (sizeof (struct NodeComCtx));
+        e_ctx->n = n;
+        e_ctx->e = e;
+        e_ctx->size = sizeof (struct GED_start_ack_message) + strlen (e->name) + 1;
+        e_ctx->notify = &node_experiment_start_ack_cb;
+        e_ctx->notify_cls = e_ctx;
 
+        GNUNET_CONTAINER_DLL_insert_tail (n->e_req_head, n->e_req_tail, e_ctx);
+        schedule_transmisson (e_ctx);
+        return GNUNET_OK;
 }
 
+
 /**
  * Request a experiment to start with a node
  *
@@ -938,31 +1044,20 @@ GED_nodes_rts (struct Node *n)
 int
 GED_nodes_request_start (struct Node *n, struct Experiment *e)
 {
-        struct ExperimentStartCtx *e_ctx;
-
-        if (NULL != n->cth)
-        {
-                GNUNET_break (0); /* should call rts before */
-                return GNUNET_NO;
-        }
+        struct NodeComCtx *e_ctx;
 
-        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending experiment start request to peer `%s' for experiment `%s'\n"),
-                        GNUNET_i2s(&n->id), e->name);
+        GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Sending %s for experiment request to peer `%s' for experiment `%s'\n"),
+                        "START", GNUNET_i2s(&n->id), e->name);
 
-        e_ctx = GNUNET_malloc (sizeof (struct ExperimentStartCtx));
+        e_ctx = GNUNET_malloc (sizeof (struct NodeComCtx));
         e_ctx->n = n;
         e_ctx->e = e;
-        n->cth = GNUNET_CORE_notify_transmit_ready (ch, GNUNET_NO, 0, FAST_TIMEOUT, &n->id,
-                        sizeof (struct GED_start_message) + strlen (e->name) + 1,
-                        &node_experiment_start_cb, e_ctx);
-        if (NULL == n->cth)
-        {
-                GNUNET_log (GNUNET_ERROR_TYPE_INFO, _("Cannot send experiment start request to peer `%s' for experiment `%s'\n"),
-                                GNUNET_i2s(&n->id), e->name);
-                GNUNET_free (e_ctx);
-        }
-        GNUNET_CONTAINER_DLL_insert (n->e_req_head, n->e_req_tail, e_ctx);
+        e_ctx->size = sizeof (struct GED_start_message) + strlen (e->name) + 1;
+        e_ctx->notify = &node_experiment_start_cb;
+        e_ctx->notify_cls = e_ctx;
 
+        GNUNET_CONTAINER_DLL_insert_tail (n->e_req_head, n->e_req_tail, e_ctx);
+        schedule_transmisson (e_ctx);
         return GNUNET_OK;
 }
 
@@ -998,16 +1093,10 @@ GED_nodes_start ()
 void
 GED_nodes_stop ()
 {
-  if (NULL != ch)
-  {
-                GNUNET_CORE_disconnect (ch);
-                ch = NULL;
-  }
-
   if (NULL != nodes_requested)
   {
                 GNUNET_CONTAINER_multihashmap_iterate (nodes_requested,
-                                                                                                                                                                         &cleanup_nodes,
+                                                                                                                                                                         &cleanup_node,
                                                                                                                                                                          nodes_requested);
                 update_stats (nodes_requested);
                 GNUNET_CONTAINER_multihashmap_destroy (nodes_requested);
@@ -1017,7 +1106,7 @@ GED_nodes_stop ()
   if (NULL != nodes_active)
   {
                 GNUNET_CONTAINER_multihashmap_iterate (nodes_active,
-                                                                                                                                                                         &cleanup_nodes,
+                                                                                                                                                                         &cleanup_node,
                                                                                                                                                                          nodes_active);
                 update_stats (nodes_active);
                 GNUNET_CONTAINER_multihashmap_destroy (nodes_active);
@@ -1027,12 +1116,17 @@ GED_nodes_stop ()
   if (NULL != nodes_inactive)
   {
                 GNUNET_CONTAINER_multihashmap_iterate (nodes_inactive,
-                                                                                                                                                                         &cleanup_nodes,
+                                                                                                                                                                         &cleanup_node,
                                                                                                                                                                          nodes_inactive);
                 update_stats (nodes_inactive);
                 GNUNET_CONTAINER_multihashmap_destroy (nodes_inactive);
                 nodes_inactive = NULL;
   }
+  if (NULL != ch)
+  {
+                GNUNET_CORE_disconnect (ch);
+                ch = NULL;
+  }
 }
 
 /* end of gnunet-daemon-experimentation_nodes.c */
diff --git a/src/experimentation/gnunet-daemon-experimentation_scheduler.c b/src/experimentation/gnunet-daemon-experimentation_scheduler.c
index de5c80614..519caa877 100644
--- a/src/experimentation/gnunet-daemon-experimentation_scheduler.c
+++ b/src/experimentation/gnunet-daemon-experimentation_scheduler.c
@@ -122,27 +122,13 @@ static void run_experiment_inbound (void *cls,const struct GNUNET_SCHEDULER_Task
         struct ScheduledExperiment *se = cls;
         struct GNUNET_TIME_Relative start;
         struct GNUNET_TIME_Relative end;
-        struct GNUNET_TIME_Relative backoff;
 
         se->task = GNUNET_SCHEDULER_NO_TASK;
 
-        if (GNUNET_NO == GED_nodes_rts (se->n))
-        {
-                se->state = BUSY;
-                backoff = GNUNET_TIME_UNIT_SECONDS;
-                backoff.rel_value += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000);
-                GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Delaying start request to peer `%s' for `%s' for %llu ms\n",
-                                GNUNET_i2s (&se->n->id), se->e->name, (unsigned long long) backoff.rel_value);
-                se->task = GNUNET_SCHEDULER_add_delayed (backoff, &run_experiment_inbound, se);
-                return;
-        }
-        else if (BUSY == se->state)
-                se->state = NOT_RUNNING;
-
         switch (se->state) {
                 case NOT_RUNNING:
                         /* Send START_ACK message */
-                        //GED_nodes_request_start (se->n, se->e);
+                        GED_nodes_send_start_ack (se->n, se->e);
                         se->state = REQUESTED;
                         /* Schedule to run */
                         start = GNUNET_TIME_absolute_get_remaining(se->e->start);
@@ -152,12 +138,11 @@ static void run_experiment_inbound (void *cls,const struct GNUNET_SCHEDULER_Task
                                         se->task = GNUNET_SCHEDULER_add_delayed (start, &run_experiment_inbound, se);
                         break;
                 case REQUESTED:
-                        /* Already requested */
-                        se->state = STARTED;
                 case STARTED:
+                        se->state = STARTED;
                         /* Experiment is running */
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running experiment `%s' peer for `%s'\n",
-                                        GNUNET_i2s (&se->n->id), se->e->name);
+                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running %s experiment `%s' peer for `%s'\n",
+                                        "inbound", GNUNET_i2s (&se->n->id), se->e->name);
 
                         /* do work here */
 
@@ -184,33 +169,15 @@ static void run_experiment_outbound (void *cls,const struct GNUNET_SCHEDULER_Tas
 {
         struct ScheduledExperiment *se = cls;
         struct GNUNET_TIME_Relative end;
-        struct GNUNET_TIME_Relative backoff;
 
         se->task = GNUNET_SCHEDULER_NO_TASK;
 
-        if (GNUNET_NO == GED_nodes_rts (se->n))
-        {
-                /* Cannot send to peer, core is busy */
-                se->state = BUSY;
-                backoff = GNUNET_TIME_UNIT_SECONDS;
-                backoff.rel_value += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 1000);
-                GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Delaying start request to peer `%s' for `%s' for %llu ms\n",
-                                GNUNET_i2s (&se->n->id), se->e->name, (unsigned long long) backoff.rel_value);
-                se->task = GNUNET_SCHEDULER_add_delayed (backoff, &run_experiment_outbound, se);
-                return;
-        }
-        else if (BUSY == se->state)
-                        se->state = NOT_RUNNING; /* Not busy anymore, can send */
-
         switch (se->state) {
                 case NOT_RUNNING:
                         /* Send START message */
                         GED_nodes_request_start (se->n, se->e);
                         se->state = REQUESTED;
                         se->task = GNUNET_SCHEDULER_add_delayed (EXP_RESPONSE_TIMEOUT, &request_timeout, se);
-
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Sending start request to peer `%s' for `%s'\n",
-                                        GNUNET_i2s (&se->n->id), se->e->name);
                         experiments_requested ++;
                         GNUNET_STATISTICS_set (GED_stats, "# experiments requested", experiments_requested, GNUNET_NO);
                         break;
@@ -220,8 +187,8 @@ static void run_experiment_outbound (void *cls,const struct GNUNET_SCHEDULER_Tas
                         break;
                 case STARTED:
                         /* Experiment is running */
-                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running experiment `%s' peer for `%s'\n",
-                                        GNUNET_i2s (&se->n->id), se->e->name);
+                        GNUNET_log (GNUNET_ERROR_TYPE_INFO, "Running %s experiment `%s' peer for `%s'\n",
+                                        "outbound", GNUNET_i2s (&se->n->id), se->e->name);
 
                         /* do work here */
 
@@ -271,7 +238,7 @@ GED_scheduler_handle_start (struct Node *n, struct Experiment *e)
 }
 
 /**
- * Handle a START_ACL message from a remote node
+ * Handle a START_ACK message from a remote node
  *
  * @param n the node
  * @param e the experiment
@@ -281,7 +248,7 @@ GED_scheduler_handle_start_ack (struct Node *n, struct Experiment *e)
 {
         struct ScheduledExperiment *se;
 
-        if (NULL == (se = find_experiment (waiting_in_head, waiting_in_tail, n, e, GNUNET_NO)))
+        if (NULL == (se = find_experiment (waiting_out_head, waiting_out_tail, n, e, GNUNET_YES)))
         {
                 GNUNET_break (0);
                 return;
@@ -291,7 +258,14 @@ GED_scheduler_handle_start_ack (struct Node *n, struct Experiment *e)
                         "START_ACK", GNUNET_i2s (&n->id), e->name);
 
         if (GNUNET_SCHEDULER_NO_TASK != se->task)
-                GNUNET_SCHEDULER_cancel (se->task);
+                GNUNET_SCHEDULER_cancel (se->task); /* *Canceling timeout task */
+
+        /* Remove from waiting list, add to running list */
+        GNUNET_CONTAINER_DLL_remove (waiting_out_head, waiting_out_tail, se);
+        GNUNET_CONTAINER_DLL_insert (running_out_head, waiting_out_tail, se);
+
+        /* Change state and schedule to run */
+        se->state = STARTED;
         se->task = GNUNET_SCHEDULER_add_now (&run_experiment_outbound, se);
 }
 
@@ -427,6 +401,38 @@ GED_scheduler_stop ()
                         experiments_running --;
                         GNUNET_STATISTICS_set (GED_stats, "# experiments running", experiments_running, GNUNET_NO);
         }
+
+        next = waiting_out_head;
+        while (NULL != (cur = next))
+        {
+                        next = cur->next;
+                        GNUNET_CONTAINER_DLL_remove (waiting_out_head, waiting_out_tail, cur);
+                        if (GNUNET_SCHEDULER_NO_TASK != cur->task)
+                        {
+                                        GNUNET_SCHEDULER_cancel (cur->task);
+                                        cur->task = GNUNET_SCHEDULER_NO_TASK;
+                        }
+                        GNUNET_free (cur);
+                        GNUNET_assert (experiments_scheduled > 0);
+                        experiments_scheduled --;
+                        GNUNET_STATISTICS_set (GED_stats, "# experiments scheduled", experiments_scheduled, GNUNET_NO);
+        }
+
+        next = running_out_head;
+        while (NULL != (cur = next))
+        {
+                        next = cur->next;
+                        GNUNET_CONTAINER_DLL_remove (running_out_head, running_out_tail, cur);
+                        if (GNUNET_SCHEDULER_NO_TASK != cur->task)
+                        {
+                                        GNUNET_SCHEDULER_cancel (cur->task);
+                                        cur->task = GNUNET_SCHEDULER_NO_TASK;
+                        }
+                        GNUNET_free (cur);
+                        GNUNET_assert (experiments_running > 0);
+                        experiments_running --;
+                        GNUNET_STATISTICS_set (GED_stats, "# experiments running", experiments_running, GNUNET_NO);
+        }
 }
 
 /* end of gnunet-daemon-experimentation_scheduler.c */
diff --git a/src/experimentation/test_experimentation_clique.conf b/src/experimentation/test_experimentation_clique.conf
index bc6a34dcc..5b2b86ab2 100644
--- a/src/experimentation/test_experimentation_clique.conf
+++ b/src/experimentation/test_experimentation_clique.conf
@@ -32,7 +32,7 @@ NEIGHBOUR_LIMIT = 50
 PORT = 12365
 
 [experimentation]
-#PREFIX = valgrind --leak-check=full
+PREFIX = valgrind --leak-check=full
 ISSUERS = TFRM29O2RQNKLVBQIGODJ6GD58LSQ2NM9TNFBC6N48BRJHQO38Q73N2OM3V4CLKDM6CILQV4CU8PMJDRG0FNB0PDI057DBRANMLPLRG
 EXPERIMENTS = test_experiments.exp