quota management and better name for NO_TASK'

'

14 files changed, 65 insertions, 65 deletions

diff --git a/src/util/client.c b/src/util/client.c
index 487f3f8e8..7d380fa5c 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -230,7 +230,7 @@ receive_helper (void *cls,
   struct GNUNET_TIME_Relative remaining;
 
   GNUNET_assert (conn->msg_complete == GNUNET_NO);
-  conn->receiver_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  conn->receiver_task = GNUNET_SCHEDULER_NO_TASK;
 
   if ((available == 0) || (conn->sock == NULL) || (errCode != 0))
     {
@@ -284,7 +284,7 @@ receive_task (void *scls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct GNUNET_MessageHeader *msg = (struct GNUNET_MessageHeader*) mbuf;
 
   GNUNET_assert (GNUNET_YES == sock->msg_complete);
-  sock->receiver_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  sock->receiver_task = GNUNET_SCHEDULER_NO_TASK;
   GNUNET_assert (sock->received_pos >= msize);
   memcpy (msg, cmsg, msize);
   memmove (sock->received_buf,
@@ -320,7 +320,7 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
       return;
     }
   GNUNET_assert (sock->receiver_task ==
-                 GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+                 GNUNET_SCHEDULER_NO_TASK);
   sock->receiver_handler = handler;
   sock->receiver_handler_cls = cls;
   sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
@@ -328,7 +328,7 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
     sock->receiver_task = GNUNET_SCHEDULER_add_after (sock->sched,
                                                       GNUNET_YES,
                                                       GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                                      GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                      GNUNET_SCHEDULER_NO_TASK,
                                                       &receive_task, sock);
   else
     sock->receiver_task = GNUNET_NETWORK_receive (sock->sock,
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index 8df4cc8f4..fc4d24320 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -484,7 +484,7 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_SCHEDULER_add_after (tc->sched,
                               fhc->run_on_shutdown,
                               GNUNET_SCHEDULER_PRIORITY_KEEP,
-                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              GNUNET_SCHEDULER_NO_TASK,
                               &file_hash_task, fhc);
 }
 
@@ -536,7 +536,7 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
   GNUNET_SCHEDULER_add_after (sched,
                               run_on_shutdown,
                               priority,
-                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              GNUNET_SCHEDULER_NO_TASK,
                               &file_hash_task, fhc);
 }
 
diff --git a/src/util/disk.c b/src/util/disk.c
index c70f2cc2b..b0f92c7f2 100644
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -735,7 +735,7 @@ GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator
   GNUNET_SCHEDULER_add_after (iter->sched,
                               GNUNET_YES,
                               iter->priority,
-                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              GNUNET_SCHEDULER_NO_TASK,
                               &directory_iterator_task, iter);
   return GNUNET_YES;
 }
diff --git a/src/util/network.c b/src/util/network.c
index cb8542329..9b61bd8c2 100644
--- a/src/util/network.c
+++ b/src/util/network.c
@@ -541,7 +541,7 @@ connect_continuation (void *cls,
   int error;
 
   /* nobody needs to wait for us anymore... */
-  sock->connect_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  sock->connect_task = GNUNET_SCHEDULER_NO_TASK;
   /* Note: write-ready does NOT mean connect succeeded,
      we need to use getsockopt to be sure */
   len = sizeof (error);
@@ -574,7 +574,7 @@ connect_continuation (void *cls,
         }
       sock->connect_task = GNUNET_SCHEDULER_add_write (tc->sched, GNUNET_NO,    /* abort on shutdown */
                                                        GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                                       GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                       GNUNET_SCHEDULER_NO_TASK,
                                                        GNUNET_NETWORK_CONNECT_RETRY_TIMEOUT,
                                                        sock->sock,
                                                        &connect_continuation,
@@ -630,7 +630,7 @@ GNUNET_NETWORK_socket_create_from_connect (struct GNUNET_SCHEDULER_Handle
     }
   ret->connect_task = GNUNET_SCHEDULER_add_write (sched, GNUNET_NO,     /* abort on shutdown */
                                                   GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                                  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                  GNUNET_SCHEDULER_NO_TASK,
                                                   GNUNET_NETWORK_CONNECT_RETRY_TIMEOUT,
                                                   ret->sock,
                                                   &connect_continuation, ret);
@@ -727,7 +727,7 @@ destroy_continuation (void *cls,
   struct GNUNET_NETWORK_SocketHandle *sock = cls;
   GNUNET_NETWORK_TransmitReadyNotify notify;
 
-  if (sock->write_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_SCHEDULER_add_after (sock->sched,
                                   GNUNET_YES,
@@ -743,7 +743,7 @@ destroy_continuation (void *cls,
 #endif
       SHUTDOWN (sock->sock, SHUT_RDWR);
     }
-  if (sock->read_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_SCHEDULER_add_after (sock->sched,
                                   GNUNET_YES,
@@ -756,10 +756,10 @@ destroy_continuation (void *cls,
     {
       sock->nth.notify_ready = NULL;
       notify (sock->nth.notify_ready_cls, 0, NULL);
-      if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+      if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK)
         {
           GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
-          sock->nth.timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+          sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
         }
     }
   if (sock->sock != -1)
@@ -837,7 +837,7 @@ receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   ssize_t ret;
   GNUNET_NETWORK_Receiver receiver;
 
-  sh->read_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  sh->read_task = GNUNET_SCHEDULER_NO_TASK;
   now = GNUNET_TIME_absolute_get ();
   if ((now.value > sh->receive_timeout.value) ||
       (0 != (tc->reason & GNUNET_SCHEDULER_REASON_TIMEOUT)) ||
@@ -907,9 +907,9 @@ receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct GNUNET_NETWORK_SocketHandle *sh = cls;
   struct GNUNET_TIME_Absolute now;
 
-  sh->read_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  sh->read_task = GNUNET_SCHEDULER_NO_TASK;
   if ((sh->sock == -1) &&
-      (sh->connect_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK))
+      (sh->connect_task == GNUNET_SCHEDULER_NO_TASK))
     {
       /* not connected and no longer trying */
 #if DEBUG_NETWORK
@@ -930,7 +930,7 @@ receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       signal_timeout (sh);
       return;
     }
-  if (sh->connect_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (sh->connect_task != GNUNET_SCHEDULER_NO_TASK)
     {
       /* connect was retried */
       sh->read_task = GNUNET_SCHEDULER_add_after (tc->sched,
@@ -965,7 +965,7 @@ receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param timeout maximum amount of time to wait (use -1 for "forever")
  * @param receiver function to call with received data
  * @param receiver_cls closure for receiver
- * @return scheduler task ID used for receiving, GNUNET_SCHEDULER_NO_PREREQUISITE_TASK on error
+ * @return scheduler task ID used for receiving, GNUNET_SCHEDULER_NO_TASK on error
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_NETWORK_receive (struct GNUNET_NETWORK_SocketHandle *sock,
@@ -975,7 +975,7 @@ GNUNET_NETWORK_receive (struct GNUNET_NETWORK_SocketHandle *sock,
 {
   struct GNUNET_SCHEDULER_TaskContext tc;
 
-  GNUNET_assert ((sock->read_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) &&
+  GNUNET_assert ((sock->read_task == GNUNET_SCHEDULER_NO_TASK) &&
                  (sock->receiver == NULL));
   sock->receiver = receiver;
   sock->receiver_cls = receiver_cls;
@@ -1004,7 +1004,7 @@ GNUNET_NETWORK_receive_cancel (struct GNUNET_NETWORK_SocketHandle *sock,
 {
   GNUNET_assert (sock->read_task == task);
   GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->sched, task));
-  sock->read_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  sock->read_task = GNUNET_SCHEDULER_NO_TASK;
   sock->receiver = NULL;
   return sock->receiver_cls;
 }
@@ -1025,7 +1025,7 @@ process_notify (struct GNUNET_NETWORK_SocketHandle *sock)
   size_t size;
   GNUNET_NETWORK_TransmitReadyNotify notify;
 
-  GNUNET_assert (sock->write_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  GNUNET_assert (sock->write_task == GNUNET_SCHEDULER_NO_TASK);
   if (NULL == (notify = sock->nth.notify_ready))
     return GNUNET_NO;
   used = sock->write_buffer_off - sock->write_buffer_pos;
@@ -1034,10 +1034,10 @@ process_notify (struct GNUNET_NETWORK_SocketHandle *sock)
   if (sock->nth.notify_size > avail)
     return GNUNET_NO;
   sock->nth.notify_ready = NULL;
-  if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
-      sock->nth.timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+      sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
     }
   if (sock->write_buffer_size - sock->write_buffer_off < size)
     {
@@ -1084,10 +1084,10 @@ transmit_error (struct GNUNET_NETWORK_SocketHandle *sock)
 {
   if (sock->nth.notify_ready == NULL)
     return;                     /* nobody to tell about it */
-  if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (sock->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_SCHEDULER_cancel (sock->sched, sock->nth.timeout_task);
-      sock->nth.timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+      sock->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
     }
   transmit_timeout (sock, NULL);
 }
@@ -1105,13 +1105,13 @@ transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   ssize_t ret;
   size_t have;
 
-  GNUNET_assert (sock->write_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
-  sock->write_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
-  if (sock->connect_task != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  GNUNET_assert (sock->write_task != GNUNET_SCHEDULER_NO_TASK);
+  sock->write_task = GNUNET_SCHEDULER_NO_TASK;
+  if (sock->connect_task != GNUNET_SCHEDULER_NO_TASK)
     {
       /* still waiting for connect */
       GNUNET_assert (sock->write_task ==
-                     GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+                     GNUNET_SCHEDULER_NO_TASK);
       sock->write_task =
         GNUNET_SCHEDULER_add_delayed (tc->sched, GNUNET_NO,
                                       GNUNET_SCHEDULER_PRIORITY_KEEP,
@@ -1195,12 +1195,12 @@ RETRY:
     return;                     /* all data sent! */
   /* not done writing, schedule more */
 SCHEDULE_WRITE:
-  if (sock->write_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
     sock->write_task =
       GNUNET_SCHEDULER_add_write (tc->sched,
                                   GNUNET_NO,
                                   GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                  GNUNET_SCHEDULER_NO_TASK,
                                   GNUNET_TIME_absolute_get_remaining (sock->nth.transmit_timeout),
                                   sock->sock, &transmit_ready, sock);
 }
@@ -1233,7 +1233,7 @@ GNUNET_NETWORK_notify_transmit_ready (struct GNUNET_NETWORK_SocketHandle
   GNUNET_assert (sock->write_buffer_size >= size);
 
   if ((sock->sock == -1) &&
-      (sock->connect_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK))
+      (sock->connect_task == GNUNET_SCHEDULER_NO_TASK))
     {
 #if DEBUG_NETWORK
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1254,17 +1254,17 @@ GNUNET_NETWORK_notify_transmit_ready (struct GNUNET_NETWORK_SocketHandle
   sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
                                                          GNUNET_NO,
                                                          GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                                         GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                         GNUNET_SCHEDULER_NO_TASK,
                                                          timeout,
                                                          &transmit_timeout,
                                                          sock);
-  if (sock->write_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
     {
-      if (sock->connect_task == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+      if (sock->connect_task == GNUNET_SCHEDULER_NO_TASK)
         sock->write_task = GNUNET_SCHEDULER_add_write (sock->sched,
                                                        GNUNET_NO,
                                                        GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                                       GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                                       GNUNET_SCHEDULER_NO_TASK,
                                                        GNUNET_TIME_absolute_get_remaining (sock->nth.transmit_timeout),
                                                        sock->sock,
                                                        &transmit_ready, sock);
@@ -1290,7 +1290,7 @@ GNUNET_NETWORK_notify_transmit_ready_cancel (struct
 {
   GNUNET_assert (h->notify_ready != NULL);
   GNUNET_SCHEDULER_cancel (h->sh->sched, h->timeout_task);
-  h->timeout_task = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  h->timeout_task = GNUNET_SCHEDULER_NO_TASK;
   h->notify_ready = NULL;
 }
 
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 4872eee41..0b5307290 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -255,7 +255,7 @@ update_sets (struct GNUNET_SCHEDULER_Handle *sched,
   pos = sched->pending;
   while (pos != NULL)
     {
-      if ((pos->prereq_id != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK) &&
+      if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) &&
           (GNUNET_YES == is_pending (sched, pos->prereq_id)))
         {
           pos = pos->next;
@@ -329,7 +329,7 @@ is_ready (struct GNUNET_SCHEDULER_Handle *sched,
     task->reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
   if (task->reason == 0)
     return GNUNET_NO;           /* not ready */
-  if (task->prereq_id != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK)
+  if (task->prereq_id != GNUNET_SCHEDULER_NO_TASK)
     {
       if (GNUNET_YES == is_pending (sched, task->prereq_id))
         return GNUNET_NO;       /* prereq waiting */
@@ -671,7 +671,7 @@ GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched,
  * @param prerequisite_task run this task after the task with the given
  *        task identifier completes (and any of our other
  *        conditions, such as delay, read or write-readyness
- *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_TASK to not have any dependency
  *        on completion of other tasks.
  * @param main main function of the task
  * @param cls closure of task
@@ -707,7 +707,7 @@ GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
  * @param prerequisite_task run this task after the task with the given
  *        task identifier completes (and any of our other
  *        conditions, such as delay, read or write-readyness
- *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_TASK to not have any dependency
  *        on completion of other tasks.
  * @param delay how long should we wait? Use  GNUNET_TIME_UNIT_FOREVER_REL for "forever"
  * @param main main function of the task
@@ -745,7 +745,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
  * @param prerequisite_task run this task after the task with the given
  *        task identifier completes (and any of our other
  *        conditions, such as delay, read or write-readyness
- *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_TASK to not have any dependency
  *        on completion of other tasks.
  * @param delay how long should we wait? Use  GNUNET_TIME_UNIT_FOREVER_REL for "forever"
  * @param rfd read file-descriptor
@@ -788,7 +788,7 @@ GNUNET_SCHEDULER_add_read (struct GNUNET_SCHEDULER_Handle * sched,
  * @param prerequisite_task run this task after the task with the given
  *        task identifier completes (and any of our other
  *        conditions, such as delay, read or write-readyness
- *        are satisfied).  Use  GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        are satisfied).  Use  GNUNET_SCHEDULER_NO_TASK to not have any dependency
  *        on completion of other tasks.
  * @param delay how long should we wait? Use  GNUNET_TIME_UNIT_FOREVER_REL for "forever"
  * @param wfd write file-descriptor
@@ -841,7 +841,7 @@ GNUNET_SCHEDULER_add_write (struct GNUNET_SCHEDULER_Handle * sched,
  * @param prerequisite_task run this task after the task with the given
  *        task identifier completes (and any of our other
  *        conditions, such as delay, read or write-readyness
- *        are satisfied).  Use GNUNET_SCHEDULER_NO_PREREQUISITE_TASK to not have any dependency
+ *        are satisfied).  Use GNUNET_SCHEDULER_NO_TASK to not have any dependency
  *        on completion of other tasks.
  * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever"
  * @param nfds highest-numbered file descriptor in any of the two sets plus one
diff --git a/src/util/server.c b/src/util/server.c
index f604fbc50..8ffc9c027 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -223,7 +223,7 @@ struct GNUNET_SERVER_Client
 
   /**
    * Current task identifier for the receive call
-   * (or GNUNET_SCHEDULER_NO_PREREQUISITE_TASK for none).
+   * (or GNUNET_SCHEDULER_NO_TASK for none).
    */
   GNUNET_SCHEDULER_TaskIdentifier my_receive;
 
@@ -351,7 +351,7 @@ process_listen_socket (void *cls,
   GNUNET_SCHEDULER_add_select (server->sched,
                                GNUNET_YES,
                                GNUNET_SCHEDULER_PRIORITY_HIGH,
-                               GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                               GNUNET_SCHEDULER_NO_TASK,
                                GNUNET_TIME_UNIT_FOREVER_REL,
                                GNUNET_MAX (server->listen_socket,
                                            server->shutpipe[0]) + 1, &r, NULL,
@@ -483,7 +483,7 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
       GNUNET_SCHEDULER_add_select (sched,
                                    GNUNET_YES,
                                    GNUNET_SCHEDULER_PRIORITY_HIGH,
-                                   GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                   GNUNET_SCHEDULER_NO_TASK,
                                    GNUNET_TIME_UNIT_FOREVER_REL,
                                    GNUNET_MAX (ret->listen_socket,
                                                ret->shutpipe[0]) + 1, &r,
@@ -621,7 +621,7 @@ shutdown_incoming_processing (struct GNUNET_SERVER_Client *client)
   struct NotifyList *n;
   unsigned int rc;
 
-  GNUNET_assert (client->my_receive == GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  GNUNET_assert (client->my_receive == GNUNET_SCHEDULER_NO_TASK);
   rc = client->reference_count;
   if (client->server != NULL)
     {
@@ -740,7 +740,7 @@ process_incoming (void *cls,
   const char *cbuf = buf;
   size_t maxcpy;
 
-  client->my_receive = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  client->my_receive = GNUNET_SCHEDULER_NO_TASK;
   if ((buf == NULL) ||
       (available == 0) ||
       (errCode != 0) ||
@@ -1107,9 +1107,9 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
 {
   if (client->server == NULL)
     return;                     /* already disconnected */
-  GNUNET_assert (client->my_receive != GNUNET_SCHEDULER_NO_PREREQUISITE_TASK);
+  GNUNET_assert (client->my_receive != GNUNET_SCHEDULER_NO_TASK);
   client->receive_cancel (client->client_closure, client->my_receive);
-  client->my_receive = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  client->my_receive = GNUNET_SCHEDULER_NO_TASK;
   shutdown_incoming_processing (client);
 }
 
diff --git a/src/util/test_network.c b/src/util/test_network.c
index b55b346a7..02555c299 100644
--- a/src/util/test_network.c
+++ b/src/util/test_network.c
@@ -169,7 +169,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_SCHEDULER_add_read (tc->sched,
                              GNUNET_NO,
                              GNUNET_SCHEDULER_PRIORITY_HIGH,
-                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_SCHEDULER_NO_TASK,
                              GNUNET_TIME_UNIT_FOREVER_REL,
                              ls, &run_accept, cls);
 }
diff --git a/src/util/test_network_addressing.c b/src/util/test_network_addressing.c
index 4a571fff5..3c2a690d9 100644
--- a/src/util/test_network_addressing.c
+++ b/src/util/test_network_addressing.c
@@ -159,7 +159,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_SCHEDULER_add_read (tc->sched,
                              GNUNET_NO,
                              GNUNET_SCHEDULER_PRIORITY_HIGH,
-                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_SCHEDULER_NO_TASK,
                              GNUNET_TIME_UNIT_FOREVER_REL,
                              ls, &run_accept, cls);
 }
diff --git a/src/util/test_network_receive_cancel.c b/src/util/test_network_receive_cancel.c
index e22e24d8c..7eb31153c 100644
--- a/src/util/test_network_receive_cancel.c
+++ b/src/util/test_network_receive_cancel.c
@@ -123,13 +123,13 @@ task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_SCHEDULER_add_read (tc->sched,
                              GNUNET_NO,
                              GNUNET_SCHEDULER_PRIORITY_HIGH,
-                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_SCHEDULER_NO_TASK,
                              GNUNET_TIME_UNIT_FOREVER_REL,
                              ls, &run_accept_cancel, cls);
   GNUNET_SCHEDULER_add_delayed (tc->sched,
                                 GNUNET_NO,
                                 GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                GNUNET_SCHEDULER_NO_TASK,
                                 GNUNET_TIME_UNIT_SECONDS,
                                 &receive_cancel_task, cls);
 }
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c
index 855b3a08a..d5a93ed7d 100644
--- a/src/util/test_scheduler.c
+++ b/src/util/test_scheduler.c
@@ -118,13 +118,13 @@ task5 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_SCHEDULER_add_read (tc->sched,
                              GNUNET_NO,
                              GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                             GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                             GNUNET_SCHEDULER_NO_TASK,
                              GNUNET_TIME_UNIT_FOREVER_REL,
                              fds[0], &taskRd, cls);
   GNUNET_SCHEDULER_add_write (tc->sched,
                               GNUNET_NO,
                               GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                              GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                              GNUNET_SCHEDULER_NO_TASK,
                               GNUNET_TIME_UNIT_FOREVER_REL,
                               fds[1], &taskWrt, cls);
 }
@@ -144,7 +144,7 @@ task1 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   t2 = GNUNET_SCHEDULER_add_after (tc->sched,
                                    GNUNET_NO,
                                    GNUNET_SCHEDULER_PRIORITY_IDLE,
-                                   GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                   GNUNET_SCHEDULER_NO_TASK,
                                    &task2, cls);
   /* t3 will go before t4: higher priority */
   t4 = GNUNET_SCHEDULER_add_after (tc->sched,
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c
index 76cbf94d8..f5477fd4c 100644
--- a/src/util/test_scheduler_delay.c
+++ b/src/util/test_scheduler_delay.c
@@ -68,7 +68,7 @@ test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_SCHEDULER_add_delayed (tc->sched,
                                 GNUNET_NO,
                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                GNUNET_SCHEDULER_NO_TASK,
                                 GNUNET_TIME_relative_multiply
                                 (GNUNET_TIME_UNIT_MILLISECONDS, i),
                                 &test_task, NULL);
diff --git a/src/util/test_server.c b/src/util/test_server.c
index c26d64270..0f2ea3ce7 100644
--- a/src/util/test_server.c
+++ b/src/util/test_server.c
@@ -77,7 +77,7 @@ my_receive (void *cls,
   struct SignalTimeoutContext *stctx;
   GNUNET_SCHEDULER_TaskIdentifier ret;
 
-  ret = GNUNET_SCHEDULER_NO_PREREQUISITE_TASK;
+  ret = GNUNET_SCHEDULER_NO_TASK;
   switch (*ok)
     {
     case 1:
@@ -98,7 +98,7 @@ my_receive (void *cls,
       ret = GNUNET_SCHEDULER_add_delayed (sched,
                                           GNUNET_NO,
                                           GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                          GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                          GNUNET_SCHEDULER_NO_TASK,
                                           timeout, &signal_timeout, stctx);
       break;
     default:
diff --git a/src/util/test_server_disconnect.c b/src/util/test_server_disconnect.c
index 7eab48284..d737e92ec 100644
--- a/src/util/test_server_disconnect.c
+++ b/src/util/test_server_disconnect.c
@@ -94,7 +94,7 @@ recv_cb (void *cls,
       GNUNET_SCHEDULER_add_delayed (sched,
                                     GNUNET_YES,
                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                    GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                    GNUNET_SCHEDULER_NO_TASK,
                                     GNUNET_TIME_relative_multiply
                                     (GNUNET_TIME_UNIT_MILLISECONDS, 50),
                                     &send_done, argclient);
@@ -104,7 +104,7 @@ recv_cb (void *cls,
       GNUNET_SCHEDULER_add_delayed (sched,
                                     GNUNET_YES,
                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                    GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                    GNUNET_SCHEDULER_NO_TASK,
                                     GNUNET_TIME_relative_multiply
                                     (GNUNET_TIME_UNIT_MILLISECONDS, 50),
                                     &server_disconnect, argclient);
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c
index 22cf2cded..e5eb50d8e 100644
--- a/src/util/test_server_with_client.c
+++ b/src/util/test_server_with_client.c
@@ -86,7 +86,7 @@ recv_cb (void *cls,
       GNUNET_SCHEDULER_add_delayed (sched,
                                     GNUNET_YES,
                                     GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                    GNUNET_SCHEDULER_NO_PREREQUISITE_TASK,
+                                    GNUNET_SCHEDULER_NO_TASK,
                                     GNUNET_TIME_relative_multiply
                                     (GNUNET_TIME_UNIT_MILLISECONDS, 50),
                                     &send_done, argclient);