big scheduler refactoring, expect some issues

9 files changed, 87 insertions, 162 deletions

diff --git a/src/core/core_api.c b/src/core/core_api.c
index dd8919ea1..cb5ba3ecb 100644
--- a/src/core/core_api.c
+++ b/src/core/core_api.c
@@ -36,10 +36,6 @@
 struct GNUNET_CORE_Handle
 {
 
-  /**
-   * Our scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
 
   /**
    * Configuration we're using.
@@ -263,10 +259,9 @@ reconnect (struct GNUNET_CORE_Handle *h)
   if (h->client_notifications != NULL)
     GNUNET_CLIENT_disconnect (h->client_notifications, GNUNET_NO);
   h->currently_down = GNUNET_YES;
-  h->client_notifications = GNUNET_CLIENT_connect (h->sched, "core", h->cfg);
+  h->client_notifications = GNUNET_CLIENT_connect ("core", h->cfg);
   if (h->client_notifications == NULL)
-    h->reconnect_task = GNUNET_SCHEDULER_add_delayed (h->sched,
-                                                      GNUNET_TIME_UNIT_SECONDS,
+    h->reconnect_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
                                                       &reconnect_task,
                                                       h);
   else
@@ -328,7 +323,7 @@ request_start (void *cls, size_t size, void *buf)
     {
       if (th->timeout_task != GNUNET_SCHEDULER_NO_TASK)
         {
-          GNUNET_SCHEDULER_cancel(h->sched, th->timeout_task);
+          GNUNET_SCHEDULER_cancel(th->timeout_task);
           th->timeout_task = GNUNET_SCHEDULER_NO_TASK;  
         }
       timeout_request (th, NULL);
@@ -673,8 +668,7 @@ transmit_start (void *cls, size_t size, void *buf)
             h->startup_timeout =
               GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES);
           h->reconnect_task =
-            GNUNET_SCHEDULER_add_delayed (h->sched, 
-                                          delay, &reconnect_task, h);
+            GNUNET_SCHEDULER_add_delayed (delay, &reconnect_task, h);
           return 0;
         }
       /* timeout on initial connect */
@@ -727,7 +721,6 @@ transmit_start (void *cls, size_t size, void *buf)
  * Connect to the core service.  Note that the connection may
  * complete (or fail) asynchronously.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param timeout after how long should we give up trying to connect to the core service?
  * @param cls closure for the various callbacks that follow (including handlers in the handlers array)
@@ -749,8 +742,7 @@ transmit_start (void *cls, size_t size, void *buf)
  *                NULL on error (in this case, init is never called)
  */
 struct GNUNET_CORE_Handle *
-GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
-                     const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                      struct GNUNET_TIME_Relative timeout,
                      void *cls,
                      GNUNET_CORE_StartupCallback init,
@@ -766,7 +758,6 @@ GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
   struct GNUNET_CORE_Handle *h;
 
   h = GNUNET_malloc (sizeof (struct GNUNET_CORE_Handle));
-  h->sched = sched;
   h->cfg = cfg;
   h->cls = cls;
   h->init = init;
@@ -778,7 +769,7 @@ GNUNET_CORE_connect (struct GNUNET_SCHEDULER_Handle *sched,
   h->inbound_hdr_only = inbound_hdr_only;
   h->outbound_hdr_only = outbound_hdr_only;
   h->handlers = handlers;
-  h->client_notifications = GNUNET_CLIENT_connect (sched, "core", cfg);
+  h->client_notifications = GNUNET_CLIENT_connect ("core", cfg);
   if (h->client_notifications == NULL)
     {
       GNUNET_free (h);
@@ -819,7 +810,7 @@ GNUNET_CORE_disconnect (struct GNUNET_CORE_Handle *handle)
   if (handle->solicit_transmit_req != NULL)
     GNUNET_CORE_notify_transmit_ready_cancel (handle->solicit_transmit_req);
   if (handle->reconnect_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (handle->sched, handle->reconnect_task);
+    GNUNET_SCHEDULER_cancel (handle->reconnect_task);
   if (handle->client_notifications != NULL)
     GNUNET_CLIENT_disconnect (handle->client_notifications, GNUNET_NO);
   GNUNET_break (handle->pending_head == NULL);
@@ -950,8 +941,7 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
   th->notify_cls = notify_cls;
   th->peer = *target;
   th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay);
-  th->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->sched,
-                                                   maxdelay,
+  th->timeout_task = GNUNET_SCHEDULER_add_delayed (maxdelay,
                                                    &timeout_request, th);
   th->priority = priority;
   th->msize = sizeof (struct SendMessage) + notify_size;
@@ -965,7 +955,7 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle,
 
 /**
  * Cancel the specified transmission-ready notification.
- *
+ *s
  * @param th handle that was returned by "notify_transmit_ready".
  */
 void
@@ -981,7 +971,7 @@ GNUNET_CORE_notify_transmit_ready_cancel (struct GNUNET_CORE_TransmitHandle
                                  h->pending_tail,
                                  th);    
   if (th->timeout_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (h->sched, th->timeout_task);
+    GNUNET_SCHEDULER_cancel (th->timeout_task);
   GNUNET_free (th);
 }
 
diff --git a/src/core/core_api_iterate_peers.c b/src/core/core_api_iterate_peers.c
index 08cb9797c..aeef67f88 100644
--- a/src/core/core_api_iterate_peers.c
+++ b/src/core/core_api_iterate_peers.c
@@ -134,22 +134,20 @@ transmit_request(void *cls,
 /**
  * Obtain statistics and/or change preferences for the given peer.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param peer_cb function to call with the peer information
  * @param cb_cls closure for peer_cb
  * @return GNUNET_OK if iterating, GNUNET_SYSERR on error
  */
 int
-GNUNET_CORE_iterate_peers (struct GNUNET_SCHEDULER_Handle *sched,
-                           const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_iterate_peers (const struct GNUNET_CONFIGURATION_Handle *cfg,
                            GNUNET_CORE_ConnectEventHandler peer_cb,
                            void *cb_cls)
 {
   struct GNUNET_CORE_RequestContext *request_context;
   struct GNUNET_CLIENT_Connection *client;
 
-  client = GNUNET_CLIENT_connect (sched, "core", cfg);
+  client = GNUNET_CLIENT_connect ("core", cfg);
   if (client == NULL)
     return GNUNET_SYSERR;
   request_context = GNUNET_malloc (sizeof (struct GNUNET_CORE_RequestContext));
diff --git a/src/core/core_api_peer_get_info.c b/src/core/core_api_peer_get_info.c
index 68cf2da11..1ca8d82af 100644
--- a/src/core/core_api_peer_get_info.c
+++ b/src/core/core_api_peer_get_info.c
@@ -99,7 +99,6 @@ receive_info (void *cls,
 /**
  * Obtain statistics and/or change preferences for the given peer.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param peer identifies the peer
  * @param timeout after how long should we give up (and call "info" with NULL
@@ -122,8 +121,7 @@ receive_info (void *cls,
  * @return NULL on error
  */
 struct GNUNET_CORE_InformationRequestContext *
-GNUNET_CORE_peer_change_preference (struct GNUNET_SCHEDULER_Handle *sched,
-                                    const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_change_preference (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                     const struct GNUNET_PeerIdentity *peer,
                                     struct GNUNET_TIME_Relative timeout,
                                     struct GNUNET_BANDWIDTH_Value32NBO bw_out,
@@ -137,7 +135,7 @@ GNUNET_CORE_peer_change_preference (struct GNUNET_SCHEDULER_Handle *sched,
   struct GNUNET_CLIENT_Connection *client;
   int retry;
 
-  client = GNUNET_CLIENT_connect (sched, "core", cfg);
+  client = GNUNET_CLIENT_connect ("core", cfg);
   if (client == NULL)
     return NULL;
   irc = GNUNET_malloc (sizeof (struct GNUNET_CORE_InformationRequestContext));
diff --git a/src/core/core_api_peer_request.c b/src/core/core_api_peer_request.c
index 96640990a..0f13f15f9 100644
--- a/src/core/core_api_peer_request.c
+++ b/src/core/core_api_peer_request.c
@@ -41,10 +41,6 @@ struct GNUNET_CORE_PeerRequestHandle
    */
   struct GNUNET_CLIENT_Connection *client;
 
-  /**
-   * Scheduler.
-   */
-  struct GNUNET_SCHEDULER_Handle *sched;
 
   /**
    * Function to call once done.
@@ -92,8 +88,7 @@ send_request (void *cls,
   if (buf == NULL)
     {
       if (prh->cont != NULL)
-        GNUNET_SCHEDULER_add_continuation (prh->sched,
-                                           prh->cont,
+        GNUNET_SCHEDULER_add_continuation (prh->cont,
                                            prh->cont_cls,
                                            GNUNET_SCHEDULER_REASON_TIMEOUT);
       GNUNET_CLIENT_disconnect (prh->client, GNUNET_NO);
@@ -109,8 +104,7 @@ send_request (void *cls,
   memcpy (buf, &msg, sizeof (msg));
   if (prh->cont != NULL)
     {
-      GNUNET_SCHEDULER_add_continuation (prh->sched,
-                                         prh->cont,
+      GNUNET_SCHEDULER_add_continuation (prh->cont,
                                          prh->cont_cls,
                                          GNUNET_SCHEDULER_REASON_PREREQ_DONE);
     }
@@ -131,7 +125,6 @@ send_request (void *cls,
  * to our connection attempt within the given time frame, 'cont' will
  * be called with the TIMEOUT reason code.
  *
- * @param sched scheduler to use
  * @param cfg configuration to use
  * @param timeout how long to try to talk to core
  * @param peer who should we connect to
@@ -140,8 +133,7 @@ send_request (void *cls,
  * @return NULL on error (cont will not be called), otherwise handle for cancellation
  */
 struct GNUNET_CORE_PeerRequestHandle *
-GNUNET_CORE_peer_request_connect (struct GNUNET_SCHEDULER_Handle *sched,
-                                  const struct GNUNET_CONFIGURATION_Handle *cfg,
+GNUNET_CORE_peer_request_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
                                   struct GNUNET_TIME_Relative timeout,
                                   const struct GNUNET_PeerIdentity * peer,
                                   GNUNET_SCHEDULER_Task cont,
@@ -150,12 +142,11 @@ GNUNET_CORE_peer_request_connect (struct GNUNET_SCHEDULER_Handle *sched,
   struct GNUNET_CORE_PeerRequestHandle *ret;
   struct GNUNET_CLIENT_Connection *client;
   
-  client = GNUNET_CLIENT_connect (sched, "core", cfg);
+  client = GNUNET_CLIENT_connect ("core", cfg);
   if (client == NULL)
     return NULL;
   ret = GNUNET_malloc (sizeof (struct GNUNET_CORE_PeerRequestHandle));
   ret->client = client;
-  ret->sched = sched;
   ret->cont = cont;
   ret->cont_cls = cont_cls;
   ret->peer = *peer;
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c
index 6b662982d..c1ebdb9df 100644
--- a/src/core/gnunet-service-core.c
+++ b/src/core/gnunet-service-core.c
@@ -657,10 +657,6 @@ static struct GNUNET_PeerIdentity my_identity;
  */
 static struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;
 
-/**
- * Our scheduler.
- */
-struct GNUNET_SCHEDULER_Handle *sched;
 
 /**
  * Handle to peerinfo service.
@@ -1259,15 +1255,15 @@ free_neighbour (struct Neighbour *n)
       n->th = NULL;
     }
   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
+    GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+    GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
   if (n->quota_update_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sched, n->quota_update_task);
+    GNUNET_SCHEDULER_cancel (n->quota_update_task);
   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
+    GNUNET_SCHEDULER_cancel (n->dead_clean_task);
   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)    
-      GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+      GNUNET_SCHEDULER_cancel (n->keep_alive_task);
   if (n->status == PEER_STATE_KEY_CONFIRMED)
     GNUNET_STATISTICS_update (stats, gettext_noop ("# established sessions"), -1, GNUNET_NO);
   GNUNET_free_non_null (n->public_key);
@@ -1397,8 +1393,7 @@ send_keep_alive (void *cls,
   retry = GNUNET_TIME_relative_max (GNUNET_TIME_relative_divide (left, 2),
                                     MIN_PING_FREQUENCY);
   n->keep_alive_task 
-    = GNUNET_SCHEDULER_add_delayed (sched, 
-                                    retry,
+    = GNUNET_SCHEDULER_add_delayed (retry,
                                     &send_keep_alive,
                                     n);
 
@@ -1445,9 +1440,8 @@ consider_free_neighbour (struct Neighbour *n)
   if (left.rel_value > 0)
     {
       if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (sched, n->dead_clean_task);
-      n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                                         left,
+        GNUNET_SCHEDULER_cancel (n->dead_clean_task);
+      n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (left,
                                                          &consider_free_task,
                                                          n);
       return;
@@ -2087,7 +2081,7 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
 
   if (n->retry_plaintext_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_SCHEDULER_cancel (sched, n->retry_plaintext_task);
+      GNUNET_SCHEDULER_cancel (n->retry_plaintext_task);
       n->retry_plaintext_task = GNUNET_SCHEDULER_NO_TASK;
     }
   switch (n->status)
@@ -2103,8 +2097,7 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
     case PEER_STATE_KEY_SENT:
       if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)
         n->retry_set_key_task
-          = GNUNET_SCHEDULER_add_delayed (sched,
-                                          n->set_key_retry_frequency,
+          = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
                                           &set_key_retry_task, n);    
 #if DEBUG_CORE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2115,8 +2108,7 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
     case PEER_STATE_KEY_RECEIVED:
       if (n->retry_set_key_task == GNUNET_SCHEDULER_NO_TASK)        
         n->retry_set_key_task
-          = GNUNET_SCHEDULER_add_delayed (sched,
-                                          n->set_key_retry_frequency,
+          = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
                                           &set_key_retry_task, n);        
 #if DEBUG_CORE
       GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -2165,8 +2157,7 @@ process_plaintext_neighbour_queue (struct Neighbour *n)
 #endif
       /* no messages selected for sending, try again later... */
       n->retry_plaintext_task =
-        GNUNET_SCHEDULER_add_delayed (sched,
-                                      retry_time,
+        GNUNET_SCHEDULER_add_delayed (retry_time,
                                       &retry_plaintext_processing, n);
       return;
     }
@@ -2252,8 +2243,7 @@ schedule_quota_update (struct Neighbour *n)
   GNUNET_assert (n->quota_update_task ==
                  GNUNET_SCHEDULER_NO_TASK);
   n->quota_update_task
-    = GNUNET_SCHEDULER_add_delayed (sched,
-                                    QUOTA_UPDATE_FREQUENCY,
+    = GNUNET_SCHEDULER_add_delayed (QUOTA_UPDATE_FREQUENCY,
                                     &neighbour_quota_update,
                                     n);
 }
@@ -2475,10 +2465,8 @@ notify_transport_connect_done (void *cls, size_t size, void *buf)
               _("TRANSPORT connection to peer `%4s' is up, trying to establish CORE connection\n"),
               GNUNET_i2s (&n->peer));
   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sched,
-                             n->retry_set_key_task);
-  n->retry_set_key_task = GNUNET_SCHEDULER_add_now (sched, 
-                                                    &set_key_retry_task,
+    GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
+  n->retry_set_key_task = GNUNET_SCHEDULER_add_now (&set_key_retry_task,
                                                     n);
   return 0;
 }
@@ -2567,7 +2555,7 @@ process_hello_retry_send_key (void *cls,
         {
           if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
             {
-              GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+              GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
               n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
             }      
           GNUNET_STATISTICS_update (stats,
@@ -2589,8 +2577,7 @@ process_hello_retry_send_key (void *cls,
                                     GNUNET_NO);      
           if (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task)
             n->retry_set_key_task
-              = GNUNET_SCHEDULER_add_delayed (sched,
-                                              n->set_key_retry_frequency,
+              = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
                                               &set_key_retry_task, n);
         }
       return;
@@ -2651,7 +2638,7 @@ send_key (struct Neighbour *n)
 
   if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
     {
-      GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+      GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
       n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
     }        
   if (n->pitr != NULL)
@@ -2829,8 +2816,7 @@ send_key (struct Neighbour *n)
   if ( (n->status != PEER_STATE_KEY_CONFIRMED) &&
        (GNUNET_SCHEDULER_NO_TASK == n->retry_set_key_task) )
     n->retry_set_key_task
-      = GNUNET_SCHEDULER_add_delayed (sched,
-                                      n->set_key_retry_frequency,
+      = GNUNET_SCHEDULER_add_delayed (n->set_key_retry_frequency,
                                       &set_key_retry_task, n);    
 }
 
@@ -3096,7 +3082,7 @@ handle_pong (struct Neighbour *n,
 #endif      
       if (n->retry_set_key_task != GNUNET_SCHEDULER_NO_TASK)
         {
-          GNUNET_SCHEDULER_cancel (sched, n->retry_set_key_task);
+          GNUNET_SCHEDULER_cancel (n->retry_set_key_task);
           n->retry_set_key_task = GNUNET_SCHEDULER_NO_TASK;
         }      
       cnm.header.size = htons (sizeof (struct ConnectNotifyMessage));
@@ -3110,10 +3096,9 @@ handle_pong (struct Neighbour *n,
     case PEER_STATE_KEY_CONFIRMED:
       n->last_activity = GNUNET_TIME_absolute_get ();
       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+        GNUNET_SCHEDULER_cancel (n->keep_alive_task);
       n->keep_alive_task 
-        = GNUNET_SCHEDULER_add_delayed (sched, 
-                                        GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
+        = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
                                         &send_keep_alive,
                                         n);
       handle_peer_status_change (n);
@@ -3560,10 +3545,9 @@ handle_encrypted_message (struct Neighbour *n,
     }
   n->last_activity = GNUNET_TIME_absolute_get ();
   if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+    GNUNET_SCHEDULER_cancel (n->keep_alive_task);
   n->keep_alive_task 
-    = GNUNET_SCHEDULER_add_delayed (sched, 
-                                    GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
+    = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
                                     &send_keep_alive,
                                     n);
   GNUNET_STATISTICS_set (stats,
@@ -3711,10 +3695,9 @@ handle_transport_receive (void *cls,
           n->time_established = now;
         }
       if (n->keep_alive_task != GNUNET_SCHEDULER_NO_TASK)
-        GNUNET_SCHEDULER_cancel (sched, n->keep_alive_task);
+        GNUNET_SCHEDULER_cancel (n->keep_alive_task);
       n->keep_alive_task 
-        = GNUNET_SCHEDULER_add_delayed (sched, 
-                                        GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
+        = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_divide (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, 2),
                                         &send_keep_alive,
                                         n);
     }
@@ -3912,14 +3895,12 @@ handle_transport_notify_disconnect (void *cls,
                             -1, 
                             GNUNET_NO);
   if (n->dead_clean_task != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (sched,
-                             n->dead_clean_task);
+    GNUNET_SCHEDULER_cancel (n->dead_clean_task);
   left = GNUNET_TIME_relative_subtract (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                         GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT);
   n->last_activity = GNUNET_TIME_absolute_subtract (GNUNET_TIME_absolute_get (), 
                                                     left);
-  n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                                     GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
+  n->dead_clean_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_DISCONNECT_SESSION_TIMEOUT,
                                                      &consider_free_task,
                                                      n);
 }
@@ -3969,13 +3950,11 @@ cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Initiate core service.
  *
  * @param cls closure
- * @param s scheduler to use
  * @param server the initialized server
  * @param c configuration to use
  */
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
      struct GNUNET_SERVER_Handle *server,
      const struct GNUNET_CONFIGURATION_Handle *c)
 {
@@ -3997,7 +3976,6 @@ run (void *cls,
   };
   char *keyfile;
 
-  sched = s;
   cfg = c;  
   /* parse configuration */
   if (
@@ -4019,15 +3997,15 @@ run (void *cls,
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _
                   ("Core service is lacking key configuration settings.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown (s);
+      GNUNET_SCHEDULER_shutdown ();
       return;
     }
-  peerinfo = GNUNET_PEERINFO_connect (sched, cfg);
+  peerinfo = GNUNET_PEERINFO_connect (cfg);
   if (NULL == peerinfo)
     {
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _("Could not access PEERINFO service.  Exiting.\n"));
-      GNUNET_SCHEDULER_shutdown (s);
+      GNUNET_SCHEDULER_shutdown ();
       GNUNET_free (keyfile);
       return;
     }
@@ -4038,7 +4016,7 @@ run (void *cls,
       GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                   _("Core service could not access hostkey.  Exiting.\n"));
       GNUNET_PEERINFO_disconnect (peerinfo);
-      GNUNET_SCHEDULER_shutdown (s);
+      GNUNET_SCHEDULER_shutdown ();
       return;
     }
   GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
@@ -4049,23 +4027,21 @@ run (void *cls,
                                                         MAX_NOTIFY_QUEUE);
   GNUNET_SERVER_disconnect_notify (server, &handle_client_disconnect, NULL);
   /* setup transport connection */
-  transport = GNUNET_TRANSPORT_connect (sched,
-                                        cfg,
+  transport = GNUNET_TRANSPORT_connect (cfg,
                                         &my_identity,
                                         NULL,
                                         &handle_transport_receive,
                                         &handle_transport_notify_connect,
                                         &handle_transport_notify_disconnect);
   GNUNET_assert (NULL != transport);
-  stats = GNUNET_STATISTICS_create (sched, "core", cfg);
+  stats = GNUNET_STATISTICS_create ("core", cfg);
 
   GNUNET_STATISTICS_set (stats, gettext_noop ("# discarded CORE_SEND requests"), 0, GNUNET_NO);
   GNUNET_STATISTICS_set (stats, gettext_noop ("# discarded lower priority CORE_SEND requests"), 0, GNUNET_NO);
 
   mst = GNUNET_SERVER_mst_create (&deliver_message,
                                   NULL);
-  GNUNET_SCHEDULER_add_delayed (sched,
-                                GNUNET_TIME_UNIT_FOREVER_REL,
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
                                 &cleaning_task, NULL);
   /* process client requests */
   GNUNET_SERVER_add_handlers (server, handlers);
diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c
index 3fbeca419..65b09c835 100644
--- a/src/core/test_core_api.c
+++ b/src/core/test_core_api.c
@@ -62,7 +62,6 @@ static struct PeerContext p1;
 
 static struct PeerContext p2;
 
-static struct GNUNET_SCHEDULER_Handle *sched;
 
 static int ok;
 
@@ -168,8 +167,8 @@ process_mtype (void *cls,
               "Receiving message from `%4s'.\n", GNUNET_i2s (peer));
   GNUNET_assert (ok == 5);
   OKPP;
-  GNUNET_SCHEDULER_cancel (sched, err_task);
-  GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+  GNUNET_SCHEDULER_cancel (err_task);
+  GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
   return GNUNET_OK;
 }
 
@@ -194,8 +193,7 @@ transmit_ready (void *cls, size_t size, void *buf)
   m->type = htons (MTYPE);
   m->size = htons (sizeof (struct GNUNET_MessageHeader));
   err_task = 
-    GNUNET_SCHEDULER_add_delayed (sched,
-        GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), &terminate_task_error, NULL);
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120), &terminate_task_error, NULL);
 
   return sizeof (struct GNUNET_MessageHeader);
 }
@@ -221,8 +219,7 @@ init_notify (void *cls,
       GNUNET_assert (ok == 2);
       OKPP;
       /* connect p2 */
-      GNUNET_CORE_connect (sched,
-                           p2.cfg,
+      GNUNET_CORE_connect (p2.cfg,
                            TIMEOUT,
                            &p2,
                            &init_notify,                         
@@ -297,7 +294,7 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL, p, NULL, NULL, NULL);
+  p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
   GNUNET_assert (p->th != NULL);
   GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
 }
@@ -305,18 +302,15 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
      char *const *args,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;
-  sched = s;
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
-  GNUNET_CORE_connect (sched,
-                       p1.cfg,
+  GNUNET_CORE_connect (p1.cfg,
                        TIMEOUT,
                        &p1,
                        &init_notify,
diff --git a/src/core/test_core_api_reliability.c b/src/core/test_core_api_reliability.c
index 49fe8f9de..da67bb4d4 100644
--- a/src/core/test_core_api_reliability.c
+++ b/src/core/test_core_api_reliability.c
@@ -82,8 +82,6 @@ static struct PeerContext p1;
 
 static struct PeerContext p2;
 
-static struct GNUNET_SCHEDULER_Handle *sched;
-
 static int ok;
 
 #if VERBOSE
@@ -235,8 +233,8 @@ process_mtype (void *cls,
                   n, s,
                   ntohs (message->size),
                   ntohl (hdr->num));
-      GNUNET_SCHEDULER_cancel (sched, err_task);
-      err_task = GNUNET_SCHEDULER_add_now (sched, &terminate_task_error, NULL);
+      GNUNET_SCHEDULER_cancel (err_task);
+      err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
       return GNUNET_SYSERR;
     }
   if (ntohl (hdr->num) != n)
@@ -246,8 +244,8 @@ process_mtype (void *cls,
                   n, s,
                   ntohs (message->size),
                   ntohl (hdr->num));
-      GNUNET_SCHEDULER_cancel (sched, err_task);
-      err_task = GNUNET_SCHEDULER_add_now (sched, &terminate_task_error, NULL);
+      GNUNET_SCHEDULER_cancel (err_task);
+      err_task = GNUNET_SCHEDULER_add_now (&terminate_task_error, NULL);
       return GNUNET_SYSERR;
     }
 #if VERBOSE
@@ -261,8 +259,8 @@ process_mtype (void *cls,
     fprintf (stderr, ".");
   if (n == TOTAL_MSGS)
     {
-      GNUNET_SCHEDULER_cancel (sched, err_task);
-      GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+      GNUNET_SCHEDULER_cancel (err_task);
+      GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
     }
   else
     {
@@ -334,10 +332,9 @@ transmit_ready (void *cls, size_t size, void *buf)
         break; /* sometimes pack buffer full, sometimes not */
     }
   while (size - ret >= s);
-  GNUNET_SCHEDULER_cancel (sched, err_task);
+  GNUNET_SCHEDULER_cancel (err_task);
   err_task = 
-    GNUNET_SCHEDULER_add_delayed (sched,
-                                  TIMEOUT,
+    GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                                   &terminate_task_error, 
                                   NULL);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
@@ -368,8 +365,7 @@ init_notify (void *cls,
       GNUNET_assert (ok == 2);
       OKPP;
       /* connect p2 */
-      GNUNET_CORE_connect (sched,
-                           p2.cfg,
+      GNUNET_CORE_connect (p2.cfg,
                            TIMEOUT,
                            &p2,
                            &init_notify,                         
@@ -389,8 +385,7 @@ init_notify (void *cls,
                   "Asking core (1) for transmission to peer `%4s'\n",
                   GNUNET_i2s (&p2.id));
       err_task = 
-        GNUNET_SCHEDULER_add_delayed (sched,
-                                      TIMEOUT,
+        GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                                       &terminate_task_error, 
                                       NULL);
       start_time = GNUNET_TIME_absolute_get ();
@@ -444,7 +439,7 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL, p, NULL, NULL, NULL);
+  p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
   GNUNET_assert (p->th != NULL);
   GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
 }
@@ -452,18 +447,15 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
      char *const *args,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;
-  sched = s;
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
-  GNUNET_CORE_connect (sched,
-                       p1.cfg,
+  GNUNET_CORE_connect (p1.cfg,
                        TIMEOUT,
                        &p1,
                        &init_notify,
diff --git a/src/core/test_core_api_start_only.c b/src/core/test_core_api_start_only.c
index 958defbf9..da7217f39 100644
--- a/src/core/test_core_api_start_only.c
+++ b/src/core/test_core_api_start_only.c
@@ -57,7 +57,6 @@ static struct PeerContext p1;
 
 static struct PeerContext p2;
 
-static struct GNUNET_SCHEDULER_Handle *sched;
 
 static int ok;
 
@@ -126,8 +125,7 @@ init_notify (void *cls,
   if (cls == &p1)
     {
       /* connect p2 */
-      GNUNET_CORE_connect (sched,
-                           p2.cfg,
+      GNUNET_CORE_connect (p2.cfg,
                            TIMEOUT,
                            &p2,
                            &init_notify,                         
@@ -166,18 +164,15 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
      char *const *args,
      const char *cfgfile, 
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;
-  sched = s;
   setup_peer (&p1, "test_core_api_peer1.conf");
   setup_peer (&p2, "test_core_api_peer2.conf");
-  GNUNET_CORE_connect (sched,
-                       p1.cfg,
+  GNUNET_CORE_connect (p1.cfg,
                        TIMEOUT,
                        &p1,
                        &init_notify,
diff --git a/src/core/test_core_quota_compliance.c b/src/core/test_core_quota_compliance.c
index d69fb0905..822dc2c46 100644
--- a/src/core/test_core_quota_compliance.c
+++ b/src/core/test_core_quota_compliance.c
@@ -105,8 +105,6 @@ static struct PeerContext p1;
 
 static struct PeerContext p2;
 
-static struct GNUNET_SCHEDULER_Handle *sched;
-
 static int ok;
 static int measurement_running;
 
@@ -147,7 +145,7 @@ terminate_task_error (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_break (0);
   if (send_task != GNUNET_SCHEDULER_NO_TASK)
-          GNUNET_SCHEDULER_cancel (sched,send_task);
+          GNUNET_SCHEDULER_cancel (send_task);
   GNUNET_CORE_disconnect (p1.ch);
   p1.ch = NULL;
   GNUNET_CORE_disconnect (p2.ch);
@@ -247,9 +245,9 @@ measurement_end (void *cls,
                 return;
 
           if (err_task != GNUNET_SCHEDULER_NO_TASK)
-                  GNUNET_SCHEDULER_cancel (sched, err_task);
+                  GNUNET_SCHEDULER_cancel (err_task);
           if (send_task != GNUNET_SCHEDULER_NO_TASK)
-                  GNUNET_SCHEDULER_cancel (sched,send_task);
+                  GNUNET_SCHEDULER_cancel (send_task);
 
           GNUNET_STATISTICS_get(p1.stats,"core","# discarded CORE_SEND requests",GNUNET_TIME_UNIT_SECONDS, &next_fin, &check_2, &p1);
           GNUNET_STATISTICS_get(p1.stats,"core","# discarded CORE_SEND requests",GNUNET_TIME_UNIT_SECONDS, &next_fin, &check_2, &p2);
@@ -271,7 +269,7 @@ measurement_end (void *cls,
                           (total_bytes_sent/(duration.rel_value / 1000)/1024),current_quota_p1_in/1024);
 
 
-      GNUNET_SCHEDULER_add_now (sched, &terminate_task, NULL);
+      GNUNET_SCHEDULER_add_now (&terminate_task, NULL);
 }
 
 static size_t
@@ -307,12 +305,10 @@ static void measure (unsigned long long quota_p1, unsigned long long quota_p2 )
               "Asking core (1) for transmission to peer `%4s'\n",
               GNUNET_i2s (&p2.id));
 #endif
-  err_task = GNUNET_SCHEDULER_add_delayed (sched,
-                              TIMEOUT,
+  err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                               &terminate_task_error,
                               NULL);
-  measure_task = GNUNET_SCHEDULER_add_delayed (sched,
-                              MEASUREMENT_INTERVALL,
+  measure_task = GNUNET_SCHEDULER_add_delayed (MEASUREMENT_INTERVALL,
                               &measurement_end,
                               NULL);
   start_time = GNUNET_TIME_absolute_get ();
@@ -420,17 +416,16 @@ transmit_ready (void *cls, size_t size, void *buf)
         break; /* sometimes pack buffer full, sometimes not */
     }
   while (size - ret >= s);
-  GNUNET_SCHEDULER_cancel (sched, err_task);
-  err_task = GNUNET_SCHEDULER_add_delayed (sched,
-                                  TIMEOUT,
+  GNUNET_SCHEDULER_cancel (err_task);
+  err_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
                                   &terminate_task_error, 
                                   NULL);
 
   total_bytes += ret;
   total_bytes_sent += ret;
   if (send_task != GNUNET_SCHEDULER_NO_TASK)
-          GNUNET_SCHEDULER_cancel(sched, send_task);
-  send_task = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 20), &send_tsk, NULL);
+          GNUNET_SCHEDULER_cancel(send_task);
+  send_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, 20), &send_tsk, NULL);
 
   return ret;
 }
@@ -457,8 +452,7 @@ init_notify (void *cls,
       GNUNET_assert (ok == 2);
       OKPP;
       /* connect p2 */
-      GNUNET_CORE_connect (sched,
-                           p2.cfg,
+      GNUNET_CORE_connect (p2.cfg,
                            TIMEOUT,
                            &p2,
                            &init_notify,                         
@@ -521,9 +515,9 @@ setup_peer (struct PeerContext *p, const char *cfgname)
                                         "-c", cfgname, NULL);
 #endif
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
-  p->stats = GNUNET_STATISTICS_create (sched, "core", p->cfg);
+  p->stats = GNUNET_STATISTICS_create ("core", p->cfg);
   GNUNET_assert (p->stats != NULL);
-  p->th = GNUNET_TRANSPORT_connect (sched, p->cfg, NULL, p, NULL, NULL, NULL);
+  p->th = GNUNET_TRANSPORT_connect (p->cfg, NULL, p, NULL, NULL, NULL);
   GNUNET_assert (p->th != NULL);
   GNUNET_TRANSPORT_get_hello (p->th, &process_hello, p);
 }
@@ -531,18 +525,15 @@ setup_peer (struct PeerContext *p, const char *cfgname)
 
 static void
 run (void *cls,
-     struct GNUNET_SCHEDULER_Handle *s,
      char *const *args,
      const char *cfgfile,
      const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_assert (ok == 1);
   OKPP;
-  sched = s;
   setup_peer (&p1, "test_core_quota_peer1.conf");
   setup_peer (&p2, "test_core_quota_peer2.conf");
-  GNUNET_CORE_connect (sched,
-                       p1.cfg,
+  GNUNET_CORE_connect (p1.cfg,
                        TIMEOUT,
                        &p1,
                        &init_notify,