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

9 files changed, 76 insertions, 76 deletions

diff --git a/src/dht/dht_api.c b/src/dht/dht_api.c
index be699e65e..5822702e0 100644
--- a/src/dht/dht_api.c
+++ b/src/dht/dht_api.c
@@ -66,7 +66,7 @@ struct PendingMessage
    * Continuation to call when the request has been
    * transmitted (for the first time) to the service; can be NULL.
    */
-  GNUNET_SCHEDULER_Task cont;
+  GNUNET_SCHEDULER_TaskCallback cont;
 
   /**
    * Closure for 'cont'.
@@ -155,7 +155,7 @@ struct GNUNET_DHT_PutHandle
   /**
    * Timeout task for this operation.
    */
-  GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+  struct GNUNET_SCHEDULER_Task * timeout_task;
 
   /**
    * Unique ID for the PUT operation.
@@ -345,7 +345,7 @@ struct GNUNET_DHT_Handle
   /**
    * Task for trying to reconnect.
    */
-  GNUNET_SCHEDULER_TaskIdentifier reconnect_task;
+  struct GNUNET_SCHEDULER_Task * reconnect_task;
 
   /**
    * How quickly should we retry?  Used for exponential back-off on
@@ -506,7 +506,7 @@ try_reconnect (void *cls,
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Reconnecting with DHT %p\n", handle);
   handle->retry_time = GNUNET_TIME_STD_BACKOFF (handle->retry_time);
-  handle->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
+  handle->reconnect_task = NULL;
   if (GNUNET_YES != try_connect (handle))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "dht reconnect failed(!)\n");
@@ -531,7 +531,7 @@ do_disconnect (struct GNUNET_DHT_Handle *handle)
 
   if (NULL == handle->client)
     return;
-  GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == handle->reconnect_task);
+  GNUNET_assert (NULL == handle->reconnect_task);
   if (NULL != handle->th)
     GNUNET_CLIENT_notify_transmit_ready_cancel (handle->th);
   handle->th = NULL;
@@ -1126,7 +1126,7 @@ GNUNET_DHT_disconnect (struct GNUNET_DHT_Handle *handle)
     GNUNET_CLIENT_disconnect (handle->client);
     handle->client = NULL;
   }
-  if (GNUNET_SCHEDULER_NO_TASK != handle->reconnect_task)
+  if (NULL != handle->reconnect_task)
     GNUNET_SCHEDULER_cancel (handle->reconnect_task);
   GNUNET_CONTAINER_multihashmap_destroy (handle->active_requests);
   GNUNET_free (handle);
@@ -1146,7 +1146,7 @@ timeout_put_request (void *cls,
   struct GNUNET_DHT_PutHandle *ph = cls;
   struct GNUNET_DHT_Handle *handle = ph->dht_handle;
 
-  ph->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+  ph->timeout_task = NULL;
   if (NULL != ph->pending)
   {
     GNUNET_CONTAINER_DLL_remove (handle->pending_head, handle->pending_tail,
@@ -1283,10 +1283,10 @@ GNUNET_DHT_put_cancel (struct GNUNET_DHT_PutHandle *ph)
     GNUNET_free (ph->pending);
     ph->pending = NULL;
   }
-  if (ph->timeout_task != GNUNET_SCHEDULER_NO_TASK)
+  if (ph->timeout_task != NULL)
   {
     GNUNET_SCHEDULER_cancel (ph->timeout_task);
-    ph->timeout_task = GNUNET_SCHEDULER_NO_TASK;
+    ph->timeout_task = NULL;
   }
   GNUNET_CONTAINER_DLL_remove (handle->put_head,
                                handle->put_tail,
diff --git a/src/dht/gnunet-service-dht_clients.c b/src/dht/gnunet-service-dht_clients.c
index b9058dc3b..09e563245 100644
--- a/src/dht/gnunet-service-dht_clients.c
+++ b/src/dht/gnunet-service-dht_clients.c
@@ -265,7 +265,7 @@ static struct GNUNET_CONTAINER_Heap *retry_heap;
 /**
  * Task that re-transmits requests (using retry_heap).
  */
-static GNUNET_SCHEDULER_TaskIdentifier retry_task;
+static struct GNUNET_SCHEDULER_Task * retry_task;
 
 
 /**
@@ -459,7 +459,7 @@ transmit_next_request_task (void *cls,
   struct ClientQueryRecord *cqr;
   struct GNUNET_TIME_Relative delay;
 
-  retry_task = GNUNET_SCHEDULER_NO_TASK;
+  retry_task = NULL;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   while (NULL != (cqr = GNUNET_CONTAINER_heap_remove_root (retry_heap)))
@@ -628,7 +628,7 @@ handle_dht_local_get (void *cls, struct GNUNET_SERVER_Client *client,
                            GDS_NEIGHBOURS_get_id(),
                            &get->key);
   /* start remote requests */
-  if (GNUNET_SCHEDULER_NO_TASK != retry_task)
+  if (NULL != retry_task)
     GNUNET_SCHEDULER_cancel (retry_task);
   retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task, NULL);
   /* perform local lookup */
@@ -1496,10 +1496,10 @@ GDS_CLIENTS_done ()
 {
   GNUNET_assert (client_head == NULL);
   GNUNET_assert (client_tail == NULL);
-  if (GNUNET_SCHEDULER_NO_TASK != retry_task)
+  if (NULL != retry_task)
   {
     GNUNET_SCHEDULER_cancel (retry_task);
-    retry_task = GNUNET_SCHEDULER_NO_TASK;
+    retry_task = NULL;
   }
   if (NULL != retry_heap)
   {
diff --git a/src/dht/gnunet-service-dht_neighbours.c b/src/dht/gnunet-service-dht_neighbours.c
index 38a9c45ad..9608405ef 100644
--- a/src/dht/gnunet-service-dht_neighbours.c
+++ b/src/dht/gnunet-service-dht_neighbours.c
@@ -334,7 +334,7 @@ struct PeerInfo
   /**
    * Task for scheduling preference updates
    */
-  GNUNET_SCHEDULER_TaskIdentifier preference_task;
+  struct GNUNET_SCHEDULER_Task * preference_task;
 
   /**
    * What is the identity of the peer?
@@ -422,7 +422,7 @@ static unsigned int bucket_size = DEFAULT_BUCKET_SIZE;
 /**
  * Task that sends FIND PEER requests.
  */
-static GNUNET_SCHEDULER_TaskIdentifier find_peer_task;
+static struct GNUNET_SCHEDULER_Task * find_peer_task;
 
 /**
  * Identity of this peer.
@@ -485,7 +485,7 @@ update_core_preference (void *cls,
   int bucket;
   struct GNUNET_HashCode phash;
 
-  peer->preference_task = GNUNET_SCHEDULER_NO_TASK;
+  peer->preference_task = NULL;
   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
   GNUNET_CRYPTO_hash (&peer->id,
@@ -586,7 +586,7 @@ send_find_peer_message (void *cls,
   struct BloomConstructorContext bcc;
   struct GNUNET_CONTAINER_BloomFilter *peer_bf;
 
-  find_peer_task = GNUNET_SCHEDULER_NO_TASK;
+  find_peer_task = NULL;
   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
   if (newly_found_peers > bucket_size)
@@ -729,10 +729,10 @@ handle_core_disconnect (void *cls,
                  GNUNET_CONTAINER_multipeermap_remove (all_known_peers,
                                                        peer,
                                                        to_remove));
-  if (GNUNET_SCHEDULER_NO_TASK != to_remove->preference_task)
+  if (NULL != to_remove->preference_task)
   {
     GNUNET_SCHEDULER_cancel (to_remove->preference_task);
-    to_remove->preference_task = GNUNET_SCHEDULER_NO_TASK;
+    to_remove->preference_task = NULL;
   }
   GNUNET_CRYPTO_hash (peer,
                       sizeof (struct GNUNET_PeerIdentity),
@@ -2240,10 +2240,10 @@ GDS_NEIGHBOURS_done ()
   GNUNET_assert (0 == GNUNET_CONTAINER_multipeermap_size (all_known_peers));
   GNUNET_CONTAINER_multipeermap_destroy (all_known_peers);
   all_known_peers = NULL;
-  if (GNUNET_SCHEDULER_NO_TASK != find_peer_task)
+  if (NULL != find_peer_task)
   {
     GNUNET_SCHEDULER_cancel (find_peer_task);
-    find_peer_task = GNUNET_SCHEDULER_NO_TASK;
+    find_peer_task = NULL;
   }
 }
 
diff --git a/src/dht/gnunet-service-xdht_clients.c b/src/dht/gnunet-service-xdht_clients.c
index 3ddb62be1..1c6b5d1bd 100644
--- a/src/dht/gnunet-service-xdht_clients.c
+++ b/src/dht/gnunet-service-xdht_clients.c
@@ -268,7 +268,7 @@ static struct GNUNET_CONTAINER_Heap *retry_heap;
 /**
  * Task that re-transmits requests (using retry_heap).
  */
-static GNUNET_SCHEDULER_TaskIdentifier retry_task;
+static struct GNUNET_SCHEDULER_Task * retry_task;
 
 
 /**
@@ -875,7 +875,7 @@ transmit_next_request_task (void *cls,
   struct ClientQueryRecord *cqr;
   struct GNUNET_TIME_Relative delay;
 
-  retry_task = GNUNET_SCHEDULER_NO_TASK;
+  retry_task = NULL;
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     return;
   while (NULL != (cqr = GNUNET_CONTAINER_heap_remove_root (retry_heap)))
@@ -1028,7 +1028,7 @@ handle_dht_local_get (void *cls, struct GNUNET_SERVER_Client *client,
                            &my_identity,
                            &get->key);
   /* start remote requests */
-  if (GNUNET_SCHEDULER_NO_TASK != retry_task)
+  if (NULL != retry_task)
     GNUNET_SCHEDULER_cancel (retry_task);
   retry_task = GNUNET_SCHEDULER_add_now (&transmit_next_request_task, NULL);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -1422,10 +1422,10 @@ GDS_CLIENTS_done ()
 {
   GNUNET_assert (client_head == NULL);
   GNUNET_assert (client_tail == NULL);
-  if (GNUNET_SCHEDULER_NO_TASK != retry_task)
+  if (NULL != retry_task)
   {
     GNUNET_SCHEDULER_cancel (retry_task);
-    retry_task = GNUNET_SCHEDULER_NO_TASK;
+    retry_task = NULL;
   }
   if (NULL != retry_heap)
   {
diff --git a/src/dht/gnunet-service-xdht_neighbours.c b/src/dht/gnunet-service-xdht_neighbours.c
index 8684ada0e..00bc69424 100644
--- a/src/dht/gnunet-service-xdht_neighbours.c
+++ b/src/dht/gnunet-service-xdht_neighbours.c
@@ -854,25 +854,25 @@ struct VerifySuccessorContext
  * Task that sends FIND FINGER TRAIL requests. This task is started when we have
  * get our first friend.
  */
-static GNUNET_SCHEDULER_TaskIdentifier find_finger_trail_task;
+static struct GNUNET_SCHEDULER_Task * find_finger_trail_task;
 
 /**
  * Task that sends verify successor message. This task is started when we get
  * our successor for the first time.
  */
-static GNUNET_SCHEDULER_TaskIdentifier send_verify_successor_task;
+static struct GNUNET_SCHEDULER_Task * send_verify_successor_task;
 
 /**
  * Task that sends verify successor message. This task is started when we get
  * our successor for the first time.
  */
-static GNUNET_SCHEDULER_TaskIdentifier send_verify_successor_retry_task;
+static struct GNUNET_SCHEDULER_Task * send_verify_successor_retry_task;
 
 /**
  * Task that sends verify successor message. This task is started when we get
  * our successor for the first time.
  */
-static GNUNET_SCHEDULER_TaskIdentifier send_notify_new_successor_retry_task;
+static struct GNUNET_SCHEDULER_Task * send_notify_new_successor_retry_task;
 
 /**
  * Identity of this peer.
@@ -3238,7 +3238,7 @@ send_verify_successor_message (void *cls,
   successor = &finger_table[0];
 
   /* This task will be scheduled when the result for Verify Successor is received. */
-  send_verify_successor_task = GNUNET_SCHEDULER_NO_TASK;
+  send_verify_successor_task = NULL;
 
   /* When verify successor is being called for first time *for current context*
    * cls will be NULL. If send_verify_successor_retry_task is not NO_TASK, we
@@ -3259,7 +3259,7 @@ send_verify_successor_message (void *cls,
      * --> Waiting for notify confirmation. again don't wait for it. notify
      *    confirmation will not succeded.
      */
-    if (send_verify_successor_retry_task != GNUNET_SCHEDULER_NO_TASK)
+    if (send_verify_successor_retry_task != NULL)
     {
       /* FIXME: Are we scheduling retry task as soon as we send verify message.
        If yes then here before making this task, first check if the message
@@ -3374,7 +3374,7 @@ update_current_search_finger_index (unsigned int finger_table_index)
     current_search_finger_index = PREDECESSOR_FINGER_ID;
     if (0 != GNUNET_CRYPTO_cmp_peer_identity (&my_identity, &successor->finger_identity))
     {
-      if (GNUNET_SCHEDULER_NO_TASK == send_verify_successor_task)
+      if (NULL == send_verify_successor_task)
       {
         send_verify_successor_task =
                 GNUNET_SCHEDULER_add_now (&send_verify_successor_message, NULL);
@@ -5133,7 +5133,7 @@ compare_and_update_successor (struct GNUNET_PeerIdentity curr_succ,
       GNUNET_STATISTICS_set (GDS_stats, key, succ, 0);
       GNUNET_free (key);
     }
-    if (send_verify_successor_task == GNUNET_SCHEDULER_NO_TASK)
+    if (send_verify_successor_task == NULL)
       send_verify_successor_task =
               GNUNET_SCHEDULER_add_delayed(verify_successor_next_send_time,
                                            &send_verify_successor_message,
@@ -5173,7 +5173,7 @@ compare_and_update_successor (struct GNUNET_PeerIdentity curr_succ,
       successor_times--;
 
 
-    if (send_verify_successor_task == GNUNET_SCHEDULER_NO_TASK)
+    if (send_verify_successor_task == NULL)
       send_verify_successor_task =
               GNUNET_SCHEDULER_add_delayed(verify_successor_next_send_time,
                                            &send_verify_successor_message,
@@ -5262,7 +5262,7 @@ send_notify_new_successor (void *cls,
                                             ctx->target_friend);
 
   if (0 == ctx->num_retries_scheduled &&
-          send_notify_new_successor_retry_task != GNUNET_SCHEDULER_NO_TASK)
+          send_notify_new_successor_retry_task != NULL)
   {
     // Result from previous notify successos hasn't arrived, so the retry task
     // hasn't been cancelled! Already a new notify successor must be called.
@@ -5271,7 +5271,7 @@ send_notify_new_successor (void *cls,
     old_notify_ctx = GNUNET_SCHEDULER_cancel(send_notify_new_successor_retry_task);
     GNUNET_free (old_notify_ctx->successor_trail);
     GNUNET_free (old_notify_ctx);
-    send_notify_new_successor_retry_task = GNUNET_SCHEDULER_NO_TASK;
+    send_notify_new_successor_retry_task = NULL;
   }
 
   ctx->num_retries_scheduled++;
@@ -5337,12 +5337,12 @@ handle_dht_p2p_verify_successor_result(void *cls,
   if(0 == (GNUNET_CRYPTO_cmp_peer_identity (&querying_peer, &my_identity)))
   {
     /* Cancel Retry Task */
-    if (GNUNET_SCHEDULER_NO_TASK != send_verify_successor_retry_task)
+    if (NULL != send_verify_successor_retry_task)
     {
       struct VerifySuccessorContext *ctx;
       ctx = GNUNET_SCHEDULER_cancel(send_verify_successor_retry_task);
       GNUNET_free(ctx);
-      send_verify_successor_retry_task = GNUNET_SCHEDULER_NO_TASK;
+      send_verify_successor_retry_task = NULL;
     }
     compare_and_update_successor (current_successor,
                                   probable_successor, trail, trail_length);
@@ -5533,15 +5533,15 @@ handle_dht_p2p_notify_succ_confirmation (void *cls,
     */
 
     // TODO: cancel schedule of notify_successor_retry_task
-    if (send_notify_new_successor_retry_task != GNUNET_SCHEDULER_NO_TASK)
+    if (send_notify_new_successor_retry_task != NULL)
     {
       struct SendNotifyContext *notify_ctx;
       notify_ctx = GNUNET_SCHEDULER_cancel(send_notify_new_successor_retry_task);
       GNUNET_free (notify_ctx->successor_trail);
       GNUNET_free (notify_ctx);
-      send_notify_new_successor_retry_task = GNUNET_SCHEDULER_NO_TASK;
+      send_notify_new_successor_retry_task = NULL;
     }
-    if (send_verify_successor_task == GNUNET_SCHEDULER_NO_TASK)
+    if (send_verify_successor_task == NULL)
     {
       verify_successor_next_send_time.rel_value_us =
       DHT_SEND_VERIFY_SUCCESSOR_INTERVAL.rel_value_us +
@@ -6063,10 +6063,10 @@ handle_core_disconnect (void *cls,
   if (0 != GNUNET_CONTAINER_multipeermap_size (friend_peermap))
     return;
 
-  if (GNUNET_SCHEDULER_NO_TASK != find_finger_trail_task)
+  if (NULL != find_finger_trail_task)
   {
       GNUNET_SCHEDULER_cancel (find_finger_trail_task);
-      find_finger_trail_task = GNUNET_SCHEDULER_NO_TASK;
+      find_finger_trail_task = NULL;
   }
   else
     GNUNET_break (0);
@@ -6109,7 +6109,7 @@ handle_core_connect (void *cls, const struct GNUNET_PeerIdentity *peer_identity)
    * selected after some time out. This is to ensure that both peers have added
    * each other as their friend. */
   /* Got a first connection, good time to start with FIND FINGER TRAIL requests...*/
-  if (GNUNET_SCHEDULER_NO_TASK == find_finger_trail_task)
+  if (NULL == find_finger_trail_task)
   {
     find_finger_trail_task = GNUNET_SCHEDULER_add_now (&send_find_finger_trail_message, NULL);
   }
@@ -6244,33 +6244,33 @@ GDS_NEIGHBOURS_done (void)
   GNUNET_CONTAINER_multipeermap_destroy (friend_peermap);
   friend_peermap = NULL;
 
-  if (GNUNET_SCHEDULER_NO_TASK != find_finger_trail_task)
+  if (NULL != find_finger_trail_task)
   {
     GNUNET_SCHEDULER_cancel (find_finger_trail_task);
-    find_finger_trail_task = GNUNET_SCHEDULER_NO_TASK;
+    find_finger_trail_task = NULL;
   }
 
-  if (GNUNET_SCHEDULER_NO_TASK != send_verify_successor_task)
+  if (NULL != send_verify_successor_task)
   {
     GNUNET_SCHEDULER_cancel (send_verify_successor_task);
-    send_verify_successor_task = GNUNET_SCHEDULER_NO_TASK;
+    send_verify_successor_task = NULL;
   }
 
-  if (GNUNET_SCHEDULER_NO_TASK != send_verify_successor_retry_task)
+  if (NULL != send_verify_successor_retry_task)
   {
     struct VerifySuccessorContext *ctx;
     ctx = GNUNET_SCHEDULER_cancel (send_verify_successor_retry_task);
     GNUNET_free(ctx);
-    send_verify_successor_retry_task = GNUNET_SCHEDULER_NO_TASK;
+    send_verify_successor_retry_task = NULL;
   }
 
-  if (send_notify_new_successor_retry_task != GNUNET_SCHEDULER_NO_TASK)
+  if (send_notify_new_successor_retry_task != NULL)
   {
     struct SendNotifyContext *notify_ctx;
     notify_ctx = GNUNET_SCHEDULER_cancel(send_notify_new_successor_retry_task);
     GNUNET_free (notify_ctx->successor_trail);
     GNUNET_free (notify_ctx);
-    send_notify_new_successor_retry_task = GNUNET_SCHEDULER_NO_TASK;
+    send_notify_new_successor_retry_task = NULL;
   }
 }
 
diff --git a/src/dht/gnunet_dht_profiler.c b/src/dht/gnunet_dht_profiler.c
index f6223b3dd..668f61aef 100644
--- a/src/dht/gnunet_dht_profiler.c
+++ b/src/dht/gnunet_dht_profiler.c
@@ -195,7 +195,7 @@ struct ActiveContext
   /**
    * Delay task
    */
-  GNUNET_SCHEDULER_TaskIdentifier delay_task;
+  struct GNUNET_SCHEDULER_Task * delay_task;
 
   /**
    * The size of the @e put_data
@@ -357,7 +357,7 @@ static int flag = 0;
 /**
  * Task to collect peer and its current successor statistics.
  */
-static GNUNET_SCHEDULER_TaskIdentifier successor_stats_task;
+static struct GNUNET_SCHEDULER_Task * successor_stats_task;
 
 /**
  * Closure for successor_stats_task.
@@ -441,7 +441,7 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       ac = a_ctx[cnt].ac;
       if (NULL != ac)
       {
-        if (GNUNET_SCHEDULER_NO_TASK != ac->delay_task)
+        if (NULL != ac->delay_task)
           GNUNET_SCHEDULER_cancel (ac->delay_task);
         if (NULL != ac->put_data)
           GNUNET_free (ac->put_data);
@@ -554,7 +554,7 @@ cancel_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct ActiveContext *ac = cls;
   struct Context *ctx = ac->ctx;
 
-  ac->delay_task = GNUNET_SCHEDULER_NO_TASK;
+  ac->delay_task = NULL;
   GNUNET_assert (NULL != ac->dht_get);
   GNUNET_DHT_get_stop (ac->dht_get);
   ac->dht_get = NULL;
@@ -613,9 +613,9 @@ get_iter (void *cls,
   get_ac->nrefs--;
   GNUNET_DHT_get_stop (ac->dht_get);
   ac->dht_get = NULL;
-  if (ac->delay_task != GNUNET_SCHEDULER_NO_TASK)
+  if (ac->delay_task != NULL)
     GNUNET_SCHEDULER_cancel (ac->delay_task);
-  ac->delay_task = GNUNET_SCHEDULER_NO_TASK;
+  ac->delay_task = NULL;
   GNUNET_assert (NULL != ctx->op);
   GNUNET_TESTBED_operation_done (ctx->op);
   ctx->op = NULL;
@@ -646,7 +646,7 @@ delayed_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct ActiveContext *get_ac;
   unsigned int r;
 
-  ac->delay_task = GNUNET_SCHEDULER_NO_TASK;
+  ac->delay_task = NULL;
   get_ac = NULL;
   while (1)
   {
@@ -735,7 +735,7 @@ delayed_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct ActiveContext *ac = cls;
 
-  ac->delay_task = GNUNET_SCHEDULER_NO_TASK;
+  ac->delay_task = NULL;
   /* Generate and DHT PUT some random data */
   ac->put_data_size = 16;       /* minimum */
   ac->put_data_size += GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
@@ -1065,7 +1065,7 @@ successor_stats_cont (void *cls,
   int count;
 
   /* Don't schedule the task till we are looking for circle here. */
-  successor_stats_task = GNUNET_SCHEDULER_NO_TASK;
+  successor_stats_task = NULL;
   GNUNET_TESTBED_operation_done (successor_stats_op);
   successor_stats_op = NULL;
   if (0 == max_searches)
@@ -1109,7 +1109,7 @@ successor_stats_cont (void *cls,
   if ((start_val == val) && (count == num_peers))
   {
     DEBUG("CIRCLE COMPLETED after %u tries", tries);
-    if(GNUNET_SCHEDULER_NO_TASK == successor_stats_task)
+    if(NULL == successor_stats_task)
     {
       start_func();
     }
@@ -1123,11 +1123,11 @@ successor_stats_cont (void *cls,
                   "Maximum tries %u exceeded while checking successor TOTAL TRIES %u"
                   " circle formation.  Exiting\n",
                   max_searches,tries);
-      if (GNUNET_SCHEDULER_NO_TASK != successor_stats_task)
+      if (NULL != successor_stats_task)
       {
-        successor_stats_task = GNUNET_SCHEDULER_NO_TASK;
+        successor_stats_task = NULL;
       }
-      if(GNUNET_SCHEDULER_NO_TASK == successor_stats_task)
+      if(NULL == successor_stats_task)
       {
         start_func();
       }
@@ -1255,7 +1255,7 @@ service_started (void *cls,
   ctx->op = NULL;
   peers_started++;
   DEBUG("Peers Started = %d; num_peers = %d \n", peers_started, num_peers);
-  if (GNUNET_SCHEDULER_NO_TASK == successor_stats_task && peers_started == num_peers)
+  if (NULL == successor_stats_task && peers_started == num_peers)
   {
      DEBUG("successor_stats_task \n");
      struct Collect_Stat_Context *collect_stat_cls = GNUNET_new(struct Collect_Stat_Context);
diff --git a/src/dht/test_dht_api.c b/src/dht/test_dht_api.c
index 5c6913740..e4f6e5b56 100644
--- a/src/dht/test_dht_api.c
+++ b/src/dht/test_dht_api.c
@@ -59,7 +59,7 @@ struct RetryContext
   /**
    * The task identifier of the retry task, so it can be cancelled.
    */
-  GNUNET_SCHEDULER_TaskIdentifier retry_task;
+  struct GNUNET_SCHEDULER_Task * retry_task;
 
 };
 
@@ -72,7 +72,7 @@ struct RetryContext retry_context;
 
 static int ok = 1;
 
-static GNUNET_SCHEDULER_TaskIdentifier die_task;
+static struct GNUNET_SCHEDULER_Task * die_task;
 
 
 #if VERBOSE
@@ -86,7 +86,7 @@ static void
 end (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_SCHEDULER_cancel (die_task);
-  die_task = GNUNET_SCHEDULER_NO_TASK;
+  die_task = NULL;
   GNUNET_DHT_disconnect (dht_handle);
   dht_handle = NULL;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -105,7 +105,7 @@ end_badly ()
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Stopping get request!\n");
     GNUNET_DHT_get_stop (get_handle);
   }
-  if (retry_context.retry_task != GNUNET_SCHEDULER_NO_TASK)
+  if (retry_context.retry_task != NULL)
     GNUNET_SCHEDULER_cancel (retry_context.retry_task);
   GNUNET_DHT_disconnect (dht_handle);
   dht_handle = NULL;
diff --git a/src/dht/test_dht_monitor.c b/src/dht/test_dht_monitor.c
index 98791d28f..6fc4498d1 100644
--- a/src/dht/test_dht_monitor.c
+++ b/src/dht/test_dht_monitor.c
@@ -90,12 +90,12 @@ static unsigned int NUM_PEERS = 3;
 /**
  * Task called to disconnect peers.
  */
-static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+static struct GNUNET_SCHEDULER_Task * timeout_task;
 
 /**
  * Task to do DHT_puts
  */
-static GNUNET_SCHEDULER_TaskIdentifier put_task;
+static struct GNUNET_SCHEDULER_Task * put_task;
 
 static struct GNUNET_DHT_MonitorHandle **monitors;
 
diff --git a/src/dht/test_dht_topo.c b/src/dht/test_dht_topo.c
index 311bb5597..9bd87b21e 100644
--- a/src/dht/test_dht_topo.c
+++ b/src/dht/test_dht_topo.c
@@ -71,12 +71,12 @@ static int ok = 1;
 /**
  * Task to do DHT_puts
  */
-static GNUNET_SCHEDULER_TaskIdentifier put_task;
+static struct GNUNET_SCHEDULER_Task * put_task;
 
 /**
  * Task to time out / regular shutdown.
  */
-static GNUNET_SCHEDULER_TaskIdentifier timeout_task;
+static struct GNUNET_SCHEDULER_Task * timeout_task;
 
 /**
  * Head of list of active GET operations.