making GNUNET_SCHEDULER_cancel() perform in O(1) instead of O(n) to help or even fully address #3247

9 files changed, 94 insertions, 94 deletions

diff --git a/src/core/core_api.c b/src/core/core_api.c
index d2a8b5651..1d287bbc6 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -130,12 +130,12 @@ struct PeerRecord
    * ID of timeout task for the 'pending_head' handle
    * which is the one with the smallest timeout.
    */
-  GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+  struct GNUNET_SCHEDULER_Task * timeout_task;
 
   /**
    * ID of task to run 'next_request_transmission'.
    */
-  GNUNET_SCHEDULER_TaskIdentifier ntr_task;
+  struct GNUNET_SCHEDULER_Task * ntr_task;
 
   /**
    * SendMessageRequest ID generator for this peer.
@@ -289,7 +289,7 @@ struct GNUNET_CORE_Handle
   /**
    * ID of reconnect task (if any).
    */
-  GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+  struct GNUNET_SCHEDULER_Task * reconnect_task;
 
   /**
    * Current delay we use for re-trying to connect to core.
@@ -344,7 +344,7 @@ reconnect_task (void *cls,
 {
   struct GNUNET_CORE_Handle *h = cls;
 
-  h->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  h->reconnect_task = NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Connecting to CORE service after delay\n");
   reconnect (h);
@@ -369,15 +369,15 @@ disconnect_and_free_peer_entry (void *cls,
   struct GNUNET_CORE_TransmitHandle *th;
   struct PeerRecord *pr = value;
 
-  if (GNUNET_SCHEDULER_NO_TASK != pr->timeout_task)
+  if (NULL != pr->timeout_task)
   {
     GNUNET_SCHEDULER_cancel (pr->timeout_task);
-    pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    pr->timeout_task = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != pr->ntr_task)
+  if (NULL != pr->ntr_task)
   {
     GNUNET_SCHEDULER_cancel (pr->ntr_task);
-    pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
+    pr->ntr_task = NULL;
   }
   if ( (NULL != pr->prev) ||
        (NULL != pr->next) ||
@@ -401,8 +401,8 @@ disconnect_and_free_peer_entry (void *cls,
   GNUNET_assert (GNUNET_YES ==
                  GNUNET_CONTAINER_multipeermap_remove (h->peers, key, pr));
   GNUNET_assert (pr->ch == h);
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->timeout_task);
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->ntr_task);
+  GNUNET_assert (NULL == pr->timeout_task);
+  GNUNET_assert (NULL == pr->ntr_task);
   GNUNET_free (pr);
   return GNUNET_YES;
 }
@@ -420,7 +420,7 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
   struct ControlMessage *cm;
   struct PeerRecord *pr;
 
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->reconnect_task);
+  GNUNET_assert (NULL == h->reconnect_task);
   if (NULL != h->cth)
   {
     GNUNET_CLIENT_notify_transmit_ready_cancel (h->cth);
@@ -432,7 +432,7 @@ reconnect_later (struct GNUNET_CORE_Handle *h)
     h->client = NULL;
   }
   h->currently_down = GNUNET_YES;
-  GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
+  GNUNET_assert (h->reconnect_task == NULL);
   h->reconnect_task =
       GNUNET_SCHEDULER_add_delayed (h->retry_backoff,
                                     &reconnect_task, h);
@@ -496,10 +496,10 @@ request_next_transmission (struct PeerRecord *pr)
   struct SendMessageRequest *smr;
   struct GNUNET_CORE_TransmitHandle *th;
 
-  if (pr->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+  if (pr->timeout_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (pr->timeout_task);
-    pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    pr->timeout_task = NULL;
   }
   th = &pr->th;
   if (NULL == th->peer)
@@ -552,11 +552,11 @@ transmission_timeout (void *cls,
   struct GNUNET_CORE_Handle *h = pr->ch;
   struct GNUNET_CORE_TransmitHandle *th;
 
-  pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
-  if (GNUNET_SCHEDULER_NO_TASK != pr->ntr_task)
+  pr->timeout_task = NULL;
+  if (NULL != pr->ntr_task)
   {
     GNUNET_SCHEDULER_cancel (pr->ntr_task);
-    pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
+    pr->ntr_task = NULL;
   }
   th = &pr->th;
   th->peer = NULL;
@@ -609,7 +609,7 @@ transmit_message (void *cls,
   uint16_t msize;
   size_t ret;
 
-  GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK);
+  GNUNET_assert (h->reconnect_task == NULL);
   h->cth = NULL;
   if (NULL == buf)
   {
@@ -657,10 +657,10 @@ transmit_message (void *cls,
                                h->ready_peer_tail,
                                pr);
   th->peer = NULL;
-  if (GNUNET_SCHEDULER_NO_TASK != pr->timeout_task)
+  if (NULL != pr->timeout_task)
   {
     GNUNET_SCHEDULER_cancel (pr->timeout_task);
-    pr->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    pr->timeout_task = NULL;
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Transmitting SEND request to `%s' with %u bytes.\n",
@@ -1083,7 +1083,7 @@ init_done_task (void *cls, int success)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
          "Failed to exchange INIT with core, retrying\n");
-    if (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK)
+    if (h->reconnect_task == NULL)
       reconnect_later (h);
     return;
   }
@@ -1259,10 +1259,10 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
   GNUNET_CONTAINER_multipeermap_iterate (handle->peers,
                                          &disconnect_and_free_peer_entry,
                                          handle);
-  if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
+  if (handle->reconnect_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (handle->reconnect_task);
-    handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+    handle->reconnect_task = NULL;
   }
   GNUNET_CONTAINER_multipeermap_destroy (handle->peers);
   handle->peers = NULL;
@@ -1283,7 +1283,7 @@ run_request_next_transmission (void *cls,
 {
   struct PeerRecord *pr = cls;
 
-  pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
+  pr->ntr_task = NULL;
   request_next_transmission (pr);
 }
 
@@ -1361,7 +1361,7 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
   th->priority = priority;
   th->msize = notify_size;
   th->cork = cork;
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == pr->ntr_task);
+  GNUNET_assert (NULL == pr->ntr_task);
   pr->ntr_task =
     GNUNET_SCHEDULER_add_now (&run_request_next_transmission, pr);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
@@ -1409,10 +1409,10 @@ GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle *th)
                                  h->ready_peer_tail,
                                  pr);
   }
-  if (GNUNET_SCHEDULER_NO_TASK != pr->ntr_task)
+  if (NULL != pr->ntr_task)
   {
     GNUNET_SCHEDULER_cancel (pr->ntr_task);
-    pr->ntr_task = GNUNET_SCHEDULER_NO_TASK;
+    pr->ntr_task = NULL;
   }
 }
 
diff --git a/src/core/gnunet-service-core_kx.c b/src/core/gnunet-service-core_kx.c
index a4e964312..94f3f5c87 100644
--- a/src/core/gnunet-service-core_kx.c
+++ b/src/core/gnunet-service-core_kx.c
@@ -302,12 +302,12 @@ struct GSC_KeyExchangeInfo
   /**
    * ID of task used for re-trying SET_KEY and PING message.
    */
-  GNUNET_SCHEDULER_TaskIdentifier retry_set_key_task;
+  struct GNUNET_SCHEDULER_Task * retry_set_key_task;
 
   /**
    * ID of task used for sending keep-alive pings.
    */
-  GNUNET_SCHEDULER_TaskIdentifier keep_alive_task;
+  struct GNUNET_SCHEDULER_Task * keep_alive_task;
 
   /**
    * Bit map indicating which of the 32 sequence numbers before the last
@@ -373,7 +373,7 @@ static struct GSC_KeyExchangeInfo *kx_tail;
  * Task scheduled for periodic re-generation (and thus rekeying) of our
  * ephemeral key.
  */
-static GNUNET_SCHEDULER_TaskIdentifier rekey_task;
+static struct GNUNET_SCHEDULER_Task * rekey_task;
 
 /**
  * Notification context for all monitors.
@@ -651,7 +651,7 @@ set_key_retry_task (void *cls,
 {
   struct GSC_KeyExchangeInfo *kx = cls;
 
-  kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+  kx->retry_set_key_task = NULL;
   kx->set_key_retry_frequency = GNUNET_TIME_STD_BACKOFF (kx->set_key_retry_frequency);
   GNUNET_assert (GNUNET_CORE_KX_STATE_DOWN != kx->status);
   send_key (kx);
@@ -746,15 +746,15 @@ GSC_KX_stop (struct GSC_KeyExchangeInfo *kx)
   GSC_SESSIONS_end (&kx->peer);
   GNUNET_STATISTICS_update (GSC_stats, gettext_noop ("# key exchanges stopped"),
                             1, GNUNET_NO);
-  if (kx->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
+  if (kx->retry_set_key_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (kx->retry_set_key_task);
-    kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+    kx->retry_set_key_task = NULL;
   }
-  if (kx->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
+  if (kx->keep_alive_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (kx->keep_alive_task);
-    kx->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
+    kx->keep_alive_task = NULL;
   }
   kx->status = GNUNET_CORE_KX_PEER_DISCONNECT;
   monitor_notify_all (kx);
@@ -929,7 +929,7 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
   switch (kx->status)
   {
   case GNUNET_CORE_KX_STATE_DOWN:
-    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
+    GNUNET_assert (NULL == kx->keep_alive_task);
     kx->status = GNUNET_CORE_KX_STATE_KEY_RECEIVED;
     monitor_notify_all (kx);
     if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
@@ -937,7 +937,7 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
     send_ping (kx);
     break;
   case GNUNET_CORE_KX_STATE_KEY_SENT:
-    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
+    GNUNET_assert (NULL == kx->keep_alive_task);
     kx->status = GNUNET_CORE_KX_STATE_KEY_RECEIVED;
     monitor_notify_all (kx);
     if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
@@ -945,7 +945,7 @@ GSC_KX_handle_ephemeral_key (struct GSC_KeyExchangeInfo *kx,
     send_ping (kx);
     break;
   case GNUNET_CORE_KX_STATE_KEY_RECEIVED:
-    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
+    GNUNET_assert (NULL == kx->keep_alive_task);
     if (GNUNET_CORE_KX_STATE_KEY_SENT == sender_status)
       send_key (kx);
     send_ping (kx);
@@ -1069,7 +1069,7 @@ send_keep_alive (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct GNUNET_TIME_Relative retry;
   struct GNUNET_TIME_Relative left;
 
-  kx->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
+  kx->keep_alive_task = NULL;
   left = GNUNET_TIME_absolute_get_remaining (kx->timeout);
   if (0 == left.rel_value_us)
   {
@@ -1122,7 +1122,7 @@ update_timeout (struct GSC_KeyExchangeInfo *kx)
        are bigger than the threshold (5s) */
     monitor_notify_all (kx);
   }
-  if (kx->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
+  if (kx->keep_alive_task != NULL)
     GNUNET_SCHEDULER_cancel (kx->keep_alive_task);
   kx->keep_alive_task =
       GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide
@@ -1213,10 +1213,10 @@ GSC_KX_handle_pong (struct GSC_KeyExchangeInfo *kx,
               "Received PONG from `%s'\n",
               GNUNET_i2s (&kx->peer));
   /* no need to resend key any longer */
-  if (GNUNET_SCHEDULER_NO_TASK != kx->retry_set_key_task)
+  if (NULL != kx->retry_set_key_task)
   {
     GNUNET_SCHEDULER_cancel (kx->retry_set_key_task);
-    kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+    kx->retry_set_key_task = NULL;
   }
   switch (kx->status)
   {
@@ -1234,7 +1234,7 @@ GSC_KX_handle_pong (struct GSC_KeyExchangeInfo *kx,
     kx->status = GNUNET_CORE_KX_STATE_UP;
     monitor_notify_all (kx);
     GSC_SESSIONS_create (&kx->peer, kx);
-    GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == kx->keep_alive_task);
+    GNUNET_assert (NULL == kx->keep_alive_task);
     update_timeout (kx);
     break;
   case GNUNET_CORE_KX_STATE_UP:
@@ -1269,10 +1269,10 @@ static void
 send_key (struct GSC_KeyExchangeInfo *kx)
 {
   GNUNET_assert (GNUNET_CORE_KX_STATE_DOWN != kx->status);
-  if (GNUNET_SCHEDULER_NO_TASK != kx->retry_set_key_task)
+  if (NULL != kx->retry_set_key_task)
   {
      GNUNET_SCHEDULER_cancel (kx->retry_set_key_task);
-     kx->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
+     kx->retry_set_key_task = NULL;
   }
   /* always update sender status in SET KEY message */
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1402,10 +1402,10 @@ GSC_KX_handle_encrypted_message (struct GSC_KeyExchangeInfo *kx,
                               gettext_noop ("# sessions terminated by key expiration"),
                               1, GNUNET_NO);
     GSC_SESSIONS_end (&kx->peer);
-    if (GNUNET_SCHEDULER_NO_TASK != kx->keep_alive_task)
+    if (NULL != kx->keep_alive_task)
     {
       GNUNET_SCHEDULER_cancel (kx->keep_alive_task);
-      kx->keep_alive_task = GNUNET_SCHEDULER_NO_TASK;
+      kx->keep_alive_task = NULL;
     }
     kx->status = GNUNET_CORE_KX_STATE_KEY_SENT;
     monitor_notify_all (kx);
@@ -1684,10 +1684,10 @@ GSC_KX_init (struct GNUNET_CRYPTO_EddsaPrivateKey *pk,
 void
 GSC_KX_done ()
 {
-  if (GNUNET_SCHEDULER_NO_TASK != rekey_task)
+  if (NULL != rekey_task)
   {
     GNUNET_SCHEDULER_cancel (rekey_task);
-    rekey_task = GNUNET_SCHEDULER_NO_TASK;
+    rekey_task = NULL;
   }
   if (NULL != my_ephemeral_key)
   {
diff --git a/src/core/gnunet-service-core_neighbours.c b/src/core/gnunet-service-core_neighbours.c
index 20055081b..4fbe72074 100644
--- a/src/core/gnunet-service-core_neighbours.c
+++ b/src/core/gnunet-service-core_neighbours.c
@@ -103,7 +103,7 @@ struct Neighbour
   /**
    * ID of task used for re-trying plaintext scheduling.
    */
-  GNUNET_SCHEDULER_TaskIdentifier retry_plaintext_task;
+  struct GNUNET_SCHEDULER_Task * retry_plaintext_task;
 
   /**
    * #GNUNET_YES if this peer currently has excess bandwidth.
@@ -172,10 +172,10 @@ free_neighbour (struct Neighbour *n)
     GSC_KX_stop (n->kxinfo);
     n->kxinfo = NULL;
   }
-  if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
+  if (n->retry_plaintext_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
-    n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
+    n->retry_plaintext_task = NULL;
   }
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_CONTAINER_multipeermap_remove (neighbours,
diff --git a/src/core/gnunet-service-core_sessions.c b/src/core/gnunet-service-core_sessions.c
index 83b1147b8..a168eeed3 100644
--- a/src/core/gnunet-service-core_sessions.c
+++ b/src/core/gnunet-service-core_sessions.c
@@ -118,12 +118,12 @@ struct Session
   /**
    * Task to transmit corked messages with a delay.
    */
-  GNUNET_SCHEDULER_TaskIdentifier cork_task;
+  struct GNUNET_SCHEDULER_Task * cork_task;
 
   /**
    * Task to transmit our type map.
    */
-  GNUNET_SCHEDULER_TaskIdentifier typemap_task;
+  struct GNUNET_SCHEDULER_Task * typemap_task;
 
   /**
    * Retransmission delay we currently use for the typemap
@@ -213,10 +213,10 @@ GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Destroying session for peer `%4s'\n",
               GNUNET_i2s (&session->peer));
-  if (GNUNET_SCHEDULER_NO_TASK != session->cork_task)
+  if (NULL != session->cork_task)
   {
     GNUNET_SCHEDULER_cancel (session->cork_task);
-    session->cork_task = GNUNET_SCHEDULER_NO_TASK;
+    session->cork_task = NULL;
   }
   while (NULL != (car = session->active_client_request_head))
   {
@@ -231,10 +231,10 @@ GSC_SESSIONS_end (const struct GNUNET_PeerIdentity *pid)
                                  sme);
     GNUNET_free (sme);
   }
-  if (GNUNET_SCHEDULER_NO_TASK != session->typemap_task)
+  if (NULL != session->typemap_task)
   {
     GNUNET_SCHEDULER_cancel (session->typemap_task);
-    session->typemap_task = GNUNET_SCHEDULER_NO_TASK;
+    session->typemap_task = NULL;
   }
   GSC_CLIENTS_notify_clients_about_neighbour (&session->peer,
                                               session->tmap, NULL);
@@ -291,7 +291,7 @@ transmit_typemap_task (void *cls,
 static void
 start_typemap_task (struct Session *session)
 {
-  if (GNUNET_SCHEDULER_NO_TASK != session->typemap_task)
+  if (NULL != session->typemap_task)
     GNUNET_SCHEDULER_cancel (session->typemap_task);
   session->typemap_delay = GNUNET_TIME_UNIT_SECONDS;
   session->typemap_task =
@@ -395,10 +395,10 @@ GSC_SESSIONS_confirm_typemap (const struct GNUNET_PeerIdentity *peer,
                               1, GNUNET_NO);
     return;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != session->typemap_task)
+  if (NULL != session->typemap_task)
   {
     GNUNET_SCHEDULER_cancel (session->typemap_task);
-    session->typemap_task = GNUNET_SCHEDULER_NO_TASK;
+    session->typemap_task = NULL;
   }
   GNUNET_STATISTICS_update (GSC_stats,
                             gettext_noop
@@ -606,7 +606,7 @@ pop_cork_task (void *cls,
 {
   struct Session *session = cls;
 
-  session->cork_task = GNUNET_SCHEDULER_NO_TASK;
+  session->cork_task = NULL;
   try_transmission (session);
 }
 
@@ -720,7 +720,7 @@ try_transmission (struct Session *session)
                   "Corking until %s\n",
                   GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_remaining (min_deadline),
                                                           GNUNET_YES));
-      if (GNUNET_SCHEDULER_NO_TASK != session->cork_task)
+      if (NULL != session->cork_task)
         GNUNET_SCHEDULER_cancel (session->cork_task);
       session->cork_task =
           GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_absolute_get_remaining (min_deadline),
diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c
index c570def84..cc7c93176 100644
--- a/src/core/test_core_api.c
+++ b/src/core/test_core_api.c
@@ -48,9 +48,9 @@ static struct PeerContext p1;
 
 static struct PeerContext p2;
 
-static GNUNET_SCHEDULER_TaskIdentifier err_task;
+static struct GNUNET_SCHEDULER_Task * err_task;
 
-static GNUNET_SCHEDULER_TaskIdentifier con_task;
+static struct GNUNET_SCHEDULER_Task * con_task;
 
 static int ok;
 
@@ -88,10 +88,10 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   p1.th = NULL;
   GNUNET_TRANSPORT_disconnect (p2.th);
   p2.th = NULL;
-  if (GNUNET_SCHEDULER_NO_TASK != con_task)
+  if (NULL != con_task)
   {
     GNUNET_SCHEDULER_cancel (con_task);
-    con_task = GNUNET_SCHEDULER_NO_TASK;
+    con_task = NULL;
   }
   ok = 0;
 }
@@ -125,10 +125,10 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_TRANSPORT_disconnect (p2.th);
     p2.th = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != con_task)
+  if (NULL != con_task)
   {
     GNUNET_SCHEDULER_cancel (con_task);
-    con_task = GNUNET_SCHEDULER_NO_TASK;
+    con_task = NULL;
   }
   ok = 42;
 }
@@ -162,10 +162,10 @@ connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Encrypted connection established to peer `%4s'\n",
               GNUNET_i2s (peer));
-  if (GNUNET_SCHEDULER_NO_TASK != con_task)
+  if (NULL != con_task)
   {
     GNUNET_SCHEDULER_cancel (con_task);
-    con_task = GNUNET_SCHEDULER_NO_TASK;
+    con_task = NULL;
   }
   pc->connect_status = 1;
   if (pc == &p1)
@@ -250,7 +250,7 @@ connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
   {
-    con_task = GNUNET_SCHEDULER_NO_TASK;
+    con_task = NULL;
     return;
   }
   con_task =
diff --git a/src/core/test_core_api_reliability.c b/src/core/test_core_api_reliability.c
index fba153ade..55d1978ac 100644
--- a/src/core/test_core_api_reliability.c
+++ b/src/core/test_core_api_reliability.c
@@ -55,9 +55,9 @@ static unsigned long long total_bytes;
 
 static struct GNUNET_TIME_Absolute start_time;
 
-static GNUNET_SCHEDULER_TaskIdentifier err_task;
+static struct GNUNET_SCHEDULER_Task * err_task;
 
-static GNUNET_SCHEDULER_TaskIdentifier connect_task;
+static struct GNUNET_SCHEDULER_Task * connect_task;
 
 
 struct PeerContext
@@ -119,7 +119,7 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_CORE_disconnect (p2.ch);
   p2.ch = NULL;
   GNUNET_free_non_null (p2.hello);
-  if (connect_task != GNUNET_SCHEDULER_NO_TASK)
+  if (connect_task != NULL)
     GNUNET_SCHEDULER_cancel (connect_task);
   GNUNET_TRANSPORT_disconnect (p1.th);
   p1.th = NULL;
@@ -148,7 +148,7 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_CORE_disconnect (p2.ch);
     p2.ch = NULL;
   }
-  if (connect_task != GNUNET_SCHEDULER_NO_TASK)
+  if (connect_task != NULL)
     GNUNET_SCHEDULER_cancel (connect_task);
   if (p1.th != NULL)
   {
diff --git a/src/core/test_core_api_send_to_self.c b/src/core/test_core_api_send_to_self.c
index 913ae3848..f5ed7453c 100644
--- a/src/core/test_core_api_send_to_self.c
+++ b/src/core/test_core_api_send_to_self.c
@@ -38,7 +38,7 @@ static int ret;
 /**
  * Handle to the cleanup task.
  */
-GNUNET_SCHEDULER_TaskIdentifier die_task;
+struct GNUNET_SCHEDULER_Task * die_task;
 
 /**
  * Identity of this peer.
@@ -57,7 +57,7 @@ struct GNUNET_CORE_Handle *core;
 static void
 cleanup (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tskctx)
 {
-  die_task = GNUNET_SCHEDULER_NO_TASK;
+  die_task = NULL;
 
   if (core != NULL)
   {
@@ -73,7 +73,7 @@ static int
 receive (void *cls, const struct GNUNET_PeerIdentity *other,
          const struct GNUNET_MessageHeader *message)
 {
-  if (die_task != GNUNET_SCHEDULER_NO_TASK)
+  if (die_task != NULL)
     GNUNET_SCHEDULER_cancel (die_task);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received message from peer %s\n",
               GNUNET_i2s (other));
diff --git a/src/core/test_core_api_start_only.c b/src/core/test_core_api_start_only.c
index 3c14b01eb..8d46c176b 100644
--- a/src/core/test_core_api_start_only.c
+++ b/src/core/test_core_api_start_only.c
@@ -46,7 +46,7 @@ static struct PeerContext p1;
 
 static struct PeerContext p2;
 
-static GNUNET_SCHEDULER_TaskIdentifier timeout_task_id;
+static struct GNUNET_SCHEDULER_Task * timeout_task_id;
 
 static int ok;
 
diff --git a/src/core/test_core_quota_compliance.c b/src/core/test_core_quota_compliance.c
index bf9197f0c..a20a6c7d0 100644
--- a/src/core/test_core_quota_compliance.c
+++ b/src/core/test_core_quota_compliance.c
@@ -62,11 +62,11 @@ static unsigned long long total_bytes_recv;
 
 static struct GNUNET_TIME_Absolute start_time;
 
-static GNUNET_SCHEDULER_TaskIdentifier err_task;
+static struct GNUNET_SCHEDULER_Task * err_task;
 
-static GNUNET_SCHEDULER_TaskIdentifier measure_task;
+static struct GNUNET_SCHEDULER_Task * measure_task;
 
-static GNUNET_SCHEDULER_TaskIdentifier connect_task;
+static struct GNUNET_SCHEDULER_Task * connect_task;
 
 
 struct PeerContext
@@ -118,7 +118,7 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_CORE_Handle *ch;
 
-  err_task = GNUNET_SCHEDULER_NO_TASK;
+  err_task = NULL;
   GNUNET_STATISTICS_destroy (p1.stats, GNUNET_NO);
   GNUNET_STATISTICS_destroy (p2.stats, GNUNET_NO);
   GNUNET_TRANSPORT_get_hello_cancel (p2.ghh);
@@ -128,10 +128,10 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_CORE_notify_transmit_ready_cancel (p1.nth);
     p1.nth = NULL;
   }
-  if (connect_task != GNUNET_SCHEDULER_NO_TASK)
+  if (connect_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (connect_task);
-    connect_task = GNUNET_SCHEDULER_NO_TASK;
+    connect_task = NULL;
   }
   ch = p1.ch;
   p1.ch = NULL;
@@ -151,7 +151,7 @@ terminate_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 static void
 terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  err_task = GNUNET_SCHEDULER_NO_TASK;
+  err_task = NULL;
 
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Testcase failed!\n");
@@ -161,12 +161,12 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     GNUNET_CORE_notify_transmit_ready_cancel (p1.nth);
     p1.nth = NULL;
   }
-  if (measure_task != GNUNET_SCHEDULER_NO_TASK)
+  if (measure_task != NULL)
     GNUNET_SCHEDULER_cancel (measure_task);
-  if (connect_task != GNUNET_SCHEDULER_NO_TASK)
+  if (connect_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (connect_task);
-    connect_task = GNUNET_SCHEDULER_NO_TASK;
+    connect_task = NULL;
   }
 
   GNUNET_TRANSPORT_get_hello_cancel (p1.ghh);
@@ -231,7 +231,7 @@ measurement_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   unsigned long long quota_delta;
   enum GNUNET_ErrorType kind = GNUNET_ERROR_TYPE_DEBUG;
 
-  measure_task = GNUNET_SCHEDULER_NO_TASK;
+  measure_task = NULL;
   FPRINTF (stdout, "%s",  "\n");
   running = GNUNET_NO;
 
@@ -381,7 +381,7 @@ connect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Asking core (1) for transmission to peer `%4s'\n",
                 GNUNET_i2s (&p2.id));
-    if (err_task != GNUNET_SCHEDULER_NO_TASK)
+    if (err_task != NULL)
       GNUNET_SCHEDULER_cancel (err_task);
     err_task =
         GNUNET_SCHEDULER_add_delayed (TIMEOUT, &terminate_task_error, NULL);
@@ -410,12 +410,12 @@ disconnect_notify (void *cls, const struct GNUNET_PeerIdentity *peer)
   if (0 == memcmp (&pc->id, peer, sizeof (struct GNUNET_PeerIdentity)))
     return;                     /* loopback */
   pc->connect_status = 0;
-  if (GNUNET_SCHEDULER_NO_TASK != measure_task)
+  if (NULL != measure_task)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "Measurement aborted due to disconnect!\n");
     GNUNET_SCHEDULER_cancel (measure_task);
-    measure_task = GNUNET_SCHEDULER_NO_TASK;
+    measure_task = NULL;
   }
   if (pc->nth != NULL)
   {