big scheduler refactoring, expect some issues

29 files changed, 326 insertions, 552 deletions

diff --git a/src/util/client.c b/src/util/client.c
index 13c4062a57..171e9e957b 100644
--- a/src/util/client.c
+++ b/src/util/client.c
@@ -151,11 +151,6 @@ struct GNUNET_CLIENT_Connection
   struct GNUNET_CONNECTION_Handle *sock;
 
   /**
-   * Our scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-
-  /**
    * Our configuration.
    * FIXME: why do we DUP the configuration? Avoid this!
    */
@@ -262,15 +257,13 @@ struct GNUNET_CLIENT_Connection
 /**
  * Try to connect to the service.
  *
- * @param sched scheduler to use
  * @param service_name name of service to connect to
  * @param cfg configuration to use
  * @param attempt counter used to alternate between IP and UNIX domain sockets
  * @return NULL on error
  */
 static struct GNUNET_CONNECTION_Handle *
-do_connect (struct GNUNET_SCHEDULER_Handle *sched,
-            const char *service_name,
+do_connect (const char *service_name,
             const struct GNUNET_CONFIGURATION_Handle *cfg,
 	    unsigned int attempt)
 {
@@ -288,8 +281,7 @@ do_connect (struct GNUNET_SCHEDULER_Handle *sched,
 						 service_name,
 						 "UNIXPATH", &unixpath))
 	{
-	  sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (sched,
-								    cfg,
+	  sock = GNUNET_CONNECTION_create_from_connect_to_unixpath (cfg,
 								    unixpath);
 	  GNUNET_free (unixpath);
 	  if (sock != NULL)
@@ -323,8 +315,7 @@ do_connect (struct GNUNET_SCHEDULER_Handle *sched,
                   service_name);
       return NULL;
     }
-  sock = GNUNET_CONNECTION_create_from_connect (sched,
-                                                cfg,
+  sock = GNUNET_CONNECTION_create_from_connect (cfg,
                                                 hostname,
                                                 port);
   GNUNET_free (hostname);
@@ -335,28 +326,24 @@ do_connect (struct GNUNET_SCHEDULER_Handle *sched,
 /**
  * Get a connection with a service.
  *
- * @param sched scheduler to use
  * @param service_name name of the service
  * @param cfg configuration to use
  * @return NULL on error (service unknown to configuration)
  */
 struct GNUNET_CLIENT_Connection *
-GNUNET_CLIENT_connect (struct GNUNET_SCHEDULER_Handle *sched,
-                       const char *service_name,
+GNUNET_CLIENT_connect (const char *service_name,
                        const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   struct GNUNET_CLIENT_Connection *ret;
   struct GNUNET_CONNECTION_Handle *sock;
 
-  sock = do_connect (sched, 
-		     service_name, 
+  sock = do_connect (service_name,
 		     cfg, 0);
   if (sock == NULL)
     return NULL;
   ret = GNUNET_malloc (sizeof (struct GNUNET_CLIENT_Connection));
   ret->attempts = 1;
   ret->sock = sock;
-  ret->sched = sched;
   ret->service_name = GNUNET_strdup (service_name);
   ret->cfg = GNUNET_CONFIGURATION_dup (cfg);
   ret->back_off = GNUNET_TIME_UNIT_MILLISECONDS;
@@ -418,7 +405,7 @@ GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock,
     GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th);
   if (sock->receive_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_SCHEDULER_cancel (sock->sched, sock->receive_task);
+      GNUNET_SCHEDULER_cancel (sock->receive_task);
       sock->receive_task = GNUNET_SCHEDULER_NO_TASK;
     }
   GNUNET_array_grow (sock->received_buf, sock->received_size, 0);
@@ -569,8 +556,7 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
   sock->receive_timeout = GNUNET_TIME_relative_to_absolute (timeout);
   if (GNUNET_YES == sock->msg_complete)
     {
-      sock->receive_task = GNUNET_SCHEDULER_add_after (sock->sched,
-                                                       GNUNET_SCHEDULER_NO_TASK,
+      sock->receive_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
                                                        &receive_task, sock);
     }
   else
@@ -588,11 +574,9 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock,
  * Report service unavailable.
  */
 static void
-service_test_error (struct GNUNET_SCHEDULER_Handle *s,
-                    GNUNET_SCHEDULER_Task task, void *task_cls)
+service_test_error (GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  GNUNET_SCHEDULER_add_continuation (s,
-                                     task,
+  GNUNET_SCHEDULER_add_continuation (task,
                                      task_cls,
                                      GNUNET_SCHEDULER_REASON_TIMEOUT);
 }
@@ -617,14 +601,13 @@ confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Received confirmation that service is running.\n");
 #endif
-      GNUNET_SCHEDULER_add_continuation (conn->sched,
-                                         conn->test_cb,
+      GNUNET_SCHEDULER_add_continuation (conn->test_cb,
                                          conn->test_cb_cls,
                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
     }
   else
     {
-      service_test_error (conn->sched, conn->test_cb, conn->test_cb_cls);
+      service_test_error (conn->test_cb, conn->test_cb_cls);
     }
   GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
 }
@@ -642,7 +625,7 @@ write_test (void *cls, size_t size, void *buf)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   _("Failure to transmit TEST request.\n"));
 #endif
-      service_test_error (conn->sched, conn->test_cb, conn->test_cb_cls);
+      service_test_error (conn->test_cb, conn->test_cb_cls);
       GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
       return 0;                 /* client disconnected */
     }
@@ -664,7 +647,6 @@ write_test (void *cls, size_t size, void *buf)
 /**
  * Wait until the service is running.
  *
- * @param sched scheduler to use
  * @param service name of the service to wait for
  * @param cfg configuration to use
  * @param timeout how long to wait at most in ms
@@ -674,8 +656,7 @@ write_test (void *cls, size_t size, void *buf)
  * @param task_cls closure for task
  */
 void
-GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
-                            const char *service,
+GNUNET_CLIENT_service_test (const char *service,
                             const struct GNUNET_CONFIGURATION_Handle *cfg,
                             struct GNUNET_TIME_Relative timeout,
                             GNUNET_SCHEDULER_Task task, void *task_cls)
@@ -686,14 +667,14 @@ GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Testing if service `%s' is running.\n", service);
 #endif
-  conn = GNUNET_CLIENT_connect (sched, service, cfg);
+  conn = GNUNET_CLIENT_connect (service, cfg);
   if (conn == NULL)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                   _
                   ("Could not connect to service `%s', must not be running.\n"),
                   service);
-      service_test_error (sched, task, task_cls);
+      service_test_error (task, task_cls);
       return;
     }
   conn->test_cb = task;
@@ -709,7 +690,7 @@ GNUNET_CLIENT_service_test (struct GNUNET_SCHEDULER_Handle *sched,
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                   _("Failure to transmit request to service `%s'\n"),
                   service);
-      service_test_error (sched, task, task_cls);
+      service_test_error (task, task_cls);
       GNUNET_CLIENT_disconnect (conn, GNUNET_NO);
       return;
     }
@@ -791,7 +772,7 @@ client_notify (void *cls, size_t size, void *buf)
     {
       delay = GNUNET_TIME_absolute_get_remaining (th->timeout);
       delay.rel_value /= 2;
-      if ( (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason (th->sock->sched))) ||
+      if ( (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & GNUNET_SCHEDULER_get_reason ())) ||
 	   (GNUNET_YES != th->auto_retry) ||
 	   (0 == --th->attempts_left) || 
 	   (delay.rel_value < 1) )
@@ -807,8 +788,7 @@ client_notify (void *cls, size_t size, void *buf)
         }
       /* auto-retry */
       GNUNET_CONNECTION_destroy (th->sock->sock, GNUNET_NO);
-      th->sock->sock = do_connect (th->sock->sched,
-                                   th->sock->service_name, 
+      th->sock->sock = do_connect (th->sock->service_name,
 				   th->sock->cfg,
 				   th->sock->attempts++);
       GNUNET_assert (NULL != th->sock->sock);
@@ -824,8 +804,7 @@ client_notify (void *cls, size_t size, void *buf)
                   MAX_ATTEMPTS - th->attempts_left,
                   (unsigned long long) delay.rel_value);
 #endif
-      th->reconnect_task = GNUNET_SCHEDULER_add_delayed (th->sock->sched,
-                                                         delay,
+      th->reconnect_task = GNUNET_SCHEDULER_add_delayed (delay,
                                                          &client_delayed_retry,
                                                          th);
       th->sock->th = th;
@@ -904,7 +883,7 @@ GNUNET_CLIENT_notify_transmit_ready_cancel (struct
   if (th->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
     {
       GNUNET_break (NULL == th->th);
-      GNUNET_SCHEDULER_cancel (th->sock->sched, th->reconnect_task);
+      GNUNET_SCHEDULER_cancel (th->reconnect_task);
       th->reconnect_task = GNUNET_SCHEDULER_NO_TASK;
     }
   else
diff --git a/src/util/connection.c b/src/util/connection.c
index 04d0c864d8..a25dc0350e 100644
--- a/src/util/connection.c
+++ b/src/util/connection.c
@@ -161,11 +161,6 @@ struct GNUNET_CONNECTION_Handle
 {
 
   /**
-   * Scheduler that was used for the connect task.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-
-  /**
    * Configuration to use.
    */
   const struct GNUNET_CONFIGURATION_Handle *cfg;
@@ -312,14 +307,11 @@ void GNUNET_CONNECTION_persist_(struct GNUNET_CONNECTION_Handle *sock)
  * socket should henceforth be no longer used directly.
  * GNUNET_socket_destroy will close it.
  *
- * @param sched scheduler to use
  * @param osSocket existing socket to box
  * @return the boxed socket handle
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
-                                        *sched,
-                                        struct GNUNET_NETWORK_Handle
+GNUNET_CONNECTION_create_from_existing (struct GNUNET_NETWORK_Handle
                                         *osSocket)
 {
   struct GNUNET_CONNECTION_Handle *ret;
@@ -327,7 +319,6 @@ GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
   ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
   ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
   ret->sock = osSocket;
-  ret->sched = sched;
   return ret;
 }
 
@@ -336,16 +327,13 @@ GNUNET_CONNECTION_create_from_existing (struct GNUNET_SCHEDULER_Handle
  * Create a socket handle by accepting on a listen socket.  This
  * function may block if the listen socket has no connection ready.
  *
- * @param sched scheduler to use
  * @param access function to use to check if access is allowed
  * @param access_cls closure for access
  * @param lsock listen socket
  * @return the socket handle, NULL on error
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
-                                      *sched,
-                                      GNUNET_CONNECTION_AccessCheck access,
+GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access,
                                       void *access_cls,
                                       struct GNUNET_NETWORK_Handle *lsock)
 {
@@ -416,7 +404,6 @@ GNUNET_CONNECTION_create_from_accept (struct GNUNET_SCHEDULER_Handle
   ret->addr = uaddr;
   ret->addrlen = addrlen;
   ret->sock = sock;
-  ret->sched = sched;
 #if DEBUG_CONNECTION
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               _("Accepting connection from `%s': %p\n"),
@@ -494,8 +481,7 @@ destroy_continuation (void *cls,
 #endif
       GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
       sock->destroy_task 
-	= GNUNET_SCHEDULER_add_after (sock->sched,
-				      sock->write_task,
+	= GNUNET_SCHEDULER_add_after (sock->write_task,
 				      &destroy_continuation, sock);
       return;
     }
@@ -517,8 +503,7 @@ destroy_continuation (void *cls,
     {
       GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
       sock->destroy_task 
-	= GNUNET_SCHEDULER_add_after (sock->sched,
-				      sock->read_task,
+	= GNUNET_SCHEDULER_add_after (sock->read_task,
 				      &destroy_continuation, sock);
       return;
     }
@@ -529,7 +514,7 @@ destroy_continuation (void *cls,
   while (NULL != (pos = sock->ap_head))
     {
       GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
-      GNUNET_SCHEDULER_cancel (sock->sched, pos->task);
+      GNUNET_SCHEDULER_cancel (pos->task);
       GNUNET_CONTAINER_DLL_remove (sock->ap_head, sock->ap_tail, pos);
       GNUNET_free (pos);
     }
@@ -606,8 +591,7 @@ connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h)
                   h);
 #endif
       h->ccs -= COCO_RECEIVE_AGAIN;
-      h->read_task = GNUNET_SCHEDULER_add_after (h->sched,
-                                                 GNUNET_SCHEDULER_NO_TASK,
+      h->read_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
                                                  &receive_again, h);
     }
   if (0 != (h->ccs & COCO_TRANSMIT_READY))
@@ -618,12 +602,11 @@ connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h)
                   h);
 #endif
       GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
-      GNUNET_SCHEDULER_cancel (h->sched, h->nth.timeout_task);
+      GNUNET_SCHEDULER_cancel (h->nth.timeout_task);
       h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
       h->ccs -= COCO_TRANSMIT_READY;
       GNUNET_assert (h->write_task == GNUNET_SCHEDULER_NO_TASK);
-      h->write_task = GNUNET_SCHEDULER_add_after (h->sched,
-                                                  GNUNET_SCHEDULER_NO_TASK,
+      h->write_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
                                                   &transmit_ready, h);
     }
   if (0 != (h->ccs & COCO_DESTROY_CONTINUATION))
@@ -636,8 +619,7 @@ connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h)
       h->ccs -= COCO_DESTROY_CONTINUATION;
       GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->destroy_task);
       h->destroy_task
-	= GNUNET_SCHEDULER_add_now (h->sched,
-				    &destroy_continuation,
+	= GNUNET_SCHEDULER_add_now (&destroy_continuation,
 				    h);
     }
 }
@@ -665,8 +647,7 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *h)
                   h);
 #endif
       h->ccs -= COCO_RECEIVE_AGAIN;
-      h->read_task = GNUNET_SCHEDULER_add_after (h->sched,
-                                                 GNUNET_SCHEDULER_NO_TASK,
+      h->read_task = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
                                                  &receive_again, h);
     }
   if (0 != (h->ccs & COCO_TRANSMIT_READY))
@@ -677,13 +658,12 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *h)
                   h);
 #endif
       GNUNET_assert (h->nth.timeout_task != GNUNET_SCHEDULER_NO_TASK);
-      GNUNET_SCHEDULER_cancel (h->sched, h->nth.timeout_task);
+      GNUNET_SCHEDULER_cancel (h->nth.timeout_task);
       h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK;
       h->ccs -= COCO_TRANSMIT_READY;
       GNUNET_assert (h->write_task == GNUNET_SCHEDULER_NO_TASK);
       h->write_task =
-        GNUNET_SCHEDULER_add_write_net (h->sched,
-                                        GNUNET_TIME_absolute_get_remaining
+        GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
                                         (h->nth.transmit_timeout), h->sock,
                                         &transmit_ready, h);
     }
@@ -697,9 +677,8 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *h)
       h->ccs -= COCO_DESTROY_CONTINUATION;
       GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->destroy_task);
       h->destroy_task
-	= GNUNET_SCHEDULER_add_now (h->sched,
-				    &destroy_continuation,
-				    h);
+	= GNUNET_SCHEDULER_add_now (&destroy_continuation,
+				                h);
     }
 }
 
@@ -749,7 +728,7 @@ connect_probe_continuation (void *cls,
   while (NULL != (pos = h->ap_head))
     {
       GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (pos->sock));
-      GNUNET_SCHEDULER_cancel (h->sched, pos->task);
+      GNUNET_SCHEDULER_cancel (pos->task);
       GNUNET_CONTAINER_DLL_remove (h->ap_head, h->ap_tail, pos);
       GNUNET_free (pos);
     }
@@ -842,7 +821,7 @@ try_connect_using_address (void *cls,
                                       GNUNET_TIME_absolute_get_remaining
                                       (h->receive_timeout));
   ap->task =
-    GNUNET_SCHEDULER_add_write_net (h->sched, delay, ap->sock,
+    GNUNET_SCHEDULER_add_write_net (delay, ap->sock,
                                     &connect_probe_continuation, ap);
 }
 
@@ -852,15 +831,13 @@ try_connect_using_address (void *cls,
  * This function returns immediately, even if the connection has not
  * yet been established.  This function only creates TCP connections.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param hostname name of the host to connect to
  * @param port port to connect to
  * @return the socket handle
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
-                                       const struct
+GNUNET_CONNECTION_create_from_connect (const struct
                                        GNUNET_CONFIGURATION_Handle *cfg,
                                        const char *hostname, uint16_t port)
 {
@@ -869,13 +846,11 @@ GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
   GNUNET_assert (0 < strlen (hostname));        /* sanity check */
   ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
   ret->cfg = cfg;
-  ret->sched = sched;
   ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
   ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
   ret->port = port;
   ret->hostname = GNUNET_strdup (hostname);
-  ret->dns_active = GNUNET_RESOLVER_ip_get (sched,
-                                            cfg,
+  ret->dns_active = GNUNET_RESOLVER_ip_get (cfg,
                                             ret->hostname,
                                             AF_UNSPEC,
                                             GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT,
@@ -889,14 +864,12 @@ GNUNET_CONNECTION_create_from_connect (struct GNUNET_SCHEDULER_Handle *sched,
  * This function returns immediately, even if the connection has not
  * yet been established.  This function only creates UNIX connections.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param unixpath path to connect to
  * @return the socket handle, NULL on systems without UNIX support
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handle *sched,
-						   const struct
+GNUNET_CONNECTION_create_from_connect_to_unixpath (const struct
 						   GNUNET_CONFIGURATION_Handle *cfg,
 						   const char *unixpath)
 {
@@ -922,7 +895,6 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handl
 #endif
   ret = GNUNET_malloc (sizeof (struct GNUNET_CONNECTION_Handle));
   ret->cfg = cfg;
-  ret->sched = sched;
   ret->write_buffer_size = GNUNET_SERVER_MIN_BUFFER_SIZE;
   ret->write_buffer = GNUNET_malloc(ret->write_buffer_size);
   ret->port = 0;
@@ -960,15 +932,13 @@ GNUNET_CONNECTION_create_from_connect_to_unixpath (struct GNUNET_SCHEDULER_Handl
  * This function returns immediately, even if the connection has not
  * yet been established.  This function only creates TCP connections.
  *
- * @param sched scheduler to use
  * @param af_family address family to use
  * @param serv_addr server address
  * @param addrlen length of server address
  * @return the socket handle
  */
 struct GNUNET_CONNECTION_Handle *
-GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
-                                        *sched, int af_family,
+GNUNET_CONNECTION_create_from_sockaddr (int af_family,
                                         const struct sockaddr *serv_addr,
                                         socklen_t addrlen)
 {
@@ -990,7 +960,7 @@ GNUNET_CONNECTION_create_from_sockaddr (struct GNUNET_SCHEDULER_Handle
       GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s));
       return NULL;
     }
-  ret = GNUNET_CONNECTION_create_from_existing (sched, s);
+  ret = GNUNET_CONNECTION_create_from_existing (s);
   ret->addr = GNUNET_malloc (addrlen);
   memcpy (ret->addr, serv_addr, addrlen);
   ret->addrlen = addrlen;
@@ -1041,8 +1011,7 @@ GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *sock,
     {
       if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
 	{
-	  GNUNET_SCHEDULER_cancel (sock->sched,
-				   sock->write_task);
+	  GNUNET_SCHEDULER_cancel (sock->write_task);
 	  sock->write_task = GNUNET_SCHEDULER_NO_TASK;
 	  sock->write_buffer_off = 0;
 	}
@@ -1052,11 +1021,10 @@ GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *sock,
       GNUNET_RESOLVER_request_cancel (sock->dns_active);
       sock->dns_active = NULL;
     }
-  GNUNET_assert (sock->sched != NULL);
+
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == sock->destroy_task);
   sock->destroy_task 
-    = GNUNET_SCHEDULER_add_now (sock->sched,
-				&destroy_continuation, sock);
+    = GNUNET_SCHEDULER_add_now (&destroy_continuation, sock);
 }
 
 
@@ -1113,8 +1081,7 @@ receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
 		  "Ignoring shutdown signal per configuration\n");
 #endif
-      sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched,
-						     GNUNET_TIME_absolute_get_remaining
+      sh->read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining
 						     (sh->receive_timeout),
 						     sh->sock,
 						     &receive_ready, sh);
@@ -1212,8 +1179,7 @@ receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     }
   GNUNET_assert (sh->sock != NULL);
   /* connect succeeded, wait for data! */
-  sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched,
-                                                 GNUNET_TIME_absolute_get_remaining
+  sh->read_task = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_absolute_get_remaining
                                                  (sh->receive_timeout),
                                                  sh->sock,
                                                  &receive_ready, sh);
@@ -1252,7 +1218,6 @@ GNUNET_CONNECTION_receive (struct GNUNET_CONNECTION_Handle *sock,
   if (sock->sock != NULL)
     {
       memset (&tc, 0, sizeof (tc));
-      tc.sched = sock->sched;
       tc.reason = GNUNET_SCHEDULER_REASON_PREREQ_DONE;
       receive_again (sock, &tc);
       return;
@@ -1293,8 +1258,7 @@ GNUNET_CONNECTION_receive_cancel (struct GNUNET_CONNECTION_Handle *sock)
 {
   if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->sched,
-                                                      sock->read_task));
+      GNUNET_assert (sock == GNUNET_SCHEDULER_cancel (sock->read_task));
       sock->read_task = GNUNET_SCHEDULER_NO_TASK;
     }
   else
@@ -1421,8 +1385,7 @@ transmit_error (struct GNUNET_CONNECTION_Handle *sock)
     }
   if (sock->read_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_SCHEDULER_cancel (sock->sched,
-			       sock->read_task);
+      GNUNET_SCHEDULER_cancel (sock->read_task);
       sock->read_task = GNUNET_SCHEDULER_NO_TASK;
       signal_timeout (sock);
       return;
@@ -1567,8 +1530,7 @@ SCHEDULE_WRITE:
 #endif
   if (sock->write_task == GNUNET_SCHEDULER_NO_TASK)
     sock->write_task =
-      GNUNET_SCHEDULER_add_write_net (tc->sched,
-                                      GNUNET_TIME_absolute_get_remaining
+      GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
                                       (sock->nth.transmit_timeout),
                                       sock->sock, &transmit_ready, sock);
 }
@@ -1612,10 +1574,8 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
       (sock->ap_head == NULL) && (sock->dns_active == NULL))
     {
       if (sock->write_task != GNUNET_SCHEDULER_NO_TASK)
-	GNUNET_SCHEDULER_cancel (sock->sched,
-				 sock->write_task);
-      sock->write_task = GNUNET_SCHEDULER_add_now (sock->sched,
-						   &connect_error, sock);
+	GNUNET_SCHEDULER_cancel (sock->write_task);
+      sock->write_task = GNUNET_SCHEDULER_add_now (&connect_error, sock);
       return &sock->nth;
     }
   if (GNUNET_SCHEDULER_NO_TASK != sock->write_task)
@@ -1626,8 +1586,7 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                   "Scheduling transmit_ready (%p).\n", sock);
 #endif
-      sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched,
-                                                         GNUNET_TIME_absolute_get_remaining
+      sock->write_task = GNUNET_SCHEDULER_add_write_net (GNUNET_TIME_absolute_get_remaining
                                                          (sock->nth.
                                                           transmit_timeout),
                                                          sock->sock,
@@ -1642,8 +1601,7 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle
                   sock);
 #endif
       sock->ccs |= COCO_TRANSMIT_READY;
-      sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched,
-                                                             timeout,
+      sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (timeout,
                                                              &transmit_timeout,
                                                              sock);
     }
@@ -1668,7 +1626,7 @@ GNUNET_CONNECTION_notify_transmit_ready_cancel (struct
                   "notify_transmit_ready_cancel cancels timeout_task (%p)\n",
                   h);
 #endif
-      GNUNET_SCHEDULER_cancel (h->sh->sched, h->timeout_task);
+      GNUNET_SCHEDULER_cancel (h->timeout_task);
       h->timeout_task = GNUNET_SCHEDULER_NO_TASK;
       h->sh->ccs -= COCO_TRANSMIT_READY;
     }
@@ -1676,7 +1634,7 @@ GNUNET_CONNECTION_notify_transmit_ready_cancel (struct
     {
       if (h->sh->write_task != GNUNET_SCHEDULER_NO_TASK)
 	{
-	  GNUNET_SCHEDULER_cancel (h->sh->sched, h->sh->write_task);
+	  GNUNET_SCHEDULER_cancel (h->sh->write_task);
 	  h->sh->write_task = GNUNET_SCHEDULER_NO_TASK;
 	}
     }
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c
index ab6fc28cfc..9e5af4ab51 100644
--- a/src/util/crypto_hash.c
+++ b/src/util/crypto_hash.c
@@ -83,11 +83,6 @@ struct GNUNET_CRYPTO_FileHashContext
   struct GNUNET_DISK_FileHandle *fh;
 
   /**
-   * Our scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-
-  /**
    * Cummulated hash.
    */
   gcry_md_hd_t md;
@@ -166,8 +161,7 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       return;
     }
   fhc->task 
-    = GNUNET_SCHEDULER_add_after (tc->sched,
-				  GNUNET_SCHEDULER_NO_TASK, 
+    = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
 				  &file_hash_task, fhc);
 }
 
@@ -175,7 +169,6 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 /**
  * Compute the hash of an entire file.
  *
- * @param sched scheduler to use
  * @param priority scheduling priority to use
  * @param filename name of file to hash
  * @param blocksize number of bytes to process in one task
@@ -184,8 +177,7 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return NULL on (immediate) errror
  */
 struct GNUNET_CRYPTO_FileHashContext *
-GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
-                         enum GNUNET_SCHEDULER_Priority priority,
+GNUNET_CRYPTO_hash_file (enum GNUNET_SCHEDULER_Priority priority,
                          const char *filename,
                          size_t blocksize,
                          GNUNET_CRYPTO_HashCompletedCallback callback,
@@ -197,7 +189,6 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
   fhc = GNUNET_malloc (sizeof (struct GNUNET_CRYPTO_FileHashContext) + blocksize);
   fhc->callback = callback;
   fhc->callback_cls = callback_cls;
-  fhc->sched = sched;
   fhc->buffer = (unsigned char *) &fhc[1];
   fhc->filename = GNUNET_strdup (filename);
   if (GPG_ERR_NO_ERROR != gcry_md_open (&fhc->md, GCRY_MD_SHA512, 0))
@@ -223,7 +214,7 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
       return NULL;
     }
   fhc->task 
-    = GNUNET_SCHEDULER_add_with_priority (sched, priority, 
+    = GNUNET_SCHEDULER_add_with_priority (priority,
 					  &file_hash_task, fhc);
   return fhc;
 }
@@ -237,8 +228,7 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched,
 void
 GNUNET_CRYPTO_hash_file_cancel (struct GNUNET_CRYPTO_FileHashContext *fhc)
 {
-  GNUNET_SCHEDULER_cancel (fhc->sched,
-			   fhc->task);
+  GNUNET_SCHEDULER_cancel (fhc->task);
   GNUNET_free (fhc->filename);
   GNUNET_break (GNUNET_OK == GNUNET_DISK_file_close (fhc->fh));
   GNUNET_free (fhc);
diff --git a/src/util/disk.c b/src/util/disk.c
index 265295922f..307c4535bf 100644
--- a/src/util/disk.c
+++ b/src/util/disk.c
@@ -810,10 +810,6 @@ GNUNET_DISK_directory_scan (const char *dirName,
  */
 struct GNUNET_DISK_DirectoryIterator
 {
-  /**
-   * Our scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
 
   /**
    * Function to call on directory entries.
@@ -906,8 +902,7 @@ GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator
       GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES);
       return GNUNET_NO;
     }
-  GNUNET_SCHEDULER_add_with_priority (iter->sched,
-                                      iter->priority,
+  GNUNET_SCHEDULER_add_with_priority (iter->priority,
                                       &directory_iterator_task, iter);
   return GNUNET_YES;
 }
@@ -919,15 +914,13 @@ GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator
  * If a scheduler does not need to be used, GNUNET_DISK_directory_scan
  * may provide a simpler API.
  *
- * @param sched scheduler to use
  * @param prio priority to use
  * @param dirName the name of the directory
  * @param callback the method to call for each file
  * @param callback_cls closure for callback
  */
 void
-GNUNET_DISK_directory_iterator_start (struct GNUNET_SCHEDULER_Handle *sched,
-                                      enum GNUNET_SCHEDULER_Priority prio,
+GNUNET_DISK_directory_iterator_start (enum GNUNET_SCHEDULER_Priority prio,
                                       const char *dirName,
                                       GNUNET_DISK_DirectoryIteratorCallback
                                       callback, void *callback_cls)
@@ -935,7 +928,6 @@ GNUNET_DISK_directory_iterator_start (struct GNUNET_SCHEDULER_Handle *sched,
   struct GNUNET_DISK_DirectoryIterator *di;
 
   di = GNUNET_malloc (sizeof (struct GNUNET_DISK_DirectoryIterator));
-  di->sched = sched;
   di->callback = callback;
   di->callback_cls = callback_cls;
   di->directory = OPENDIR (dirName);
diff --git a/src/util/gnunet-resolver.c b/src/util/gnunet-resolver.c
index 9686d3a068..18ce232f2d 100644
--- a/src/util/gnunet-resolver.c
+++ b/src/util/gnunet-resolver.c
@@ -49,21 +49,19 @@ printer (void *cls,
  * Main function that will be run by the scheduler.
  *
  * @param cls closure
- * @param sched the scheduler to use
  * @param args remaining command-line arguments
  * @param cfgfile name of the configuration file used (for saving, can be NULL!)
  * @param cfg configuration
  */
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *sched,
      char *const *args,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   if (args[0] == NULL)
     return;
-  GNUNET_RESOLVER_ip_get (sched, cfg,
+  GNUNET_RESOLVER_ip_get (cfg,
 			  args[0],
 			  AF_UNSPEC,
 			  GET_TIMEOUT,
diff --git a/src/util/gnunet-service-resolver.c b/src/util/gnunet-service-resolver.c
index b0e2f0be4f..68d2daae72 100644
--- a/src/util/gnunet-service-resolver.c
+++ b/src/util/gnunet-service-resolver.c
@@ -477,13 +477,11 @@ handle_get (void *cls,
  * Process resolver requests.
  *
  * @param cls closure
- * @param sched scheduler to use
  * @param server the initialized server
  * @param cfg configuration to use
  */
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *sched,
      struct GNUNET_SERVER_Handle *server,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
diff --git a/src/util/program.c b/src/util/program.c
index 9a5ee8833f..6f8467837d 100644
--- a/src/util/program.c
+++ b/src/util/program.c
@@ -77,7 +77,7 @@ program_main (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct CommandContext *cc = cls;
 
-  cc->task (cc->task_cls, tc->sched, cc->args, cc->cfgfile, cc->cfg);
+  cc->task (cc->task_cls, cc->args, cc->cfgfile, cc->cfg);
 }
 
 
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c
index f4832ed9c8..7daaaf1cce 100644
--- a/src/util/resolver_api.c
+++ b/src/util/resolver_api.c
@@ -80,11 +80,6 @@ struct GNUNET_RESOLVER_RequestHandle
   struct GNUNET_CLIENT_Connection *client;
 
   /**
-   * Our scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-
-  /**
    * Name of the host that we are resolving.
    */
   const char *hostname;
@@ -401,7 +396,6 @@ loopback_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 /**
  * Convert a string to one or more IP addresses.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param hostname the hostname to resolve
  * @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
@@ -411,8 +405,7 @@ loopback_resolution (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
-                        const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_RESOLVER_ip_get (const struct GNUNET_CONFIGURATION_Handle *cfg,
                         const char *hostname,
                         int domain,
                         struct GNUNET_TIME_Relative timeout,
@@ -436,7 +429,6 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
       return NULL;
     }
   rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + slen);
-  rh->sched = sched;
   rh->domain = domain;
   rh->addr_callback = callback;
   rh->cls = callback_cls;
@@ -454,8 +446,7 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
                         &v6)) &&
        ((domain == AF_INET6) || (domain == AF_UNSPEC))))
     {
-      rh->task = GNUNET_SCHEDULER_add_now (sched,
-					   &numeric_resolution, rh);
+      rh->task = GNUNET_SCHEDULER_add_now (&numeric_resolution, rh);
       return rh;
     }
   /* then, check if this is a loopback address */
@@ -463,12 +454,11 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched,
   while (loopback[i] != NULL)
     if (0 == strcasecmp (loopback[i++], hostname))
       {
-        rh->task = GNUNET_SCHEDULER_add_now (sched,
-					     &loopback_resolution, rh);
+        rh->task = GNUNET_SCHEDULER_add_now (&loopback_resolution, rh);
         return rh;
       }
 
-  client = GNUNET_CLIENT_connect (sched, "resolver", cfg);
+  client = GNUNET_CLIENT_connect ("resolver", cfg);
   if (client == NULL)
     {
       GNUNET_free (rh);
@@ -595,7 +585,6 @@ numeric_reverse (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 /**
  * Get an IP address as a string.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param sa host address
  * @param salen length of host address
@@ -606,8 +595,7 @@ numeric_reverse (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return handle that can be used to cancel the request
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
-                              const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_RESOLVER_hostname_get (const struct GNUNET_CONFIGURATION_Handle *cfg,
                               const struct sockaddr *sa,
                               socklen_t salen,
                               int do_resolve,
@@ -625,14 +613,12 @@ GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
   rh->name_callback = callback;
   rh->cls = cls;
   rh->timeout = GNUNET_TIME_relative_to_absolute (timeout);
-  rh->sched = sched;
   rh->salen = salen;
   memcpy (&rh[1], sa, salen);
 
   if (GNUNET_NO == do_resolve)
     {
-      rh->task = GNUNET_SCHEDULER_add_now (sched,
-					   &numeric_reverse, rh);
+      rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse, rh);
       return rh;
     }
   if (salen + sizeof (struct GNUNET_RESOLVER_GetMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE)
@@ -641,7 +627,7 @@ GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched,
       GNUNET_free (rh);
       return NULL;
     }
-  client = GNUNET_CLIENT_connect (sched, "resolver", cfg);
+  client = GNUNET_CLIENT_connect ("resolver", cfg);
   if (client == NULL)
     {
       GNUNET_free (rh);
@@ -710,7 +696,6 @@ GNUNET_RESOLVER_local_fqdn_get ( void )
 /**
  * Looking our own hostname.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param domain AF_INET or AF_INET6; use AF_UNSPEC for "any"
  * @param callback function to call with addresses
@@ -719,8 +704,7 @@ GNUNET_RESOLVER_local_fqdn_get ( void )
  * @return handle that can be used to cancel the request, NULL on error
  */
 struct GNUNET_RESOLVER_RequestHandle *
-GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
-                                  const struct GNUNET_CONFIGURATION_Handle
+GNUNET_RESOLVER_hostname_resolve (const struct GNUNET_CONFIGURATION_Handle
                                   *cfg, int domain,
                                   struct GNUNET_TIME_Relative timeout,
                                   GNUNET_RESOLVER_AddressCallback callback,
@@ -739,8 +723,7 @@ GNUNET_RESOLVER_hostname_resolve (struct GNUNET_SCHEDULER_Handle *sched,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               _("Resolving our hostname `%s'\n"), hostname);
 #endif
-  return GNUNET_RESOLVER_ip_get (sched,
-                                 cfg, hostname, domain, timeout, callback,
+  return GNUNET_RESOLVER_ip_get (cfg, hostname, domain, timeout, callback,
                                  cls);
 }
 
@@ -759,7 +742,7 @@ GNUNET_RESOLVER_request_cancel (struct GNUNET_RESOLVER_RequestHandle *h)
   if (h->client != NULL)
     GNUNET_CLIENT_disconnect (h->client, GNUNET_NO);
   if (h->task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (h->sched, h->task);
+    GNUNET_SCHEDULER_cancel (h->task);
   GNUNET_free (h);
 }
 
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 9b8ab4b296..341400bba1 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -163,84 +163,76 @@ struct Task
 
 
 /**
- * Handle for the scheduling service.
- */
-struct GNUNET_SCHEDULER_Handle
-{
-
-  /**
-   * List of tasks waiting for an event.
-   */
-  struct Task *pending;
-
-  /**
-   * List of tasks waiting ONLY for a timeout event.
-   * Sorted by timeout (earliest first).  Used so that
-   * we do not traverse the list of these tasks when
-   * building select sets (we just look at the head
-   * to determine the respective timeout ONCE).
-   */
-  struct Task *pending_timeout;
+* List of tasks waiting for an event.
+*/
+struct Task *pending;
 
-  /**
-   * Last inserted task waiting ONLY for a timeout event.
-   * Used to (heuristically) speed up insertion.
-   */
-  struct Task *pending_timeout_last;
+/**
+* List of tasks waiting ONLY for a timeout event.
+* Sorted by timeout (earliest first).  Used so that
+* we do not traverse the list of these tasks when
+* building select sets (we just look at the head
+* to determine the respective timeout ONCE).
+*/
+struct Task *pending_timeout;
 
-  /**
-   * ID of the task that is running right now.
-   */
-  struct Task *active_task;
+/**
+* Last inserted task waiting ONLY for a timeout event.
+* Used to (heuristically) speed up insertion.
+*/
+struct Task *pending_timeout_last;
 
-  /**
-   * List of tasks ready to run right now,
-   * grouped by importance.
-   */
-  struct Task *ready[GNUNET_SCHEDULER_PRIORITY_COUNT];
+/**
+* ID of the task that is running right now.
+*/
+struct Task *active_task;
 
-  /**
-   * Identity of the last task queued.  Incremented for each task to
-   * generate a unique task ID (it is virtually impossible to start
-   * more than 2^64 tasks during the lifetime of a process).
-   */
-  GNUNET_SCHEDULER_TaskIdentifier last_id;
+/**
+* List of tasks ready to run right now,
+* grouped by importance.
+*/
+struct Task *ready[GNUNET_SCHEDULER_PRIORITY_COUNT];
 
-  /**
-   * Highest number so that all tasks with smaller identifiers
-   * have already completed.  Also the lowest number of a task
-   * still waiting to be executed.
-   */
-  GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id;
+/**
+* Identity of the last task queued.  Incremented for each task to
+* generate a unique task ID (it is virtually impossible to start
+* more than 2^64 tasks during the lifetime of a process).
+*/
+GNUNET_SCHEDULER_TaskIdentifier last_id;
 
-  /**
-   * Number of tasks on the ready list.
-   */
-  unsigned int ready_count;
+/**
+* Highest number so that all tasks with smaller identifiers
+* have already completed.  Also the lowest number of a task
+* still waiting to be executed.
+*/
+GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id;
 
-  /**
-   * How many tasks have we run so far?
-   */
-  unsigned long long tasks_run;
+/**
+* Number of tasks on the ready list.
+*/
+unsigned int ready_count;
 
-  /**
-   * Priority of the task running right now.  Only
-   * valid while a task is running.
-   */
-  enum GNUNET_SCHEDULER_Priority current_priority;
+/**
+* How many tasks have we run so far?
+*/
+unsigned long long tasks_run;
 
-  /**
-   * Priority of the highest task added in the current select
-   * iteration.
-   */
-  enum GNUNET_SCHEDULER_Priority max_priority_added;
+/**
+* Priority of the task running right now.  Only
+* valid while a task is running.
+*/
+enum GNUNET_SCHEDULER_Priority current_priority;
 
-  /**
-   * How 'nice' are we right now?
-   */
-  int nice_level;
+/**
+* Priority of the highest task added in the current select
+* iteration.
+*/
+enum GNUNET_SCHEDULER_Priority max_priority_added;
 
-};
+/**
+* How 'nice' are we right now?
+*/
+int nice_level;
 
 
 /**
@@ -270,17 +262,16 @@ check_priority (enum GNUNET_SCHEDULER_Priority p)
  * @return GNUNET_YES if so, GNUNET_NO if not
  */
 static int
-is_pending (struct GNUNET_SCHEDULER_Handle *sched,
-            GNUNET_SCHEDULER_TaskIdentifier id)
+is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
 {
   struct Task *pos;
   enum GNUNET_SCHEDULER_Priority p;
   GNUNET_SCHEDULER_TaskIdentifier min;
 
-  if (id < sched->lowest_pending_id)
+  if (id < lowest_pending_id)
     return GNUNET_NO;
   min = -1;                     /* maximum value */
-  pos = sched->pending;
+  pos = pending;
   while (pos != NULL)
     {
       if (pos->id == id)
@@ -289,7 +280,7 @@ is_pending (struct GNUNET_SCHEDULER_Handle *sched,
         min = pos->id;
       pos = pos->next;
     }
-  pos = sched->pending_timeout;
+  pos = pending_timeout;
   while (pos != NULL)
     {
       if (pos->id == id)
@@ -300,7 +291,7 @@ is_pending (struct GNUNET_SCHEDULER_Handle *sched,
     }
   for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++)
     {
-      pos = sched->ready[p];
+      pos = ready[p];
       while (pos != NULL)
         {
           if (pos->id == id)
@@ -310,7 +301,7 @@ is_pending (struct GNUNET_SCHEDULER_Handle *sched,
           pos = pos->next;
         }
     }
-  sched->lowest_pending_id = min;
+  lowest_pending_id = min;
   return GNUNET_NO;
 }
 
@@ -324,8 +315,7 @@ is_pending (struct GNUNET_SCHEDULER_Handle *sched,
  * @param timeout next timeout (updated)
  */
 static void
-update_sets (struct GNUNET_SCHEDULER_Handle *sched,
-             struct GNUNET_NETWORK_FDSet *rs,
+update_sets (struct GNUNET_NETWORK_FDSet *rs,
              struct GNUNET_NETWORK_FDSet *ws,
              struct GNUNET_TIME_Relative *timeout)
 {
@@ -334,7 +324,7 @@ update_sets (struct GNUNET_SCHEDULER_Handle *sched,
   struct GNUNET_TIME_Relative to;
 
   now = GNUNET_TIME_absolute_get ();
-  pos = sched->pending_timeout;
+  pos = pending_timeout;
   if (pos != NULL) 
     {
       to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
@@ -343,11 +333,11 @@ update_sets (struct GNUNET_SCHEDULER_Handle *sched,
       if (pos->reason != 0)
         *timeout = GNUNET_TIME_UNIT_ZERO;
     }
-  pos = sched->pending;
+  pos = pending;
   while (pos != NULL)
     {
       if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) &&
-          (GNUNET_YES == is_pending (sched, pos->prereq_id)))
+          (GNUNET_YES == is_pending (pos->prereq_id)))
         {
           pos = pos->next;
           continue;
@@ -411,8 +401,7 @@ set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
  * @return GNUNET_YES if we can run it, GNUNET_NO if not.
  */
 static int
-is_ready (struct GNUNET_SCHEDULER_Handle *sched,
-          struct Task *task,
+is_ready (struct Task *task,
           struct GNUNET_TIME_Absolute now,
           const struct GNUNET_NETWORK_FDSet *rs,
           const struct GNUNET_NETWORK_FDSet *ws)
@@ -436,7 +425,7 @@ is_ready (struct GNUNET_SCHEDULER_Handle *sched,
     return GNUNET_NO;           /* not ready */    
   if (task->prereq_id != GNUNET_SCHEDULER_NO_TASK)
     {
-      if (GNUNET_YES == is_pending (sched, task->prereq_id))
+      if (GNUNET_YES == is_pending (task->prereq_id))
 	{
 	  task->reason = reason;
 	  return GNUNET_NO;       /* prereq waiting */
@@ -455,15 +444,14 @@ is_ready (struct GNUNET_SCHEDULER_Handle *sched,
  * @param task task ready for execution
  */
 static void
-queue_ready_task (struct GNUNET_SCHEDULER_Handle *handle,
-		  struct Task *task)
+queue_ready_task (struct Task *task)
 {
   enum GNUNET_SCHEDULER_Priority p = task->priority;
   if (0 != (task->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     p = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
-  task->next = handle->ready[check_priority (p)];
-  handle->ready[check_priority (p)] = task;
-  handle->ready_count++;
+  task->next = ready[check_priority (p)];
+  ready[check_priority (p)] = task;
+  ready_count++;
 }
 
 
@@ -476,8 +464,7 @@ queue_ready_task (struct GNUNET_SCHEDULER_Handle *handle,
  * @param ws FDs ready for writing
  */
 static void
-check_ready (struct GNUNET_SCHEDULER_Handle *handle,
-             const struct GNUNET_NETWORK_FDSet *rs,
+check_ready (const struct GNUNET_NETWORK_FDSet *rs,
              const struct GNUNET_NETWORK_FDSet *ws)
 {
   struct Task *pos;
@@ -487,7 +474,7 @@ check_ready (struct GNUNET_SCHEDULER_Handle *handle,
 
   now = GNUNET_TIME_absolute_get ();
   prev = NULL;
-  pos = handle->pending_timeout;
+  pos = pending_timeout;
   while (pos != NULL)
     {
       next = pos->next;
@@ -495,13 +482,13 @@ check_ready (struct GNUNET_SCHEDULER_Handle *handle,
 	pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
       if (0 == pos->reason)
 	break;
-      handle->pending_timeout = next;
-      if (handle->pending_timeout_last == pos)
-	handle->pending_timeout_last = NULL;
-      queue_ready_task (handle, pos);
+      pending_timeout = next;
+      if (pending_timeout_last == pos)
+	pending_timeout_last = NULL;
+      queue_ready_task (pos);
       pos = next;
     }
-  pos = handle->pending;
+  pos = pending;
   while (pos != NULL)
     {
 #if DEBUG_TASKS
@@ -510,13 +497,13 @@ check_ready (struct GNUNET_SCHEDULER_Handle *handle,
                   pos->id, pos->callback_cls);
 #endif
       next = pos->next;
-      if (GNUNET_YES == is_ready (handle, pos, now, rs, ws))
+      if (GNUNET_YES == is_ready (pos, now, rs, ws))
         {
           if (prev == NULL)
-            handle->pending = next;
+            pending = next;
           else
             prev->next = next;
-          queue_ready_task (handle, pos);
+          queue_ready_task (pos);
           pos = next;
           continue;
         }
@@ -536,12 +523,12 @@ check_ready (struct GNUNET_SCHEDULER_Handle *handle,
  * @param sched the scheduler
  */
 void
-GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched)
+GNUNET_SCHEDULER_shutdown ()
 {
   struct Task *pos;
   int i;
 
-  pos = sched->pending_timeout;
+  pos = pending_timeout;
   while (pos != NULL)
     {
       pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
@@ -550,7 +537,7 @@ GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched)
          readiness-factors */
       pos = pos->next;
     }
-  pos = sched->pending;
+  pos = pending;
   while (pos != NULL)
     {
       pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
@@ -561,7 +548,7 @@ GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched)
     }
   for (i=0;i<GNUNET_SCHEDULER_PRIORITY_COUNT;i++)
     {
-      pos = sched->ready[i];
+      pos = ready[i];
       while (pos != NULL)
 	{
 	  pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
@@ -605,37 +592,36 @@ destroy_task (struct Task *t)
  * @param ws FDs ready for writing
  */
 static void
-run_ready (struct GNUNET_SCHEDULER_Handle *sched,
-	   struct GNUNET_NETWORK_FDSet *rs,
+run_ready (struct GNUNET_NETWORK_FDSet *rs,
 	   struct GNUNET_NETWORK_FDSet *ws)
 {
   enum GNUNET_SCHEDULER_Priority p;
   struct Task *pos;
   struct GNUNET_SCHEDULER_TaskContext tc;
 
-  sched->max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
+  max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
   do
     {
-      if (sched->ready_count == 0)
+      if (ready_count == 0)
         return;
-      GNUNET_assert (sched->ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
+      GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
       /* yes, p>0 is correct, 0 is "KEEP" which should
          always be an empty queue (see assertion)! */
       for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
         {
-          pos = sched->ready[p];
+          pos = ready[p];
           if (pos != NULL)
             break;
         }
       GNUNET_assert (pos != NULL);      /* ready_count wrong? */
-      sched->ready[p] = pos->next;
-      sched->ready_count--;
-      if (sched->current_priority != pos->priority)
+      ready[p] = pos->next;
+      ready_count--;
+      if (current_priority != pos->priority)
 	{
-	  sched->current_priority = pos->priority;
+	  current_priority = pos->priority;
 	  (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (), pos->priority);
 	}
-      sched->active_task = pos;
+      active_task = pos;
 #if PROFILE_DELAYS
       if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value >
 	  DELAY_THRESHOLD.rel_value)
@@ -646,7 +632,6 @@ run_ready (struct GNUNET_SCHEDULER_Handle *sched,
 		      (unsigned long long) GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value);
 	}
 #endif
-      tc.sched = sched;
       tc.reason = pos->reason;
       tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set; 
       if ( (pos->read_fd != -1) &&
@@ -677,11 +662,11 @@ run_ready (struct GNUNET_SCHEDULER_Handle *sched,
                     i,
                     pos->backtrace_strings[i]);
 #endif
-      sched->active_task = NULL;
+      active_task = NULL;
       destroy_task (pos);
-      sched->tasks_run++;
+      tasks_run++;
     }
-  while ( (sched->pending == NULL) || (p >= sched->max_priority_added) );
+  while ( (pending == NULL) || (p >= max_priority_added) );
 }
 
 /**
@@ -732,7 +717,6 @@ sighandler_shutdown ()
 void
 GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  struct GNUNET_SCHEDULER_Handle sched;
   struct GNUNET_NETWORK_FDSet *rs;
   struct GNUNET_NETWORK_FDSet *ws;
   struct GNUNET_TIME_Relative timeout;
@@ -763,24 +747,22 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown);
   shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown);
 #endif
-  memset (&sched, 0, sizeof (sched));
-  sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
-  GNUNET_SCHEDULER_add_continuation (&sched,
-                                     task,
+  current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
+  GNUNET_SCHEDULER_add_continuation (task,
                                      task_cls,
                                      GNUNET_SCHEDULER_REASON_STARTUP);
   last_tr = 0;
   busy_wait_warning = 0;
-  while ((sched.pending != NULL) || 
-	 (sched.pending_timeout != NULL) ||
-	 (sched.ready_count > 0))
+  while ((pending != NULL) ||
+	 (pending_timeout != NULL) ||
+	 (ready_count > 0))
     {
       GNUNET_NETWORK_fdset_zero (rs);
       GNUNET_NETWORK_fdset_zero (ws);
       timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-      update_sets (&sched, rs, ws, &timeout);
+      update_sets (rs, ws, &timeout);
       GNUNET_NETWORK_fdset_handle_set (rs, pr);
-      if (sched.ready_count > 0)
+      if (ready_count > 0)
         {
           /* no blocking, more work already ready! */
           timeout = GNUNET_TIME_UNIT_ZERO;
@@ -810,22 +792,22 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
                       _("Looks like we're busy waiting...\n"));
           sleep (1);            /* mitigate */
         }
-      check_ready (&sched, rs, ws);
-      run_ready (&sched, rs, ws);
+      check_ready (rs, ws);
+      run_ready (rs, ws);
       if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
         {
           /* consume the signal */
           GNUNET_DISK_file_read (pr, &c, sizeof (c));
           /* mark all active tasks as ready due to shutdown */
-          GNUNET_SCHEDULER_shutdown (&sched);
+          GNUNET_SCHEDULER_shutdown ();
         }
-      if (last_tr == sched.tasks_run)
+      if (last_tr == tasks_run)
         {
           busy_wait_warning++;
         }
       else
         {
-          last_tr = sched.tasks_run;
+          last_tr = tasks_run;
           busy_wait_warning = 0;
         }
     }
@@ -852,9 +834,9 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
  * @return reason(s) why the current task is run
  */
 enum GNUNET_SCHEDULER_Reason
-GNUNET_SCHEDULER_get_reason (struct GNUNET_SCHEDULER_Handle *sched)
+GNUNET_SCHEDULER_get_reason ()
 {
-  return sched->active_task->reason;
+  return active_task->reason;
 }
 
 
@@ -869,18 +851,17 @@ GNUNET_SCHEDULER_get_reason (struct GNUNET_SCHEDULER_Handle *sched)
  * @return number of tasks pending right now
  */
 unsigned int
-GNUNET_SCHEDULER_get_load (struct GNUNET_SCHEDULER_Handle *sched,
-                           enum GNUNET_SCHEDULER_Priority p)
+GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
 {
   struct Task *pos;
   unsigned int ret;
 
   if (p == GNUNET_SCHEDULER_PRIORITY_COUNT)
-    return sched->ready_count;
+    return ready_count;
   if (p == GNUNET_SCHEDULER_PRIORITY_KEEP)
-    p = sched->current_priority;
+    p = current_priority;
   ret = 0;
-  pos = sched->ready[check_priority (p)];
+  pos = ready[check_priority (p)];
   while (pos != NULL)
     {
       pos = pos->next;
@@ -899,8 +880,7 @@ GNUNET_SCHEDULER_get_load (struct GNUNET_SCHEDULER_Handle *sched,
  * @return original closure of the task
  */
 void *
-GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
-                         GNUNET_SCHEDULER_TaskIdentifier task)
+GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
 {
   struct Task *t;
   struct Task *prev;
@@ -910,7 +890,7 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
 
   to = 0;
   prev = NULL;
-  t = sched->pending;
+  t = pending;
   while (t != NULL)
     {
       if (t->id == task)
@@ -922,7 +902,7 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
     {
       prev = NULL;
       to = 1;
-      t = sched->pending_timeout;
+      t = pending_timeout;
       while (t != NULL)
 	{
 	  if (t->id == task)
@@ -930,8 +910,8 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
 	  prev = t;
 	  t = t->next;
 	}
-      if (sched->pending_timeout_last == t)
-	sched->pending_timeout_last = NULL;
+      if (pending_timeout_last == t)
+	pending_timeout_last = NULL;
     }
   p = 0;
   while (t == NULL)
@@ -939,12 +919,12 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
       p++;
       GNUNET_assert (p < GNUNET_SCHEDULER_PRIORITY_COUNT);
       prev = NULL;
-      t = sched->ready[p];
+      t = ready[p];
       while (t != NULL)
         {
           if (t->id == task)
             {
-              sched->ready_count--;
+              ready_count--;
               break;
             }
           prev = t;
@@ -957,16 +937,16 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
 	{
 	  if (to == 0)
 	    {
-	      sched->pending = t->next;
+	      pending = t->next;
 	    }
 	  else
 	    {
-	      sched->pending_timeout = t->next;
+	      pending_timeout = t->next;
 	    }
 	}
       else
 	{
-	  sched->ready[p] = t->next;
+	  ready[p] = t->next;
 	}
     }
   else
@@ -994,8 +974,7 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched,
  * @param reason reason for task invocation
  */
 void
-GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched,
-                                   GNUNET_SCHEDULER_Task task,
+GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task,
                                    void *task_cls,
                                    enum GNUNET_SCHEDULER_Reason reason)
 {
@@ -1012,18 +991,18 @@ GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched,
   t->write_fd = -1;
   t->callback = task;
   t->callback_cls = task_cls;
-  t->id = ++sched->last_id;
+  t->id = ++last_id;
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->reason = reason;
-  t->priority = sched->current_priority;
+  t->priority = current_priority;
 #if DEBUG_TASKS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Adding continuation task: %llu / %p\n",
               t->id, t->callback_cls);
 #endif
-  queue_ready_task (sched, t);
+  queue_ready_task (t);
 }
 
 
@@ -1046,12 +1025,10 @@ GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
-                            GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
                             GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (sched,
-                                      GNUNET_SCHEDULER_PRIORITY_KEEP,
+  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
                                       prerequisite_task,
                                       GNUNET_TIME_UNIT_ZERO,
                                       NULL, NULL, task, task_cls);
@@ -1069,13 +1046,11 @@ GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle * sched,
-                                    enum GNUNET_SCHEDULER_Priority prio,
+GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
                                     GNUNET_SCHEDULER_Task task,
                                     void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (sched,
-                                      prio,
+  return GNUNET_SCHEDULER_add_select (prio,
                                       GNUNET_SCHEDULER_NO_TASK,
                                       GNUNET_TIME_UNIT_ZERO,
                                       NULL, NULL, task, task_cls);
@@ -1097,8 +1072,7 @@ GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle * sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
-                              struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
                               GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if 1
@@ -1120,15 +1094,15 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
-  t->id = ++sched->last_id;
+  t->id = ++last_id;
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
-  t->priority = sched->current_priority;
+  t->priority = current_priority;
   /* try tail first (optimization in case we are
      appending to a long list of tasks with timeouts) */
-  prev = sched->pending_timeout_last;
+  prev = pending_timeout_last;
   if (prev != NULL) 
     {
       if (prev->timeout.abs_value > t->timeout.abs_value)
@@ -1139,7 +1113,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
   if (prev == NULL)
     {
       /* heuristic failed, do traversal of timeout list */
-      pos = sched->pending_timeout;
+      pos = pending_timeout;
     }
   while ( (pos != NULL) &&
 	  ( (pos->timeout.abs_value <= t->timeout.abs_value) ||
@@ -1149,12 +1123,12 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
       pos = pos->next;
     }
   if (prev == NULL)
-    sched->pending_timeout = t;
+    pending_timeout = t;
   else
     prev->next = t;
   t->next = pos;
   /* hyper-optimization... */
-  sched->pending_timeout_last = t;
+  pending_timeout_last = t;
 
 #if DEBUG_TASKS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1194,12 +1168,10 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_now (struct GNUNET_SCHEDULER_Handle *sched,
-			  GNUNET_SCHEDULER_Task task,
-			  void *task_cls)
+GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task,
+						  void *task_cls)
 {
-  return GNUNET_SCHEDULER_add_select (sched,
-                                      GNUNET_SCHEDULER_PRIORITY_KEEP,
+  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
                                       GNUNET_SCHEDULER_NO_TASK,
 				      GNUNET_TIME_UNIT_ZERO,
                                       NULL, NULL, task, task_cls);
@@ -1236,8 +1208,7 @@ GNUNET_SCHEDULER_add_now (struct GNUNET_SCHEDULER_Handle *sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-add_without_sets (struct GNUNET_SCHEDULER_Handle * sched,
-		  struct GNUNET_TIME_Relative delay,
+add_without_sets (struct GNUNET_TIME_Relative delay,
 		  int rfd,
 		  int wfd,
 		  GNUNET_SCHEDULER_Task task, void *task_cls)
@@ -1257,16 +1228,16 @@ add_without_sets (struct GNUNET_SCHEDULER_Handle * sched,
 #endif
   t->read_fd = rfd;
   t->write_fd = wfd;
-  t->id = ++sched->last_id;
+  t->id = ++last_id;
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->prereq_id = GNUNET_SCHEDULER_NO_TASK;
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
-  t->priority = check_priority (sched->current_priority);
-  t->next = sched->pending;
-  sched->pending = t;
-  sched->max_priority_added = GNUNET_MAX (sched->max_priority_added,
+  t->priority = check_priority (current_priority);
+  t->next = pending;
+  pending = t;
+  max_priority_added = GNUNET_MAX (max_priority_added,
 					  t->priority);
 #if DEBUG_TASKS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -1305,13 +1276,11 @@ add_without_sets (struct GNUNET_SCHEDULER_Handle * sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched,
-                               struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
                                struct GNUNET_NETWORK_Handle * rfd,
                                GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  return add_without_sets (sched,
-			   delay,
+  return add_without_sets (delay,
 			   GNUNET_NETWORK_get_fd (rfd),
 			   -1,
 			   task,
@@ -1337,13 +1306,11 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched,
-                                struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
                                 struct GNUNET_NETWORK_Handle * wfd,
                                 GNUNET_SCHEDULER_Task task, void *task_cls)
 {
-  return add_without_sets (sched,
-			   delay,
+  return add_without_sets (delay,
 			   -1,
 			   GNUNET_NETWORK_get_fd (wfd),
 			   task,
@@ -1369,8 +1336,7 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched,
-                                struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
                                 const struct GNUNET_DISK_FileHandle * rfd,
                                 GNUNET_SCHEDULER_Task task, void *task_cls)
 {
@@ -1391,8 +1357,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched,
   int fd;
 
   GNUNET_DISK_internal_file_handle_ (rfd, &fd, sizeof (int));
-  return add_without_sets (sched,
-			   delay,
+  return add_without_sets (delay,
 			   fd,
 			   -1,
 			   task,
@@ -1420,8 +1385,7 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched,
-                                 struct GNUNET_TIME_Relative delay,
+GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
                                  const struct GNUNET_DISK_FileHandle * wfd,
                                  GNUNET_SCHEDULER_Task task, void *task_cls)
 {
@@ -1442,8 +1406,7 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched,
   int fd;
 
   GNUNET_DISK_internal_file_handle_ (wfd, &fd, sizeof (int));
-  return add_without_sets (sched,
-			   delay,
+  return add_without_sets (delay,
 			   -1,
 			   fd,
 			   task,
@@ -1488,8 +1451,7 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched,
  *         only valid until "task" is started!
  */
 GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched,
-                             enum GNUNET_SCHEDULER_Priority prio,
+GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                              GNUNET_SCHEDULER_TaskIdentifier
                              prerequisite_task,
                              struct GNUNET_TIME_Relative delay,
@@ -1522,7 +1484,7 @@ GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched,
       t->write_set = GNUNET_NETWORK_fdset_create ();
       GNUNET_NETWORK_fdset_copy (t->write_set, ws);
     }
-  t->id = ++sched->last_id;
+  t->id = ++last_id;
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
@@ -1530,11 +1492,11 @@ GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched,
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
   t->priority =
     check_priority ((prio ==
-                     GNUNET_SCHEDULER_PRIORITY_KEEP) ? sched->current_priority
+                     GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority
                     : prio);
-  t->next = sched->pending; 
-  sched->pending = t;
-  sched->max_priority_added = GNUNET_MAX (sched->max_priority_added,
+  t->next = pending;
+  pending = t;
+  max_priority_added = GNUNET_MAX (max_priority_added,
 					  t->priority);
 #if DEBUG_TASKS
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
diff --git a/src/util/server.c b/src/util/server.c
index 516885fedf..f586e42043 100644
--- a/src/util/server.c
+++ b/src/util/server.c
@@ -80,11 +80,6 @@ struct NotifyList
 struct GNUNET_SERVER_Handle
 {
   /**
-   * My scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-
-  /**
    * List of handlers for incoming messages.
    */
   struct HandlerList *handlers;
@@ -249,8 +244,7 @@ process_listen_socket (void *cls,
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
     {
       /* ignore shutdown, someone else will take care of it! */
-      server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
-                                                         GNUNET_SCHEDULER_PRIORITY_HIGH,
+      server->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                                          GNUNET_SCHEDULER_NO_TASK,
                                                          GNUNET_TIME_UNIT_FOREVER_REL,
                                                          r, NULL,
@@ -266,7 +260,7 @@ process_listen_socket (void *cls,
           (tc->read_ready, server->listen_sockets[i]))
         {
           sock =
-            GNUNET_CONNECTION_create_from_accept (tc->sched, server->access,
+            GNUNET_CONNECTION_create_from_accept (server->access,
                                                   server->access_cls,
                                                   server->listen_sockets[i]);
           if (sock != NULL)
@@ -285,8 +279,7 @@ process_listen_socket (void *cls,
       i++;
     }
   /* listen for more! */
-  server->listen_task = GNUNET_SCHEDULER_add_select (server->sched,
-                                                     GNUNET_SCHEDULER_PRIORITY_HIGH,
+  server->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                                      GNUNET_SCHEDULER_NO_TASK,
                                                      GNUNET_TIME_UNIT_FOREVER_REL,
                                                      r, NULL,
@@ -386,7 +379,6 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
 /**
  * Create a new server.
  *
- * @param sched scheduler to use
  * @param access function for access control
  * @param access_cls closure for access
  * @param lsocks NULL-terminated array of listen sockets
@@ -397,8 +389,7 @@ open_listen_socket (const struct sockaddr *serverAddr, socklen_t socklen)
  *         (typically, "port" already in use)
  */
 struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
-				   GNUNET_CONNECTION_AccessCheck access, void *access_cls,
+GNUNET_SERVER_create_with_sockets (GNUNET_CONNECTION_AccessCheck access, void *access_cls,
 				   struct GNUNET_NETWORK_Handle **lsocks,
 				   struct GNUNET_TIME_Relative
 				   idle_timeout,
@@ -409,7 +400,6 @@ GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
   int i;
 
   ret = GNUNET_malloc (sizeof (struct GNUNET_SERVER_Handle));
-  ret->sched = sched;
   ret->idle_timeout = idle_timeout;
   ret->listen_sockets = lsocks;
   ret->access = access;
@@ -421,8 +411,7 @@ GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
       i = 0;
       while (NULL != ret->listen_sockets[i])
         GNUNET_NETWORK_fdset_set (r, ret->listen_sockets[i++]);
-      ret->listen_task = GNUNET_SCHEDULER_add_select (sched,
-                                                      GNUNET_SCHEDULER_PRIORITY_HIGH,
+      ret->listen_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_HIGH,
                                                       GNUNET_SCHEDULER_NO_TASK,
                                                       GNUNET_TIME_UNIT_FOREVER_REL,
                                                       r, NULL,
@@ -437,7 +426,6 @@ GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
 /**
  * Create a new server.
  *
- * @param sched scheduler to use
  * @param access function for access control
  * @param access_cls closure for access
  * @param serverAddr address to listen on (including port), NULL terminated array
@@ -449,8 +437,7 @@ GNUNET_SERVER_create_with_sockets (struct GNUNET_SCHEDULER_Handle *sched,
  *         (typically, "port" already in use)
  */
 struct GNUNET_SERVER_Handle *
-GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
-                      GNUNET_CONNECTION_AccessCheck access,
+GNUNET_SERVER_create (GNUNET_CONNECTION_AccessCheck access,
                       void *access_cls,
                       struct sockaddr *const *serverAddr,
                       const socklen_t * socklen,
@@ -489,8 +476,7 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched,
     {
       lsocks = NULL;
     }
-  return GNUNET_SERVER_create_with_sockets (sched,
-					    access, access_cls,
+  return GNUNET_SERVER_create_with_sockets (access, access_cls,
 					    lsocks,
 					    idle_timeout,
 					    require_found);
@@ -514,7 +500,7 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s)
 #endif
   if (GNUNET_SCHEDULER_NO_TASK != s->listen_task)
     {
-      GNUNET_SCHEDULER_cancel (s->sched, s->listen_task);
+      GNUNET_SCHEDULER_cancel (s->listen_task);
       s->listen_task = GNUNET_SCHEDULER_NO_TASK;
     }
   if (s->listen_sockets != NULL)
@@ -1023,8 +1009,7 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
 #endif
   if (client->restart_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_SCHEDULER_cancel (client->server->sched,
-			       client->restart_task);
+      GNUNET_SCHEDULER_cancel (client->restart_task);
       client->restart_task = GNUNET_SCHEDULER_NO_TASK;
     }
   if (GNUNET_YES == client->receive_pending)
@@ -1053,8 +1038,7 @@ GNUNET_SERVER_client_disconnect (struct GNUNET_SERVER_Client *client)
         prev->next = pos->next;
       if (client->restart_task != GNUNET_SCHEDULER_NO_TASK)
 	{
-	  GNUNET_SCHEDULER_cancel (server->sched,
-				   client->restart_task);
+	  GNUNET_SCHEDULER_cancel (client->restart_task);
 	  client->restart_task = GNUNET_SCHEDULER_NO_TASK;
 	}
       n = server->disconnect_notify_list;
@@ -1182,8 +1166,7 @@ GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success)
 	      "GNUNET_SERVER_receive_done causes restart in reading from the socket\n");
 #endif
   GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == client->restart_task);
-  client->restart_task = GNUNET_SCHEDULER_add_now (client->server->sched,
-						   &restart_processing,
+  client->restart_task = GNUNET_SCHEDULER_add_now (&restart_processing,
 						   client);
 }
 
diff --git a/src/util/service.c b/src/util/service.c
index d18d4e9e3d..3423b58cb5 100644
--- a/src/util/service.c
+++ b/src/util/service.c
@@ -430,11 +430,6 @@ struct GNUNET_SERVICE_Context
   struct GNUNET_SERVER_Handle *server;
 
   /**
-   * Scheduler for the server.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
-
-  /**
    * NULL-terminated array of addresses to bind to, NULL if we got pre-bound
    * listen sockets.
    */
@@ -1290,16 +1285,13 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct GNUNET_SERVICE_Context *sctx = cls;
   unsigned int i;
 
-  sctx->sched = tc->sched;
   if (sctx->lsocks != NULL)
-    sctx->server = GNUNET_SERVER_create_with_sockets (tc->sched,
-						      &check_access,
+    sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
 						      sctx,
 						      sctx->lsocks,
 						      sctx->timeout, sctx->require_found);
   else
-    sctx->server = GNUNET_SERVER_create (tc->sched,
-					 &check_access,
+    sctx->server = GNUNET_SERVER_create (&check_access,
 					 sctx,
 					 sctx->addrs,
 					 sctx->addrlens,
@@ -1325,8 +1317,7 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     {
       /* install a task that will kill the server
          process if the scheduler ever gets a shutdown signal */
-      GNUNET_SCHEDULER_add_delayed (tc->sched,
-                                    GNUNET_TIME_UNIT_FOREVER_REL,
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                     &shutdown_task, sctx->server);
     }
   sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers));
@@ -1354,7 +1345,7 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 	  i++;
 	}
     }
-  sctx->task (sctx->task_cls, tc->sched, sctx->server, sctx->cfg);
+  sctx->task (sctx->task_cls, sctx->server, sctx->cfg);
 }
 
 
@@ -1612,13 +1603,11 @@ shutdown:
  * initialized system.
  *
  * @param serviceName our service name
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @return NULL on error, service handle
  */
 struct GNUNET_SERVICE_Context *
 GNUNET_SERVICE_start (const char *serviceName,
-                      struct GNUNET_SCHEDULER_Handle *sched,
                       const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int i;
@@ -1630,7 +1619,6 @@ GNUNET_SERVICE_start (const char *serviceName,
   sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL;
   sctx->serviceName = serviceName;
   sctx->cfg = cfg;
-  sctx->sched = sched;
 
   /* setup subsystems */
   if (GNUNET_OK != setup_service (sctx))
@@ -1639,14 +1627,12 @@ GNUNET_SERVICE_start (const char *serviceName,
       return NULL;
     }
   if (sctx->lsocks != NULL)
-    sctx->server = GNUNET_SERVER_create_with_sockets (sched,
-						      &check_access,
+    sctx->server = GNUNET_SERVER_create_with_sockets (&check_access,
 						      sctx,
 						      sctx->lsocks,
 						      sctx->timeout, sctx->require_found);
   else
-    sctx->server = GNUNET_SERVER_create (sched,
-					 &check_access,
+    sctx->server = GNUNET_SERVER_create (&check_access,
 					 sctx,
 					 sctx->addrs,
 					 sctx->addrlens,
diff --git a/src/util/test_client.c b/src/util/test_client.c
index ead6751a40..3851744c25 100644
--- a/src/util/test_client.c
+++ b/src/util/test_client.c
@@ -150,8 +150,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #endif
   sa.sin_family = AF_INET;
   sa.sin_port = htons (PORT);
-  server = GNUNET_SERVER_create (tc->sched,
-                                 NULL,
+  server = GNUNET_SERVER_create (NULL,
                                  NULL,
                                  sap,
 				 slens,
@@ -162,7 +161,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   handlers[0].callback_cls = cls;
   handlers[1].callback_cls = cls;
   GNUNET_SERVER_add_handlers (server, handlers);
-  client = GNUNET_CLIENT_connect (tc->sched, MYNAME, cfg);
+  client = GNUNET_CLIENT_connect (MYNAME, cfg);
   GNUNET_assert (client != NULL);
   GNUNET_assert (NULL !=
                  GNUNET_CLIENT_notify_transmit_ready (client,
diff --git a/src/util/test_connection.c b/src/util/test_connection.c
index 0cc02059de..71b37c8ac2 100644
--- a/src/util/test_connection.c
+++ b/src/util/test_connection.c
@@ -118,8 +118,7 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test accepts connection\n");
 #endif
-  asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
-                                                NULL, NULL, ls);
+  asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
   GNUNET_assert (asock != NULL);
   GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
 #if VERBOSE
@@ -157,10 +156,9 @@ static void
 task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+  lsock = GNUNET_CONNECTION_create_from_existing (ls);
   GNUNET_assert (lsock != NULL);
-  csock = GNUNET_CONNECTION_create_from_connect (tc->sched,
-                                                 cfg,
+  csock = GNUNET_CONNECTION_create_from_connect (cfg,
                                                  "localhost", PORT);
   GNUNET_assert (csock != NULL);
 #if VERBOSE
@@ -174,8 +172,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #if VERBOSE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n");
 #endif
-  GNUNET_SCHEDULER_add_read_net (tc->sched,
-                                 GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                  ls, &run_accept, cls);
 }
 
diff --git a/src/util/test_connection_addressing.c b/src/util/test_connection_addressing.c
index 4c10bd074e..f5328be921 100644
--- a/src/util/test_connection_addressing.c
+++ b/src/util/test_connection_addressing.c
@@ -115,8 +115,7 @@ run_accept (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct sockaddr_in *v4;
   struct sockaddr_in expect;
 
-  asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
-                                                NULL, NULL, ls);
+  asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
   GNUNET_assert (asock != NULL);
   GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
   GNUNET_assert (GNUNET_OK ==
@@ -153,7 +152,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct sockaddr_in v4;
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+  lsock = GNUNET_CONNECTION_create_from_existing (ls);
   GNUNET_assert (lsock != NULL);
 
 #if HAVE_SOCKADDR_IN_SIN_LEN
@@ -162,8 +161,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   v4.sin_family = AF_INET;
   v4.sin_port = htons (PORT);
   v4.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
-  csock = GNUNET_CONNECTION_create_from_sockaddr (tc->sched,
-                                                  AF_INET,
+  csock = GNUNET_CONNECTION_create_from_sockaddr (AF_INET,
                                                   (const struct sockaddr
                                                    *) &v4, sizeof (v4));
   GNUNET_assert (csock != NULL);
@@ -173,8 +171,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                                           GNUNET_TIME_UNIT_SECONDS,
                                                           &make_hello, NULL));
   GNUNET_CONNECTION_destroy (csock, GNUNET_YES);
-  GNUNET_SCHEDULER_add_read_net (tc->sched,
-                                 GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                  ls, &run_accept, cls);
 }
 
diff --git a/src/util/test_connection_receive_cancel.c b/src/util/test_connection_receive_cancel.c
index e4d7111d4a..1e67202359 100644
--- a/src/util/test_connection_receive_cancel.c
+++ b/src/util/test_connection_receive_cancel.c
@@ -90,8 +90,7 @@ static void
 run_accept_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
-  asock = GNUNET_CONNECTION_create_from_accept (tc->sched,
-                                                NULL, NULL, ls);
+  asock = GNUNET_CONNECTION_create_from_accept (NULL, NULL, ls);
   GNUNET_assert (asock != NULL);
   GNUNET_assert (GNUNET_YES == GNUNET_CONNECTION_check (asock));
   GNUNET_CONNECTION_destroy (lsock, GNUNET_YES);
@@ -119,16 +118,14 @@ static void
 task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+  lsock = GNUNET_CONNECTION_create_from_existing (ls);
   GNUNET_assert (lsock != NULL);
-  csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+  csock = GNUNET_CONNECTION_create_from_connect (cfg,
                                                  "localhost", PORT);
   GNUNET_assert (csock != NULL);
-  GNUNET_SCHEDULER_add_read_net (tc->sched,
-                                 GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                  ls, &run_accept_cancel, cls);
-  GNUNET_SCHEDULER_add_delayed (tc->sched,
-                                GNUNET_TIME_UNIT_SECONDS,
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                 &receive_cancel_task, cls);
 }
 
diff --git a/src/util/test_connection_timeout.c b/src/util/test_connection_timeout.c
index 5291ad3c4e..0e2190e417 100644
--- a/src/util/test_connection_timeout.c
+++ b/src/util/test_connection_timeout.c
@@ -107,9 +107,9 @@ task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
 
   ls = open_listen_socket ();
-  lsock = GNUNET_CONNECTION_create_from_existing (tc->sched, ls);
+  lsock = GNUNET_CONNECTION_create_from_existing (ls);
   GNUNET_assert (lsock != NULL);
-  csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+  csock = GNUNET_CONNECTION_create_from_connect (cfg,
                                                  "localhost", PORT);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
diff --git a/src/util/test_connection_timeout_no_connect.c b/src/util/test_connection_timeout_no_connect.c
index 468e965ca0..3519f197b8 100644
--- a/src/util/test_connection_timeout_no_connect.c
+++ b/src/util/test_connection_timeout_no_connect.c
@@ -53,7 +53,7 @@ handle_timeout (void *cls, size_t size, void *buf)
 static void
 task_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+  csock = GNUNET_CONNECTION_create_from_connect (cfg,
                                                  "localhost", PORT);
   GNUNET_assert (csock != NULL);
   GNUNET_assert (NULL !=
diff --git a/src/util/test_connection_transmit_cancel.c b/src/util/test_connection_transmit_cancel.c
index d4456b00d1..72e27243b2 100644
--- a/src/util/test_connection_transmit_cancel.c
+++ b/src/util/test_connection_transmit_cancel.c
@@ -50,7 +50,7 @@ task_transmit_cancel (void *cls,
   struct GNUNET_CONNECTION_TransmitHandle *th;
   struct GNUNET_CONNECTION_Handle *csock;
 
-  csock = GNUNET_CONNECTION_create_from_connect (tc->sched, cfg,
+  csock = GNUNET_CONNECTION_create_from_connect (cfg,
                                                  "localhost", PORT);
   GNUNET_assert (csock != NULL);
   th = GNUNET_CONNECTION_notify_transmit_ready (csock,
diff --git a/src/util/test_crypto_hash.c b/src/util/test_crypto_hash.c
index 33f19c8045..85de9fbbbf 100644
--- a/src/util/test_crypto_hash.c
+++ b/src/util/test_crypto_hash.c
@@ -123,8 +123,7 @@ static void
 file_hasher (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_assert (NULL !=
-		 GNUNET_CRYPTO_hash_file (tc->sched,
-					  GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+		 GNUNET_CRYPTO_hash_file (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
 					  FILENAME, 1024,
 					  &finished_task, cls));
 }
diff --git a/src/util/test_disk.c b/src/util/test_disk.c
index 9a5ea3a579..fb79e7cd86 100644
--- a/src/util/test_disk.c
+++ b/src/util/test_disk.c
@@ -169,8 +169,7 @@ iter_callback (void *cls,
 static void
 iter_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_DISK_directory_iterator_start (tc->sched,
-                                        GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+  GNUNET_DISK_directory_iterator_start (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                         "test", &iter_callback, cls);
 }
 
diff --git a/src/util/test_os_start_process.c b/src/util/test_os_start_process.c
index bce1c71516..f82860e832 100644
--- a/src/util/test_os_start_process.c
+++ b/src/util/test_os_start_process.c
@@ -78,8 +78,8 @@ read_call (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
     {
       GNUNET_break (0);
       ok = 1;
-      GNUNET_SCHEDULER_cancel(tc->sched, die_task);
-      GNUNET_SCHEDULER_add_now(tc->sched, &end_task, NULL);
+      GNUNET_SCHEDULER_cancel(die_task);
+      GNUNET_SCHEDULER_add_now(&end_task, NULL);
       return;
     }
 
@@ -89,13 +89,12 @@ read_call (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 #endif
   if (ok == 0)
     {
-      GNUNET_SCHEDULER_cancel(tc->sched, die_task);
-      GNUNET_SCHEDULER_add_now(tc->sched, &end_task, NULL);
+      GNUNET_SCHEDULER_cancel(die_task);
+      GNUNET_SCHEDULER_add_now(&end_task, NULL);
       return;
     }
 
-  GNUNET_SCHEDULER_add_read_file (tc->sched,
-                                       GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                        stdout_read_handle, &read_call, stdout_read_handle);
 
 }
@@ -145,10 +144,9 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   stdout_read_handle = GNUNET_DISK_pipe_handle(hello_pipe_stdout, GNUNET_DISK_PIPE_END_READ);
 
-  die_task = GNUNET_SCHEDULER_add_delayed(tc->sched, GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 1), &end_task, NULL);
+  die_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 1), &end_task, NULL);
 
-  GNUNET_SCHEDULER_add_read_file (tc->sched,
-                                  GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                   stdout_read_handle, &read_call, (void *)stdout_read_handle);
 
 }
diff --git a/src/util/test_program.c b/src/util/test_program.c
index e7745abff3..33a6b50ea4 100644
--- a/src/util/test_program.c
+++ b/src/util/test_program.c
@@ -58,13 +58,11 @@ static struct GNUNET_GETOPT_CommandLineOption options4[] = {
 
 static void
 runner (void *cls,
-        struct GNUNET_SCHEDULER_Handle *sched,
         char *const *args,
         const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int *ok = cls;
   GNUNET_assert (setme1 == 1);
-  GNUNET_assert (sched != NULL);
   GNUNET_assert (0 == strcmp (args[0], "extra"));
   GNUNET_assert (args[1] == NULL);
   GNUNET_assert (0 == strcmp (cfgfile, "test_program_data.conf"));
diff --git a/src/util/test_resolver_api.c b/src/util/test_resolver_api.c
index 734420e84e..bf2f8f00f8 100644
--- a/src/util/test_resolver_api.c
+++ b/src/util/test_resolver_api.c
@@ -219,7 +219,7 @@ check_rootserver_name(void *cls, const char *hostname)
 }
 
 static void
-run(void *cls, struct GNUNET_SCHEDULER_Handle *sched, char * const *args,
+run(void *cls, char * const *args,
     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   int *ok = cls;
@@ -232,13 +232,13 @@ run(void *cls, struct GNUNET_SCHEDULER_Handle *sched, char * const *args,
   memset(&sa, 0, sizeof(sa));
   sa.sin_family = AF_INET;
   sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-  GNUNET_RESOLVER_ip_get(sched, cfg, "localhost", AF_INET, timeout, &check_127,
+  GNUNET_RESOLVER_ip_get(cfg, "localhost", AF_INET, timeout, &check_127,
       cls);
-  GNUNET_RESOLVER_hostname_get(sched, cfg, (const struct sockaddr *) &sa,
+  GNUNET_RESOLVER_hostname_get(cfg, (const struct sockaddr *) &sa,
       sizeof(struct sockaddr), GNUNET_YES, timeout, &check_localhost, cls);
-  GNUNET_RESOLVER_hostname_get(sched, cfg, (const struct sockaddr *) &sa,
+  GNUNET_RESOLVER_hostname_get(cfg, (const struct sockaddr *) &sa,
       sizeof(struct sockaddr), GNUNET_NO, timeout, &check_localhost_num, cls);
-  GNUNET_RESOLVER_hostname_resolve(sched, cfg, AF_UNSPEC, timeout,
+  GNUNET_RESOLVER_hostname_resolve(cfg, AF_UNSPEC, timeout,
       &check_hostname, cls);
 
 
@@ -297,7 +297,7 @@ run(void *cls, struct GNUNET_SCHEDULER_Handle *sched, char * const *args,
 #endif
 
   /* Resolve the same using GNUNET */
-  GNUNET_RESOLVER_ip_get(sched, cfg, ROOTSERVER_NAME, AF_INET, timeout,
+  GNUNET_RESOLVER_ip_get(cfg, ROOTSERVER_NAME, AF_INET, timeout,
       &check_rootserver_ip, cls);
 
   /*
@@ -350,7 +350,7 @@ run(void *cls, struct GNUNET_SCHEDULER_Handle *sched, char * const *args,
 #else
   sa.sin_addr.S_un.S_addr = inet_addr(ROOTSERVER_IP);
 #endif
-  GNUNET_RESOLVER_hostname_get(sched, cfg, (const struct sockaddr *) &sa,
+  GNUNET_RESOLVER_hostname_get(cfg, (const struct sockaddr *) &sa,
       sizeof(struct sockaddr), GNUNET_YES, timeout, &check_rootserver_name, cls);
 }
 
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c
index 0ac1865886..f0c908d7d6 100644
--- a/src/util/test_scheduler.c
+++ b/src/util/test_scheduler.c
@@ -34,8 +34,7 @@ task3 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   int *ok = cls;
   /* t4 should be ready (albeit with lower priority) */
-  GNUNET_assert (1 == GNUNET_SCHEDULER_get_load (tc->sched,
-                                                 GNUNET_SCHEDULER_PRIORITY_COUNT));
+  GNUNET_assert (1 == GNUNET_SCHEDULER_get_load (GNUNET_SCHEDULER_PRIORITY_COUNT));
   GNUNET_assert (3 == *ok);
   (*ok) = 4;
 }
@@ -48,8 +47,7 @@ task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (2 == *ok);
   (*ok) = 3;
   /* t3 will go before t4: higher priority */
-  GNUNET_SCHEDULER_add_with_priority (tc->sched,
-                                      GNUNET_SCHEDULER_PRIORITY_UI,
+  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
                                       &task3, cls);
 }
 
@@ -101,10 +99,9 @@ taskRd (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, fds[0]));
   GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1));
   (*ok) = 8;
-  GNUNET_SCHEDULER_add_with_priority (tc->sched,
-                                      GNUNET_SCHEDULER_PRIORITY_IDLE,
+  GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_IDLE,
                                       &taskLast, cls);
-  GNUNET_SCHEDULER_shutdown (tc->sched);
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -118,11 +115,9 @@ task5 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (NULL != p);
   fds[0] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_READ);
   fds[1] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_WRITE);
-  GNUNET_SCHEDULER_add_read_file (tc->sched,
-                                  GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                   fds[0], &taskRd, cls);
-  GNUNET_SCHEDULER_add_write_file (tc->sched,
-                                   GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_write_file (GNUNET_TIME_UNIT_FOREVER_REL,
                                    fds[1], &taskWrt, cls);
 }
 
@@ -137,12 +132,11 @@ task1 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_assert (1 == *ok);
   (*ok) = 2;
   /* t2 will go first -- prereq for all */
-  t2 = GNUNET_SCHEDULER_add_after (tc->sched,
-                                   GNUNET_SCHEDULER_NO_TASK, &task2, cls);
+  t2 = GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK, &task2, cls);
   /* t4 will go after t2 ('add after') and after t3 (priority) */
-  t4 = GNUNET_SCHEDULER_add_after (tc->sched, t2, &task4, cls);
+  t4 = GNUNET_SCHEDULER_add_after (t2, &task4, cls);
   /* t5 will go last (after p4) */
-  GNUNET_SCHEDULER_add_after (tc->sched, t4, &task5, cls);
+  GNUNET_SCHEDULER_add_after (t4, &task5, cls);
 }
 
 
@@ -168,9 +162,8 @@ taskShutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   int *ok = cls;
   GNUNET_assert (1 == *ok);
   *ok = 8;
-  GNUNET_SCHEDULER_add_delayed (tc->sched,
-                                GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
-  GNUNET_SCHEDULER_shutdown (tc->sched);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -195,8 +188,7 @@ taskSig (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   int *ok = cls;
   GNUNET_assert (1 == *ok);
   *ok = 8;
-  GNUNET_SCHEDULER_add_delayed (tc->sched,
-                                GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls);
   GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM));
 }
 
@@ -223,9 +215,7 @@ taskCancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   GNUNET_assert (1 == *ok);
   *ok = 0;
-  GNUNET_SCHEDULER_cancel (tc->sched,
-                           GNUNET_SCHEDULER_add_after (tc->sched,
-                                                       GNUNET_SCHEDULER_NO_TASK,
+  GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_NO_TASK,
                                                        &taskNeverRun, NULL));
 }
 
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c
index 24d30be998..1f60ca9fd1 100644
--- a/src/util/test_scheduler_delay.c
+++ b/src/util/test_scheduler_delay.c
@@ -65,8 +65,7 @@ test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
       fprintf (stderr, "\n");
       return;
     }
-  GNUNET_SCHEDULER_add_delayed (tc->sched,
-                                GNUNET_TIME_relative_multiply
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
                                 (GNUNET_TIME_UNIT_MILLISECONDS, i),
                                 &test_task, NULL);
   i += INCR;
diff --git a/src/util/test_server.c b/src/util/test_server.c
index 78e2d52bfb..00d4352f85 100644
--- a/src/util/test_server.c
+++ b/src/util/test_server.c
@@ -45,8 +45,6 @@ static struct GNUNET_SERVER_Client *argclient;
 
 static struct GNUNET_CONFIGURATION_Handle *cfg;
 
-static struct GNUNET_SCHEDULER_Handle *sched;
-
 static int ok;
 
 
@@ -70,8 +68,7 @@ recv_fin_cb (void *cls,
   GNUNET_assert (ok == 5);
   ok = 6;
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
-  GNUNET_SCHEDULER_add_now (sched,
-			    &finish_up,
+  GNUNET_SCHEDULER_add_now (&finish_up,
 			    NULL);
 }
 
@@ -181,15 +178,13 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   slens[0] = sizeof (sa);
   sap[1] = NULL;
   slens[1] = 0;
-  sched = tc->sched;
   memset (&sa, 0, sizeof (sa));
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sa.sin_len = sizeof (sa);
 #endif
   sa.sin_family = AF_INET;
   sa.sin_port = htons (PORT);
-  server = GNUNET_SERVER_create (tc->sched,
-                                 NULL,
+  server = GNUNET_SERVER_create (NULL,
                                  NULL,
                                  sap,
 				 slens,
@@ -201,8 +196,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_CONFIGURATION_set_value_number (cfg, "test-server", "PORT", PORT);
   GNUNET_CONFIGURATION_set_value_string (cfg, "test-server", "HOSTNAME", "localhost");
   GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost");
-  cc = GNUNET_CLIENT_connect (tc->sched,
-			      "test-server",
+  cc = GNUNET_CLIENT_connect ("test-server",
 			      cfg);
   GNUNET_assert (cc != NULL);
   GNUNET_assert (NULL !=
diff --git a/src/util/test_server_disconnect.c b/src/util/test_server_disconnect.c
index 2fef5642e9..8ab8ef35bd 100644
--- a/src/util/test_server_disconnect.c
+++ b/src/util/test_server_disconnect.c
@@ -42,8 +42,6 @@ static struct GNUNET_CLIENT_Connection *cc;
 
 static struct GNUNET_CONFIGURATION_Handle *cfg;
 
-static struct GNUNET_SCHEDULER_Handle *sched;
-
 static int ok;
 
 
@@ -66,8 +64,7 @@ notify_disconnect (void *cls, struct GNUNET_SERVER_Client *clientarg)
     return;
   GNUNET_assert (ok == 4);
   ok = 5;
-  GNUNET_SCHEDULER_add_now (sched,
-			    &finish_up,
+  GNUNET_SCHEDULER_add_now (&finish_up,
 			    NULL);
 }
 
@@ -91,8 +88,7 @@ recv_cb (void *cls,
   GNUNET_assert (ok == 2);
   ok = 3;
   GNUNET_SERVER_client_keep (client);
-  GNUNET_SCHEDULER_add_now (sched,
-			    &server_disconnect, client);
+  GNUNET_SCHEDULER_add_now (&server_disconnect, client);
   GNUNET_assert (sizeof (struct GNUNET_MessageHeader) ==
                  ntohs (message->size));
   GNUNET_assert (MY_TYPE == ntohs (message->type));
@@ -134,15 +130,13 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   slens[0] = sizeof (sa);
   sap[1] = NULL;
   slens[1] = 0;
-  sched = tc->sched;
   memset (&sa, 0, sizeof (sa));
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sa.sin_len = sizeof (sa);
 #endif
   sa.sin_family = AF_INET;
   sa.sin_port = htons (PORT);
-  server = GNUNET_SERVER_create (tc->sched,
-                                 NULL,
+  server = GNUNET_SERVER_create (NULL,
                                  NULL,
                                  sap,
 				 slens,
@@ -155,8 +149,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_CONFIGURATION_set_value_number (cfg, "test-server", "PORT", PORT);
   GNUNET_CONFIGURATION_set_value_string (cfg, "test-server", "HOSTNAME", "localhost");
   GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME", "localhost");
-  cc = GNUNET_CLIENT_connect (tc->sched,
-			      "test-server",
+  cc = GNUNET_CLIENT_connect ("test-server",
 			      cfg);
   GNUNET_assert (cc != NULL);
   GNUNET_assert (NULL !=
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c
index 4157be2503..5c36b7b03c 100644
--- a/src/util/test_server_with_client.c
+++ b/src/util/test_server_with_client.c
@@ -41,8 +41,6 @@ static struct GNUNET_SERVER_Handle *server;
 
 static struct GNUNET_CLIENT_Connection *client;
 
-static struct GNUNET_SCHEDULER_Handle *sched;
-
 static struct GNUNET_CONFIGURATION_Handle *cfg;
 
 static int ok;
@@ -86,8 +84,7 @@ recv_cb (void *cls,
     {
     case 2:
       ok++;
-      GNUNET_SCHEDULER_add_delayed (sched,
-                                    GNUNET_TIME_relative_multiply
+      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
                                     (GNUNET_TIME_UNIT_MILLISECONDS, 50),
                                     &send_done, argclient);
       break;
@@ -127,8 +124,7 @@ notify_disconnect (void *cls, struct GNUNET_SERVER_Client *client)
     return;
   GNUNET_assert (ok == 5);
   ok = 0;
-  GNUNET_SCHEDULER_add_now (sched,
-			    &clean_up, NULL);
+  GNUNET_SCHEDULER_add_now (&clean_up, NULL);
 }
 
 
@@ -167,15 +163,13 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   slens[0] = sizeof (sa);
   sap[1] = NULL;
   slens[1] = 0;
-  sched = tc->sched;
   memset (&sa, 0, sizeof (sa));
 #if HAVE_SOCKADDR_IN_SIN_LEN
   sa.sin_len = sizeof (sa);
 #endif
   sa.sin_family = AF_INET;
   sa.sin_port = htons (PORT);
-  server = GNUNET_SERVER_create (tc->sched,
-                                 NULL,
+  server = GNUNET_SERVER_create (NULL,
                                  NULL,
                                  sap,
 				 slens,
@@ -192,7 +186,7 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                          "localhost");
   GNUNET_CONFIGURATION_set_value_string (cfg, "resolver", "HOSTNAME",
                                          "localhost");
-  client = GNUNET_CLIENT_connect (tc->sched, "test", cfg);
+  client = GNUNET_CLIENT_connect ("test", cfg);
   GNUNET_assert (client != NULL);
   GNUNET_CLIENT_notify_transmit_ready (client,
                                        256,
diff --git a/src/util/test_service.c b/src/util/test_service.c
index 6c78a4eb9c..9bd58352b4 100644
--- a/src/util/test_service.c
+++ b/src/util/test_service.c
@@ -37,8 +37,6 @@
 
 #define MY_TYPE 256
 
-static struct GNUNET_SCHEDULER_Handle *sched;
-
 static struct GNUNET_SERVICE_Context *sctx;
 
 static int ok = 1;
@@ -67,8 +65,7 @@ ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service confirmed running\n");
-  sched = tc->sched;
-  client = GNUNET_CLIENT_connect (tc->sched, "test_service", cfg);
+  client = GNUNET_CLIENT_connect ("test_service", cfg);
   GNUNET_assert (client != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Client connecting, waiting to transmit\n");
@@ -94,9 +91,9 @@ recv_cb (void *cls,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Receiving client message...\n");
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
   if (sctx != NULL)
-    GNUNET_SCHEDULER_add_now (sched, &do_stop, NULL);
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
   else
-    GNUNET_SCHEDULER_shutdown (sched);
+    GNUNET_SCHEDULER_shutdown ();
   ok = 0;
 }
 
@@ -110,14 +107,12 @@ static struct GNUNET_SERVER_MessageHandler myhandlers[] = {
 
 static void
 runner (void *cls,
-        struct GNUNET_SCHEDULER_Handle *sched,
         struct GNUNET_SERVER_Handle *server,
         const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Service initializing\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);
-  GNUNET_CLIENT_service_test (sched,
-                              "test_service",
+  GNUNET_CLIENT_service_test ("test_service",
                               cfg, GNUNET_TIME_UNIT_SECONDS, &ready,
                               (void *) cfg);
 }
@@ -161,9 +156,8 @@ ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   struct GNUNET_CLIENT_Connection *client;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 ready\n");
-  sched = tc->sched;
   GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
-  client = GNUNET_CLIENT_connect (tc->sched, "test_service6", cfg);
+  client = GNUNET_CLIENT_connect ("test_service6", cfg);
   GNUNET_assert (client != NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "V6 client connected\n");
   GNUNET_CLIENT_notify_transmit_ready (client,
@@ -174,14 +168,12 @@ ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 static void
 runner6 (void *cls,
-         struct GNUNET_SCHEDULER_Handle *sched,
          struct GNUNET_SERVER_Handle *server,
          const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Initializing v6 service\n");
   GNUNET_SERVER_add_handlers (server, myhandlers);
-  GNUNET_CLIENT_service_test (sched,
-                              "test_service6",
+  GNUNET_CLIENT_service_test ("test_service6",
                               cfg, GNUNET_TIME_UNIT_SECONDS, &ready6,
                               (void *) cfg);
 }
@@ -220,7 +212,6 @@ check6 ()
 
 static void
 start_stop_main (void *cls,
-                 struct GNUNET_SCHEDULER_Handle *sched,
                  char *const *args,
                  const char *cfgfile,
                  const struct GNUNET_CONFIGURATION_Handle *cfg)
@@ -228,9 +219,9 @@ start_stop_main (void *cls,
   int *ret = cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Starting service using start method\n");
-  sctx = GNUNET_SERVICE_start ("test_service", sched, cfg);
+  sctx = GNUNET_SERVICE_start ("test_service", cfg);
   GNUNET_assert (NULL != sctx);
-  runner (cls, sched, GNUNET_SERVICE_get_server (sctx), cfg);
+  runner (cls, GNUNET_SERVICE_get_server (sctx), cfg);
   *ret = 0;
 }