Nearly finished. Call to set_wakeup missing in case of tasks added to pending_timeout

[oweals/gnunet.git] / src / util / scheduler.c

diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index e2f6700e4b20918917e9963828510bb038c9f4ec..9061200bd0866919f53eeb8c8b029b9c1655b92a 100644 (file)
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -1,10 +1,10 @@
 /*
       This file is part of GNUnet
 /*
       This file is part of GNUnet

-      (C) 2009, 2011 Christian Grothoff (and other contributing authors)
+      Copyright (C) 2009-2017 GNUnet e.V.

 
       GNUnet is free software; you can redistribute it and/or modify
       it under the terms of the GNU General Public License as published
 
       GNUnet is free software; you can redistribute it and/or modify
       it under the terms of the GNU General Public License as published

-      by the Free Software Foundation; either version 2, or (at your
+      by the Free Software Foundation; either version 3, or (at your

       option) any later version.
 
       GNUnet is distributed in the hope that it will be useful, but
       option) any later version.
 
       GNUnet is distributed in the hope that it will be useful, but


@@ -14,26 +14,26 @@
 
       You should have received a copy of the GNU General Public License
       along with GNUnet; see the file COPYING.  If not, write to the
 
       You should have received a copy of the GNU General Public License
       along with GNUnet; see the file COPYING.  If not, write to the

-      Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-      Boston, MA 02111-1307, USA.
+      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+      Boston, MA 02110-1301, USA.

  */
  */

-

 /**
  * @file util/scheduler.c
  * @brief schedule computations using continuation passing style
  * @author Christian Grothoff
  */
 #include "platform.h"
 /**
  * @file util/scheduler.c
  * @brief schedule computations using continuation passing style
  * @author Christian Grothoff
  */
 #include "platform.h"

-#include "gnunet_common.h"
-#include "gnunet_os_lib.h"
-#include "gnunet_scheduler_lib.h"
-#include "gnunet_signal_lib.h"
-#include "gnunet_time_lib.h"
+#include "gnunet_util_lib.h"

 #include "disk.h"
 #include "disk.h"

-#ifdef LINUX
-#include "execinfo.h"
+
+#define LOG(kind,...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)
+
+#define LOG_STRERROR(kind,syscall) GNUNET_log_from_strerror (kind, "util-scheduler", syscall)

 
 
 
 

+#if HAVE_EXECINFO_H
+#include "execinfo.h"
+

 /**
  * Use lsof to generate file descriptor reports on select error?
  * (turn off for stable releases).
 /**
  * Use lsof to generate file descriptor reports on select error?
  * (turn off for stable releases).


@@ -56,8 +56,6 @@
 #define MAX_TRACE_DEPTH 50
 #endif
 
 #define MAX_TRACE_DEPTH 50
 #endif
 

-#define DEBUG_TASKS GNUNET_NO
-

 /**
  * Should we figure out which tasks are delayed for a while
  * before they are run? (Consider using in combination with EXECINFO).
 /**
  * Should we figure out which tasks are delayed for a while
  * before they are run? (Consider using in combination with EXECINFO).


@@ -70,26 +68,66 @@
  */
 #define DELAY_THRESHOLD GNUNET_TIME_UNIT_SECONDS
 
  */
 #define DELAY_THRESHOLD GNUNET_TIME_UNIT_SECONDS
 

+
+/**
+ * Argument to be passed from the driver to
+ * #GNUNET_SCHEDULER_run_from_driver().  Contains the
+ * scheduler's internal state.
+ */
+struct GNUNET_SCHEDULER_Handle
+{
+  /**
+   * Passed here to avoid constantly allocating/deallocating
+   * this element, but generally we want to get rid of this.
+   * @deprecated
+   */
+  struct GNUNET_NETWORK_FDSet *rs;
+
+  /**
+   * Passed here to avoid constantly allocating/deallocating
+   * this element, but generally we want to get rid of this.
+   * @deprecated
+   */
+  struct GNUNET_NETWORK_FDSet *ws;
+
+  /**
+   * Driver we used for the event loop.
+   */
+  const struct GNUNET_SCHEDULER_Driver *driver;
+
+};
+
+

 /**
 /**

- * Linked list of pending tasks.
+ * Entry in list of pending tasks.

  */
  */

-struct Task
+struct GNUNET_SCHEDULER_Task

 {
   /**
    * This is a linked list.
    */
 {
   /**
    * This is a linked list.
    */

-  struct Task *next;
+  struct GNUNET_SCHEDULER_Task *next;
+
+  /**
+   * This is a linked list.
+   */
+  struct GNUNET_SCHEDULER_Task *prev;

 
   /**
    * Function to run when ready.
    */
 
   /**
    * Function to run when ready.
    */

-  GNUNET_SCHEDULER_Task callback;
+  GNUNET_SCHEDULER_TaskCallback callback;

 
   /**
 
   /**

-   * Closure for the callback.
+   * Closure for the @e callback.

    */
   void *callback_cls;
 
    */
   void *callback_cls;
 

+  /**
+   * Handle to the scheduler's state.
+   */
+  const struct GNUNET_SCHEDULER_Handle *sh;
+

   /**
    * Set of file descriptors this task is waiting
    * for for reading.  Once ready, this is updated
   /**
    * Set of file descriptors this task is waiting
    * for for reading.  Once ready, this is updated


@@ -106,18 +144,20 @@ struct Task
   struct GNUNET_NETWORK_FDSet *write_set;
 
   /**
   struct GNUNET_NETWORK_FDSet *write_set;
 
   /**

-   * Unique task identifier.
+   * Information about which FDs are ready for this task (and why).

    */
    */

-  GNUNET_SCHEDULER_TaskIdentifier id;
+  const struct GNUNET_SCHEDULER_FdInfo *fds;

 
   /**
 
   /**

-   * Identifier of a prerequisite task.
+   * Storage location used for @e fds if we want to avoid
+   * a separate malloc() call in the common case that this
+   * task is only about a single FD.

    */
    */

-  GNUNET_SCHEDULER_TaskIdentifier prereq_id;
+  struct GNUNET_SCHEDULER_FdInfo fdx;

 
   /**
    * Absolute timeout value for the task, or
 
   /**
    * Absolute timeout value for the task, or

-   * GNUNET_TIME_UNIT_FOREVER_ABS for "no timeout".
+   * #GNUNET_TIME_UNIT_FOREVER_ABS for "no timeout".

    */
   struct GNUNET_TIME_Absolute timeout;
 
    */
   struct GNUNET_TIME_Absolute timeout;
 


@@ -128,6 +168,11 @@ struct Task
   struct GNUNET_TIME_Absolute start_time;
 #endif
 
   struct GNUNET_TIME_Absolute start_time;
 #endif
 

+  /**
+   * Size of the @e fds array.
+   */
+  unsigned int fds_len;
+

   /**
    * Why is the task ready?  Set after task is added to ready queue.
    * Initially set to zero.  All reasons that have already been
   /**
    * Why is the task ready?  Set after task is added to ready queue.
    * Initially set to zero.  All reasons that have already been


@@ -156,6 +201,16 @@ struct Task
    */
   int lifeness;
 
    */
   int lifeness;
 

+  /**
+   * Is this task run on shutdown?
+   */
+  int on_shutdown;
+
+  /**
+   * Is this task in the ready list?
+   */
+  int in_ready_list;
+

 #if EXECINFO
   /**
    * Array of strings which make up a backtrace from the point when this
 #if EXECINFO
   /**
    * Array of strings which make up a backtrace from the point when this


@@ -172,11 +227,34 @@ struct Task
 
 };
 
 
 };
 

+/**
+ * The driver used for the event loop. Will be handed over to
+ * the scheduler in #GNUNET_SCHEDULER_run_from_driver(), peristed
+ * there in this variable for later use in functions like
+ * #GNUNET_SCHEDULER_add_select(), #add_without_sets() and
+ * #GNUNET_SCHEDULER_cancel().
+ */
+static const struct GNUNET_SCHEDULER_Driver *scheduler_driver;
+
+/**
+ * Head of list of tasks waiting for an event.
+ */
+static struct GNUNET_SCHEDULER_Task *pending_head;
+
+/**
+ * Tail of list of tasks waiting for an event.
+ */
+static struct GNUNET_SCHEDULER_Task *pending_tail;
+
+/**
+ * Head of list of tasks waiting for shutdown.
+ */
+static struct GNUNET_SCHEDULER_Task *shutdown_head;

 
 /**
 
 /**

- * List of tasks waiting for an event.
+ * Tail of list of tasks waiting for shutdown.

  */
  */

-static struct Task *pending;
+static struct GNUNET_SCHEDULER_Task *shutdown_tail;

 
 /**
  * List of tasks waiting ONLY for a timeout event.
 
 /**
  * List of tasks waiting ONLY for a timeout event.


@@ -185,38 +263,37 @@ static struct Task *pending;
  * building select sets (we just look at the head
  * to determine the respective timeout ONCE).
  */
  * building select sets (we just look at the head
  * to determine the respective timeout ONCE).
  */

-static struct Task *pending_timeout;
+static struct GNUNET_SCHEDULER_Task *pending_timeout_head;

 
 /**
 
 /**

- * Last inserted task waiting ONLY for a timeout event.
- * Used to (heuristically) speed up insertion.
+ * 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).

  */
  */

-static struct Task *pending_timeout_last;
+static struct GNUNET_SCHEDULER_Task *pending_timeout_tail;

 
 /**
 
 /**

- * ID of the task that is running right now.
+ * Last inserted task waiting ONLY for a timeout event.
+ * Used to (heuristically) speed up insertion.

  */
  */

-static struct Task *active_task;
+static struct GNUNET_SCHEDULER_Task *pending_timeout_last;

 
 /**
 
 /**

- * List of tasks ready to run right now,
- * grouped by importance.
+ * ID of the task that is running right now.

  */
  */

-static struct Task *ready[GNUNET_SCHEDULER_PRIORITY_COUNT];
+static struct GNUNET_SCHEDULER_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).
+ * Head of list of tasks ready to run right now, grouped by importance.

  */
  */

-static GNUNET_SCHEDULER_TaskIdentifier last_id;
+static struct GNUNET_SCHEDULER_Task *ready_head[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.
+ * Tail of list of tasks ready to run right now, grouped by importance.

  */
  */

-static GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id;
+static struct GNUNET_SCHEDULER_Task *ready_tail[GNUNET_SCHEDULER_PRIORITY_COUNT];

 
 /**
  * Number of tasks on the ready list.
 
 /**
  * Number of tasks on the ready list.


@@ -247,20 +324,26 @@ static int current_lifeness;
 
 /**
  * Function to use as a select() in the scheduler.
 
 /**
  * Function to use as a select() in the scheduler.

- * If NULL, we use GNUNET_NETWORK_socket_select ().
+ * If NULL, we use GNUNET_NETWORK_socket_select().

  */
 static GNUNET_SCHEDULER_select scheduler_select;
 
 /**
  */
 static GNUNET_SCHEDULER_select scheduler_select;
 
 /**

- * Closure for 'scheduler_select'.
+ * Task context of the current task.
+ */
+static struct GNUNET_SCHEDULER_TaskContext tc;
+
+/**
+ * Closure for #scheduler_select.

  */
 static void *scheduler_select_cls;
 
  */
 static void *scheduler_select_cls;
 

+

 /**
  * Sets the select function to use in the scheduler (scheduler_select).
  *
  * @param new_select new select function to use
 /**
  * Sets the select function to use in the scheduler (scheduler_select).
  *
  * @param new_select new select function to use

- * @param new_select_cls closure for 'new_select'
+ * @param new_select_cls closure for @a new_select

  * @return previously used select function, NULL for default
  */
 void
  * @return previously used select function, NULL for default
  */
 void


@@ -288,60 +371,6 @@ check_priority (enum GNUNET_SCHEDULER_Priority p)
 }
 
 
 }
 
 

-/**
- * Is a task with this identifier still pending?  Also updates
- * "lowest_pending_id" as a side-effect (for faster checks in the
- * future), but only if the return value is "GNUNET_NO" (and
- * the "lowest_pending_id" check failed).
- *
- * @param id which task are we checking for
- * @return GNUNET_YES if so, GNUNET_NO if not
- */
-static int
-is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
-{
-  struct Task *pos;
-  enum GNUNET_SCHEDULER_Priority p;
-  GNUNET_SCHEDULER_TaskIdentifier min;
-
-  if (id < lowest_pending_id)
-    return GNUNET_NO;
-  min = -1;                     /* maximum value */
-  pos = pending;
-  while (pos != NULL)
-  {
-    if (pos->id == id)
-      return GNUNET_YES;
-    if (pos->id < min)
-      min = pos->id;
-    pos = pos->next;
-  }
-  pos = pending_timeout;
-  while (pos != NULL)
-  {
-    if (pos->id == id)
-      return GNUNET_YES;
-    if (pos->id < min)
-      min = pos->id;
-    pos = pos->next;
-  }
-  for (p = 0; p < GNUNET_SCHEDULER_PRIORITY_COUNT; p++)
-  {
-    pos = ready[p];
-    while (pos != NULL)
-    {
-      if (pos->id == id)
-        return GNUNET_YES;
-      if (pos->id < min)
-        min = pos->id;
-      pos = pos->next;
-    }
-  }
-  lowest_pending_id = min;
-  return GNUNET_NO;
-}
-
-

 /**
  * Update all sets and timeout for select.
  *
 /**
  * Update all sets and timeout for select.
  *


@@ -349,50 +378,55 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
  * @param ws write-set, set to all FDs we would like to write (updated)
  * @param timeout next timeout (updated)
  */
  * @param ws write-set, set to all FDs we would like to write (updated)
  * @param timeout next timeout (updated)
  */

-static void
-update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
-             struct GNUNET_TIME_Relative *timeout)
+void getNextPendingTimeout(struct GNUNET_TIME_Relative *timeout)

 {
 {

-  struct Task *pos;
+
+  struct GNUNET_SCHEDULER_Task *pos;

   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_Relative to;
 
   now = GNUNET_TIME_absolute_get ();
   struct GNUNET_TIME_Absolute now;
   struct GNUNET_TIME_Relative to;
 
   now = GNUNET_TIME_absolute_get ();

-  pos = pending_timeout;
-  if (pos != NULL)
+  pos = pending_timeout_head;
+  if (NULL != pos)

   {
     to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
   {
     to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);

-    if (timeout->rel_value > to.rel_value)
+    if (timeout->rel_value_us > to.rel_value_us)

       *timeout = to;
       *timeout = to;

-    if (pos->reason != 0)
+    if (0 != pos->reason)

       *timeout = GNUNET_TIME_UNIT_ZERO;
   }
       *timeout = GNUNET_TIME_UNIT_ZERO;
   }

-  pos = pending;
-  while (pos != NULL)
+}
+
+static void
+update_sets (struct GNUNET_NETWORK_FDSet *rs,
+             struct GNUNET_NETWORK_FDSet *ws,
+             struct GNUNET_TIME_Relative *timeout)
+{
+  struct GNUNET_SCHEDULER_Task *pos;
+  struct GNUNET_TIME_Absolute now;
+  struct GNUNET_TIME_Relative to;
+
+  now = GNUNET_TIME_absolute_get ();
+
+  getNextPendingTimeout(timeout);
+  for (pos = pending_head; NULL != pos; pos = pos->next)

   {
   {

-    if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) &&
-        (GNUNET_YES == is_pending (pos->prereq_id)))
-    {
-      pos = pos->next;
-      continue;
-    }
-    if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+    if (pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us)

     {
       to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
     {
       to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);

-      if (timeout->rel_value > to.rel_value)
+      if (timeout->rel_value_us > to.rel_value_us)

         *timeout = to;
     }
         *timeout = to;
     }

-    if (pos->read_fd != -1)
+    if (-1 != pos->read_fd)

       GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
       GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);

-    if (pos->write_fd != -1)
+    if (-1 != pos->write_fd)

       GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
       GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);

-    if (pos->read_set != NULL)
+    if (NULL != pos->read_set)

       GNUNET_NETWORK_fdset_add (rs, pos->read_set);
       GNUNET_NETWORK_fdset_add (rs, pos->read_set);

-    if (pos->write_set != NULL)
+    if (NULL != pos->write_set)

       GNUNET_NETWORK_fdset_add (ws, pos->write_set);
       GNUNET_NETWORK_fdset_add (ws, pos->write_set);

-    if (pos->reason != 0)
+    if (0 != pos->reason)

       *timeout = GNUNET_TIME_UNIT_ZERO;
       *timeout = GNUNET_TIME_UNIT_ZERO;

-    pos = pos->next;

   }
 }
 
   }
 }
 


@@ -400,11 +434,11 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
 /**
  * Check if the ready set overlaps with the set we want to have ready.
  * If so, update the want set (set all FDs that are ready).  If not,
 /**
  * Check if the ready set overlaps with the set we want to have ready.
  * If so, update the want set (set all FDs that are ready).  If not,

- * return GNUNET_NO.
+ * return #GNUNET_NO.

  *
  * @param ready set that is ready
  * @param want set that we want to be ready
  *
  * @param ready set that is ready
  * @param want set that we want to be ready

- * @return GNUNET_YES if there was some overlap
+ * @return #GNUNET_YES if there was some overlap

  */
 static int
 set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
  */
 static int
 set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,


@@ -431,17 +465,18 @@ set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
  * @param now the current time
  * @param rs set of FDs ready for reading
  * @param ws set of FDs ready for writing
  * @param now the current time
  * @param rs set of FDs ready for reading
  * @param ws set of FDs ready for writing

- * @return GNUNET_YES if we can run it, GNUNET_NO if not.
+ * @return #GNUNET_YES if we can run it, #GNUNET_NO if not.

  */
 static int
  */
 static int

-is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
+is_ready (struct GNUNET_SCHEDULER_Task *task,
+          struct GNUNET_TIME_Absolute now,

           const struct GNUNET_NETWORK_FDSet *rs,
           const struct GNUNET_NETWORK_FDSet *ws)
 {
   enum GNUNET_SCHEDULER_Reason reason;
 
   reason = task->reason;
           const struct GNUNET_NETWORK_FDSet *rs,
           const struct GNUNET_NETWORK_FDSet *ws)
 {
   enum GNUNET_SCHEDULER_Reason reason;
 
   reason = task->reason;

-  if (now.abs_value >= task->timeout.abs_value)
+  if (now.abs_value_us >= task->timeout.abs_value_us)

     reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
       (((task->read_fd != -1) &&
     reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
       (((task->read_fd != -1) &&


@@ -453,17 +488,9 @@ is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
         (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd)))
        || (set_overlaps (ws, task->write_set))))
     reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
         (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd)))
        || (set_overlaps (ws, task->write_set))))
     reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;

-  if (reason == 0)
+  if (0 == reason)

     return GNUNET_NO;           /* not ready */
     return GNUNET_NO;           /* not ready */

-  if (task->prereq_id != GNUNET_SCHEDULER_NO_TASK)
-  {
-    if (GNUNET_YES == is_pending (task->prereq_id))
-    {
-      task->reason = reason;
-      return GNUNET_NO;         /* prereq waiting */
-    }
-    reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
-  }
+  reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;

   task->reason = reason;
   return GNUNET_YES;
 }
   task->reason = reason;
   return GNUNET_YES;
 }


@@ -475,14 +502,14 @@ is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
  * @param task task ready for execution
  */
 static void
  * @param task task ready for execution
  */
 static void

-queue_ready_task (struct Task *task)
+queue_ready_task (struct GNUNET_SCHEDULER_Task *task)

 {
 {

-  enum GNUNET_SCHEDULER_Priority p = task->priority;
+  enum GNUNET_SCHEDULER_Priority p = check_priority (task->priority);

 
 

-  if (0 != (task->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
-    p = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
-  task->next = ready[check_priority (p)];
-  ready[check_priority (p)] = task;
+  GNUNET_CONTAINER_DLL_insert (ready_head[p],
+                               ready_tail[p],
+                               task);
+  task->in_ready_list = GNUNET_YES;

   ready_count++;
 }
 
   ready_count++;
 }
 


@@ -498,94 +525,58 @@ static void
 check_ready (const struct GNUNET_NETWORK_FDSet *rs,
              const struct GNUNET_NETWORK_FDSet *ws)
 {
 check_ready (const struct GNUNET_NETWORK_FDSet *rs,
              const struct GNUNET_NETWORK_FDSet *ws)
 {

-  struct Task *pos;
-  struct Task *prev;
-  struct Task *next;
+  struct GNUNET_SCHEDULER_Task *pos;
+  struct GNUNET_SCHEDULER_Task *next;

   struct GNUNET_TIME_Absolute now;
 
   now = GNUNET_TIME_absolute_get ();
   struct GNUNET_TIME_Absolute now;
 
   now = GNUNET_TIME_absolute_get ();

-  prev = NULL;
-  pos = pending_timeout;
-  while (pos != NULL)
+  while (NULL != (pos = pending_timeout_head))

   {
   {

-    next = pos->next;
-    if (now.abs_value >= pos->timeout.abs_value)
+    if (now.abs_value_us >= pos->timeout.abs_value_us)

       pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
     if (0 == pos->reason)
       break;
       pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
     if (0 == pos->reason)
       break;

-    pending_timeout = next;
+    GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
+                                 pending_timeout_tail,
+                                 pos);

     if (pending_timeout_last == pos)
       pending_timeout_last = NULL;
     queue_ready_task (pos);
     if (pending_timeout_last == pos)
       pending_timeout_last = NULL;
     queue_ready_task (pos);

-    pos = next;

   }
   }

-  pos = pending;
-  while (pos != NULL)
+  pos = pending_head;
+  while (NULL != pos)

   {
   {

-#if DEBUG_TASKS
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Checking readiness of task: %llu / %p\n", pos->id,
-                pos->callback_cls);
-#endif

     next = pos->next;
     if (GNUNET_YES == is_ready (pos, now, rs, ws))
     {
     next = pos->next;
     if (GNUNET_YES == is_ready (pos, now, rs, ws))
     {

-      if (prev == NULL)
-        pending = next;
-      else
-        prev->next = next;
+      GNUNET_CONTAINER_DLL_remove (pending_head,
+                                   pending_tail,
+                                   pos);

       queue_ready_task (pos);
       queue_ready_task (pos);

-      pos = next;
-      continue;

     }
     }

-    prev = pos;

     pos = next;
   }
 }
 
 
 /**
     pos = next;
   }
 }
 
 
 /**

- * Request the shutdown of a scheduler.  Marks all currently
- * pending tasks as ready because of shutdown.  This will
- * cause all tasks to run (as soon as possible, respecting
- * priorities and prerequisite tasks).  Note that tasks
- * scheduled AFTER this call may still be delayed arbitrarily.
+ * Request the shutdown of a scheduler.  Marks all tasks
+ * awaiting shutdown as ready. Note that tasks
+ * scheduled with #GNUNET_SCHEDULER_add_shutdown() AFTER this call
+ * will be delayed until the next shutdown signal.

  */
 void
 GNUNET_SCHEDULER_shutdown ()
 {
  */
 void
 GNUNET_SCHEDULER_shutdown ()
 {

-  struct Task *pos;
-  int i;
+  struct GNUNET_SCHEDULER_Task *pos;

 
 

-  pos = pending_timeout;
-  while (pos != NULL)
+  while (NULL != (pos = shutdown_head))

   {
   {

+    GNUNET_CONTAINER_DLL_remove (shutdown_head,
+                                 shutdown_tail,
+                                 pos);

     pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
     pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;

-    /* we don't move the task into the ready queue yet; check_ready
-     * will do that later, possibly adding additional
-     * readiness-factors */
-    pos = pos->next;
-  }
-  pos = pending;
-  while (pos != NULL)
-  {
-    pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
-    /* we don't move the task into the ready queue yet; check_ready
-     * will do that later, possibly adding additional
-     * readiness-factors */
-    pos = pos->next;
-  }
-  for (i = 0; i < GNUNET_SCHEDULER_PRIORITY_COUNT; i++)
-  {
-    pos = ready[i];
-    while (pos != NULL)
-    {
-      pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
-      /* we don't move the task into the ready queue yet; check_ready
-       * will do that later, possibly adding additional
-       * readiness-factors */
-      pos = pos->next;
-    }
+    queue_ready_task (pos);

   }
 }
 
   }
 }
 


@@ -596,7 +587,7 @@ GNUNET_SCHEDULER_shutdown ()
  * @param t task to destroy
  */
 static void
  * @param t task to destroy
  */
 static void

-destroy_task (struct Task *t)
+destroy_task (struct GNUNET_SCHEDULER_Task *t)

 {
   if (NULL != t->read_set)
     GNUNET_NETWORK_fdset_destroy (t->read_set);
 {
   if (NULL != t->read_set)
     GNUNET_NETWORK_fdset_destroy (t->read_set);


@@ -609,6 +600,27 @@ destroy_task (struct Task *t)
 }
 
 
 }
 
 

+/**
+ * Output stack trace of task @a t.
+ *
+ * @param t task to dump stack trace of
+ */
+static void
+dump_backtrace (struct GNUNET_SCHEDULER_Task *t)
+{
+#if EXECINFO
+  unsigned int i;
+
+  for (i = 0; i < t->num_backtrace_strings; i++)
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+   "Task %p trace %u: %s\n",
+   t,
+   i,
+   t->backtrace_strings[i]);
+#endif
+}
+
+

 /**
  * Run at least one task in the highest-priority queue that is not
  * empty.  Keep running tasks until we are either no longer running
 /**
  * Run at least one task in the highest-priority queue that is not
  * empty.  Keep running tasks until we are either no longer running


@@ -620,85 +632,82 @@ destroy_task (struct Task *t)
  * @param ws FDs ready for writing
  */
 static void
  * @param ws FDs ready for writing
  */
 static void

-run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
+run_ready (struct GNUNET_NETWORK_FDSet *rs,
+           struct GNUNET_NETWORK_FDSet *ws)

 {
   enum GNUNET_SCHEDULER_Priority p;
 {
   enum GNUNET_SCHEDULER_Priority p;

-  struct Task *pos;
-  struct GNUNET_SCHEDULER_TaskContext tc;
+  struct GNUNET_SCHEDULER_Task *pos;

 
   max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
   do
   {
 
   max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
   do
   {

-    if (ready_count == 0)
+    if (0 == ready_count)

       return;
       return;

-    GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
+    GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);

     /* 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--)
     {
     /* 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 = ready[p];
-      if (pos != NULL)
+      pos = ready_head[p];
+      if (NULL != pos)

         break;
     }
         break;
     }

-    GNUNET_assert (pos != NULL);        /* ready_count wrong? */
-    ready[p] = pos->next;
+    GNUNET_assert (NULL != pos);        /* ready_count wrong? */
+    GNUNET_CONTAINER_DLL_remove (ready_head[p],
+                                 ready_tail[p],
+                                 pos);

     ready_count--;
     ready_count--;

-    if (current_priority != pos->priority)
-    {
-      current_priority = pos->priority;
-      (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (),
-                                             pos->priority);
-    }
+    current_priority = pos->priority;

     current_lifeness = pos->lifeness;
     active_task = pos;
 #if PROFILE_DELAYS
     current_lifeness = pos->lifeness;
     active_task = pos;
 #if PROFILE_DELAYS

-    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value >
-        DELAY_THRESHOLD.rel_value)
+    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
+        DELAY_THRESHOLD.rel_value_us)

     {
     {

-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Task %llu took %llums to be scheduled\n", pos->id,
-                  (unsigned long long)
-                  GNUNET_TIME_absolute_get_duration
-                  (pos->start_time).rel_value);
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+     "Task %p took %s to be scheduled\n",
+           pos,
+           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
+                                                   GNUNET_YES));

     }
 #endif
     tc.reason = pos->reason;
     }
 #endif
     tc.reason = pos->reason;

-    tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set;
-    if ((pos->read_fd != -1) &&
+    tc.read_ready = (NULL == pos->read_set) ? rs : pos->read_set;
+    if ((-1 != pos->read_fd) &&

         (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)))
       GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
         (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)))
       GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);

-    tc.write_ready = (pos->write_set == NULL) ? ws : pos->write_set;
-    if ((pos->write_fd != -1) &&
+    tc.write_ready = (NULL == pos->write_set) ? ws : pos->write_set;
+    if ((-1 != pos->write_fd) &&

         (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
       GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
         (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
       GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);

-    if (((tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY) != 0) &&
-        (pos->write_fd != -1) &&
+    if ((0 != (tc.reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
+        (-1 != pos->write_fd) &&

         (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
         (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))

-      abort ();                 // added to ready in previous select loop!
-#if DEBUG_TASKS
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Running task: %llu / %p\n", pos->id,
-                pos->callback_cls);
-#endif
-    pos->callback (pos->callback_cls, &tc);
-#if EXECINFO
-    int i;
-
-    for (i = 0; i < pos->num_backtrace_strings; i++)
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Task %llu trace %d: %s\n", pos->id,
-                  i, pos->backtrace_strings[i]);
-#endif
+      GNUNET_assert (0);          // added to ready in previous select loop!
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+   "Running task: %p\n",
+         pos);
+    pos->callback (pos->callback_cls);
+    dump_backtrace (pos);

     active_task = NULL;
     destroy_task (pos);
     tasks_run++;
   }
     active_task = NULL;
     destroy_task (pos);
     tasks_run++;
   }

-  while ((pending == NULL) || (p >= max_priority_added));
+  while ((NULL == pending_head) || (p >= max_priority_added));

 }
 
 }
 

+

 /**
  * Pipe used to communicate shutdown via signal.
  */
 static struct GNUNET_DISK_PipeHandle *shutdown_pipe_handle;
 
 /**
  * Pipe used to communicate shutdown via signal.
  */
 static struct GNUNET_DISK_PipeHandle *shutdown_pipe_handle;
 

+/**
+ * Process ID of this process at the time we installed the various
+ * signal handlers.
+ */
+static pid_t my_pid;
+

 /**
  * Signal handler called for SIGPIPE.
  */
 /**
  * Signal handler called for SIGPIPE.
  */


@@ -709,6 +718,26 @@ sighandler_pipe ()
   return;
 }
 #endif
   return;
 }
 #endif

+
+
+/**
+ * Wait for a short time.
+ * Sleeps for @a ms ms (as that should be long enough for virtually all
+ * modern systems to context switch and allow another process to do
+ * some 'real' work).
+ *
+ * @param ms how many ms to wait
+ */
+static void
+short_wait (unsigned int ms)
+{
+  struct GNUNET_TIME_Relative timeout;
+
+  timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS, ms);
+  (void) GNUNET_NETWORK_socket_select (NULL, NULL, NULL, timeout);
+}
+
+

 /**
  * Signal handler called for signals that should cause us to shutdown.
  */
 /**
  * Signal handler called for signals that should cause us to shutdown.
  */


@@ -718,6 +747,9 @@ sighandler_shutdown ()
   static char c;
   int old_errno = errno;        /* backup errno */
 
   static char c;
   int old_errno = errno;        /* backup errno */
 

+  if (getpid () != my_pid)
+    exit (1);                   /* we have fork'ed since the signal handler was created,
+                                 * ignore the signal, see https://gnunet.org/vfork discussion */

   GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
                           (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
                           &c, sizeof (c));
   GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
                           (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
                           &c, sizeof (c));


@@ -726,26 +758,29 @@ sighandler_shutdown ()
 
 
 /**
 
 
 /**

- * Check if the system is still life. Trigger shutdown if we
+ * Check if the system is still alive. Trigger shutdown if we

  * have tasks, but none of them give us lifeness.
  *
  * have tasks, but none of them give us lifeness.
  *

- * @return GNUNET_OK to continue the main loop,
- *         GNUNET_NO to exit
+ * @return #GNUNET_OK to continue the main loop,
+ *         #GNUNET_NO to exit

  */
 static int
 check_lifeness ()
 {
  */
 static int
 check_lifeness ()
 {

-  struct Task *t;
+  struct GNUNET_SCHEDULER_Task *t;

 
   if (ready_count > 0)
     return GNUNET_OK;
 
   if (ready_count > 0)
     return GNUNET_OK;

-  for (t = pending; NULL != t; t = t->next)
+  for (t = pending_head; NULL != t; t = t->next)
+    if (t->lifeness == GNUNET_YES)
+      return GNUNET_OK;
+  for (t = shutdown_head; NULL != t; t = t->next)

     if (t->lifeness == GNUNET_YES)
       return GNUNET_OK;
     if (t->lifeness == GNUNET_YES)
       return GNUNET_OK;

-  for (t = pending_timeout; NULL != t; t = t->next)
+  for (t = pending_timeout_head; NULL != t; t = t->next)

     if (t->lifeness == GNUNET_YES)
       return GNUNET_OK;
     if (t->lifeness == GNUNET_YES)
       return GNUNET_OK;

-  if ((NULL != pending) || (NULL != pending_timeout))
+  if (NULL != shutdown_head)

   {
     GNUNET_SCHEDULER_shutdown ();
     return GNUNET_OK;
   {
     GNUNET_SCHEDULER_shutdown ();
     return GNUNET_OK;


@@ -754,69 +789,22 @@ check_lifeness ()
 }
 
 
 }
 
 

-/**
- * Initialize and run scheduler.  This function will return when all
- * tasks have completed.  On systems with signals, receiving a SIGTERM
- * (and other similar signals) will cause "GNUNET_SCHEDULER_shutdown"
- * to be run after the active task is complete.  As a result, SIGTERM
- * causes all active tasks to be scheduled with reason
- * "GNUNET_SCHEDULER_REASON_SHUTDOWN".  (However, tasks added
- * afterwards will execute normally!). Note that any particular signal
- * will only shut down one scheduler; applications should always only
- * create a single scheduler.
- *
- * @param task task to run immediately
- * @param task_cls closure of task
- */
-void
-GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
+
+void while_live(struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)

 {
 {

-  struct GNUNET_NETWORK_FDSet *rs;
-  struct GNUNET_NETWORK_FDSet *ws;
-  struct GNUNET_TIME_Relative timeout;

   int ret;
   int ret;

-  struct GNUNET_SIGNAL_Context *shc_int;
-  struct GNUNET_SIGNAL_Context *shc_term;
-
-#ifndef MINGW
-  struct GNUNET_SIGNAL_Context *shc_quit;
-  struct GNUNET_SIGNAL_Context *shc_hup;
-  struct GNUNET_SIGNAL_Context *shc_pipe;
-#endif
-  unsigned long long last_tr;

   unsigned int busy_wait_warning;
   unsigned int busy_wait_warning;

+  unsigned long long last_tr;

   const struct GNUNET_DISK_FileHandle *pr;
   char c;
   const struct GNUNET_DISK_FileHandle *pr;
   char c;

+  struct GNUNET_TIME_Relative timeout;

 
 

-  GNUNET_assert (active_task == NULL);
-  rs = GNUNET_NETWORK_fdset_create ();
-  ws = GNUNET_NETWORK_fdset_create ();
-  GNUNET_assert (shutdown_pipe_handle == NULL);
-  shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO);
-  GNUNET_assert (shutdown_pipe_handle != NULL);
+  busy_wait_warning = 0;

   pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
                                 GNUNET_DISK_PIPE_END_READ);
   pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
                                 GNUNET_DISK_PIPE_END_READ);

-  GNUNET_assert (pr != NULL);
-  shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown);
-  shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown);
-#ifndef MINGW
-  shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE, &sighandler_pipe);
-  shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown);
-  shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown);
-#endif
-  current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
-  current_lifeness = GNUNET_YES;
-  GNUNET_SCHEDULER_add_continuation (task, task_cls,
-                                     GNUNET_SCHEDULER_REASON_STARTUP);
-#if ENABLE_WINDOWS_WORKAROUNDS
-  active_task = (void *) (long) -1;     /* force passing of sanity check */
-  GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
-                                          &GNUNET_OS_install_parent_control_handler,
-                                          NULL);
-  active_task = NULL;
-#endif
+  GNUNET_assert (NULL != pr);

   last_tr = 0;
   last_tr = 0;

-  busy_wait_warning = 0;
+

   while (GNUNET_OK == check_lifeness ())
   {
     GNUNET_NETWORK_fdset_zero (rs);
   while (GNUNET_OK == check_lifeness ())
   {
     GNUNET_NETWORK_fdset_zero (rs);


@@ -830,15 +818,22 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
       timeout = GNUNET_TIME_UNIT_ZERO;
     }
     if (NULL == scheduler_select)
       timeout = GNUNET_TIME_UNIT_ZERO;
     }
     if (NULL == scheduler_select)

-      ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout);
+      ret = GNUNET_NETWORK_socket_select (rs,
+                                          ws,
+                                          NULL,
+                                          timeout);

     else
     else

-      ret = scheduler_select (scheduler_select_cls, rs, ws, NULL, timeout);
+      ret = scheduler_select (scheduler_select_cls,
+                              rs,
+                              ws,
+                              NULL,
+                              timeout);

     if (ret == GNUNET_SYSERR)
     {
       if (errno == EINTR)
         continue;
 
     if (ret == GNUNET_SYSERR)
     {
       if (errno == EINTR)
         continue;
 

-      GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "select");
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "select");

 #ifndef MINGW
 #if USE_LSOF
       char lsof[512];
 #ifndef MINGW
 #if USE_LSOF
       char lsof[512];


@@ -847,17 +842,50 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
       (void) close (1);
       (void) dup2 (2, 1);
       if (0 != system (lsof))
       (void) close (1);
       (void) dup2 (2, 1);
       if (0 != system (lsof))

-        GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "system");
+        LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING,
+                      "system");

 #endif
 #endif
 #endif
 #endif

-      abort ();
+#if DEBUG_FDS
+      struct GNUNET_SCHEDULER_Task *t;
+
+      for (t = pending_head; NULL != t; t = t->next)
+      {
+        if (-1 != t->read_fd)
+        {
+          int flags = fcntl (t->read_fd, F_GETFD);
+          if ((flags == -1) && (errno == EBADF))
+            {
+              LOG (GNUNET_ERROR_TYPE_ERROR,
+                   "Got invalid file descriptor %d!\n",
+                   t->read_fd);
+              dump_backtrace (t);
+            }
+        }
+        if (-1 != t->write_fd)
+          {
+            int flags = fcntl (t->write_fd, F_GETFD);
+            if ((flags == -1) && (errno == EBADF))
+              {
+                LOG (GNUNET_ERROR_TYPE_ERROR,
+                     "Got invalid file descriptor %d!\n",
+                     t->write_fd);
+                dump_backtrace (t);
+              }
+          }
+      }
+#endif
+      GNUNET_assert (0);

       break;
     }
       break;
     }

-    if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
+
+    if ( (0 == ret) &&
+         (0 == timeout.rel_value_us) &&
+         (busy_wait_warning > 16) )

     {
     {

-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                  _("Looks like we're busy waiting...\n"));
-      sleep (1);                /* mitigate */
+      LOG (GNUNET_ERROR_TYPE_WARNING,
+           "Looks like we're busy waiting...\n");
+      short_wait (100);                /* mitigate */

     }
     check_ready (rs, ws);
     run_ready (rs, ws);
     }
     check_ready (rs, ws);
     run_ready (rs, ws);


@@ -870,6 +898,7 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
     }
     if (last_tr == tasks_run)
     {
     }
     if (last_tr == tasks_run)
     {

+      short_wait (1);

       busy_wait_warning++;
     }
     else
       busy_wait_warning++;
     }
     else


@@ -878,8 +907,92 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
       busy_wait_warning = 0;
     }
   }
       busy_wait_warning = 0;
     }
   }

+}
+
+/**
+ * Initialize and run scheduler.  This function will return when all
+ * tasks have completed.  On systems with signals, receiving a SIGTERM
+ * (and other similar signals) will cause #GNUNET_SCHEDULER_shutdown()
+ * to be run after the active task is complete.  As a result, SIGTERM
+ * causes all active tasks to be scheduled with reason
+ * #GNUNET_SCHEDULER_REASON_SHUTDOWN.  (However, tasks added
+ * afterwards will execute normally!). Note that any particular signal
+ * will only shut down one scheduler; applications should always only
+ * create a single scheduler.
+ *
+ * @param task task to run immediately
+ * @param task_cls closure of @a task
+ */
+void
+GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_TaskCallback task,
+                      void *task_cls)
+{
+  struct GNUNET_NETWORK_FDSet *rs;
+  struct GNUNET_NETWORK_FDSet *ws;
+
+
+  struct GNUNET_SIGNAL_Context *shc_int;
+  struct GNUNET_SIGNAL_Context *shc_term;
+#if (SIGTERM != GNUNET_TERM_SIG)
+  struct GNUNET_SIGNAL_Context *shc_gterm;
+#endif
+
+#ifndef MINGW
+  struct GNUNET_SIGNAL_Context *shc_quit;
+  struct GNUNET_SIGNAL_Context *shc_hup;
+  struct GNUNET_SIGNAL_Context *shc_pipe;
+#endif
+
+
+
+  GNUNET_assert (NULL == active_task);
+  rs = GNUNET_NETWORK_fdset_create ();
+  ws = GNUNET_NETWORK_fdset_create ();
+  GNUNET_assert (NULL == shutdown_pipe_handle);
+  shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
+                                           GNUNET_NO,
+                                           GNUNET_NO,
+                                           GNUNET_NO);
+  GNUNET_assert (NULL != shutdown_pipe_handle);
+
+  my_pid = getpid ();
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Registering signal handlers\n");
+  shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
+             &sighandler_shutdown);
+  shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
+              &sighandler_shutdown);
+#if (SIGTERM != GNUNET_TERM_SIG)
+  shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
+               &sighandler_shutdown);
+#endif
+#ifndef MINGW
+  shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
+              &sighandler_pipe);
+  shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
+              &sighandler_shutdown);
+  shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
+             &sighandler_shutdown);
+#endif
+  current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
+  current_lifeness = GNUNET_YES;
+  GNUNET_SCHEDULER_add_with_reason_and_priority (task,
+                                                 task_cls,
+                                                 GNUNET_SCHEDULER_REASON_STARTUP,
+                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+  active_task = (void *) (long) -1;     /* force passing of sanity check */
+  GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
+                                          &GNUNET_OS_install_parent_control_handler,
+                                          NULL);
+  active_task = NULL;
+
+
+  while_live(rs, ws);

   GNUNET_SIGNAL_handler_uninstall (shc_int);
   GNUNET_SIGNAL_handler_uninstall (shc_term);
   GNUNET_SIGNAL_handler_uninstall (shc_int);
   GNUNET_SIGNAL_handler_uninstall (shc_term);

+#if (SIGTERM != GNUNET_TERM_SIG)
+  GNUNET_SIGNAL_handler_uninstall (shc_gterm);
+#endif

 #ifndef MINGW
   GNUNET_SIGNAL_handler_uninstall (shc_pipe);
   GNUNET_SIGNAL_handler_uninstall (shc_quit);
 #ifndef MINGW
   GNUNET_SIGNAL_handler_uninstall (shc_pipe);
   GNUNET_SIGNAL_handler_uninstall (shc_quit);


@@ -893,17 +1006,16 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
 
 
 /**
 
 
 /**

- * Obtain the reason code for why the current task was
- * started.  Will return the same value as
- * the GNUNET_SCHEDULER_TaskContext's reason field.
+ * Obtain the task context, giving the reason why the current task was
+ * started.

  *
  *

- * @return reason(s) why the current task is run
+ * @return current tasks' scheduler context

  */
  */

-enum GNUNET_SCHEDULER_Reason
-GNUNET_SCHEDULER_get_reason ()
+const struct GNUNET_SCHEDULER_TaskContext *
+GNUNET_SCHEDULER_get_task_context ()

 {
 {

-  GNUNET_assert (active_task != NULL);
-  return active_task->reason;
+  GNUNET_assert (NULL != active_task);
+  return &tc;

 }
 
 
 }
 
 


@@ -919,24 +1031,75 @@ GNUNET_SCHEDULER_get_reason ()
 unsigned int
 GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
 {
 unsigned int
 GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
 {

-  struct Task *pos;
+  struct GNUNET_SCHEDULER_Task *pos;

   unsigned int ret;
 
   unsigned int ret;
 

-  GNUNET_assert (active_task != NULL);
+  GNUNET_assert (NULL != active_task);

   if (p == GNUNET_SCHEDULER_PRIORITY_COUNT)
     return ready_count;
   if (p == GNUNET_SCHEDULER_PRIORITY_KEEP)
     p = current_priority;
   ret = 0;
   if (p == GNUNET_SCHEDULER_PRIORITY_COUNT)
     return ready_count;
   if (p == GNUNET_SCHEDULER_PRIORITY_KEEP)
     p = current_priority;
   ret = 0;

-  pos = ready[check_priority (p)];
-  while (pos != NULL)
-  {
-    pos = pos->next;
+  for (pos = ready_head[check_priority (p)]; NULL != pos; pos = pos->next)

     ret++;
     ret++;

-  }

   return ret;
 }
 
   return ret;
 }
 

+static struct GNUNET_SCHEDULER_Task*
+initFdInfo(const struct GNUNET_NETWORK_Handle *read_nh,
+           const struct GNUNET_NETWORK_Handle *write_nh,
+           const struct GNUNET_DISK_FileHandle *read_fh,
+           const struct GNUNET_DISK_FileHandle *write_fh)
+{
+
+
+  struct GNUNET_SCHEDULER_Task *t;
+
+  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+
+  // either only network handles or only file handles are allowed
+  GNUNET_assert (!((NULL != read_nh || NULL != write_nh) && (NULL != read_fh || NULL != write_fh)));
+
+  if (NULL != read_nh && NULL != write_nh)
+  {
+    t->fds_len = 2;
+    t->fds = GNUNET_new_array (2, struct GNUNET_SCHEDULER_FdInfo);
+    const struct GNUNET_SCHEDULER_FdInfo read_fdi = { .fd = read_nh, .et = GNUNET_SCHEDULER_ET_IN, .sock = GNUNET_NETWORK_get_fd (read_nh)};
+    const struct GNUNET_SCHEDULER_FdInfo write_fdi = { .fd = write_nh, .et = GNUNET_SCHEDULER_ET_OUT, .sock = GNUNET_NETWORK_get_fd (write_nh)};
+
+    const struct GNUNET_SCHEDULER_FdInfo array[2] = {read_fdi, write_fdi};
+    t->fds = array;
+  }
+  else if (NULL != read_fh && NULL != write_fh)
+  {
+    t->fds_len = 2;
+    t->fds = GNUNET_new_array (2, struct GNUNET_SCHEDULER_FdInfo);
+    const struct GNUNET_SCHEDULER_FdInfo read_fdi = { .fh = read_fh, .et = GNUNET_SCHEDULER_ET_IN};
+    const struct GNUNET_SCHEDULER_FdInfo write_fdi = { .fh = write_fh, .et = GNUNET_SCHEDULER_ET_OUT, .sock = GNUNET_NETWORK_get_fd (write_nh)};
+    const struct GNUNET_SCHEDULER_FdInfo array[2] = {read_fdi, write_fdi};
+    t->fds = array;
+  }
+  else if (NULL != read_nh)
+  {
+    struct GNUNET_SCHEDULER_FdInfo read_fdi = { .fd = read_nh, .et = GNUNET_SCHEDULER_ET_IN, .sock = GNUNET_NETWORK_get_fd (read_nh)};
+    t->fdx = read_fdi;
+  }
+  else if (NULL != write_nh)
+  {
+    struct GNUNET_SCHEDULER_FdInfo write_fdi = { .fd = write_nh, .et = GNUNET_SCHEDULER_ET_OUT, .sock = GNUNET_NETWORK_get_fd (write_nh)};
+    t->fdx = write_fdi;
+  }
+  else if (NULL != read_fh)
+  {
+    struct GNUNET_SCHEDULER_FdInfo read_fdi = { .fh = read_fh, .et = GNUNET_SCHEDULER_ET_IN};
+    t->fdx = read_fdi;
+  }
+  else if (NULL != write_fh)
+  {
+    struct GNUNET_SCHEDULER_FdInfo write_fdi = { .fh = write_fh, .et = GNUNET_SCHEDULER_ET_OUT, .sock = GNUNET_NETWORK_get_fd (write_nh)};
+    t->fdx = write_fdi;
+  }
+}

 
 /**
  * Cancel the task with the specified identifier.
 
 /**
  * Cancel the task with the specified identifier.


@@ -946,167 +1109,213 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
  * @return original closure of the task
  */
 void *
  * @return original closure of the task
  */
 void *

-GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
+GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Task *task)

 {
 {

-  struct Task *t;
-  struct Task *prev;

   enum GNUNET_SCHEDULER_Priority p;
   enum GNUNET_SCHEDULER_Priority p;

-  int to;

   void *ret;
 
   void *ret;
 

-  GNUNET_assert (active_task != NULL);
-  to = 0;
-  prev = NULL;
-  t = pending;
-  while (t != NULL)
+  GNUNET_assert ( (NULL != active_task) ||
+      (GNUNET_NO == task->lifeness) );
+  if (! task->in_ready_list)

   {
   {

-    if (t->id == task)
-      break;
-    prev = t;
-    t = t->next;
-  }
-  if (t == NULL)
-  {
-    prev = NULL;
-    to = 1;
-    t = pending_timeout;
-    while (t != NULL)
+    if ( (-1 == task->read_fd) &&
+         (-1 == task->write_fd) &&
+         (NULL == task->read_set) &&
+         (NULL == task->write_set) )

     {
     {

-      if (t->id == task)
-        break;
-      prev = t;
-      t = t->next;
-    }
-    if (pending_timeout_last == t)
-      pending_timeout_last = NULL;
-  }
-  p = 0;
-  while (t == NULL)
-  {
-    p++;
-    if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  _("Attempt to cancel dead task %llu!\n"),
-                  (unsigned long long) task);
-      GNUNET_assert (0);
-    }
-    prev = NULL;
-    t = ready[p];
-    while (t != NULL)
-    {
-      if (t->id == task)
-      {
-        ready_count--;
-        break;
-      }
-      prev = t;
-      t = t->next;
-    }
-  }
-  if (prev == NULL)
-  {
-    if (p == 0)
-    {
-      if (to == 0)
-      {
-        pending = t->next;
-      }
+      if (GNUNET_YES == task->on_shutdown)
+  GNUNET_CONTAINER_DLL_remove (shutdown_head,
+             shutdown_tail,
+             task);

       else
       else

-      {
-        pending_timeout = t->next;
-      }
+  GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
+             pending_timeout_tail,
+             task);
+      if (task == pending_timeout_last)
+        pending_timeout_last = NULL;

     }
     else
     {
     }
     else
     {

-      ready[p] = t->next;
+      scheduler_multi_function_call(task, scheduler_driver->del);

     }
   }
   else
   {
     }
   }
   else
   {

-    prev->next = t->next;
+    p = check_priority (task->priority);
+    GNUNET_CONTAINER_DLL_remove (ready_head[p],
+                                 ready_tail[p],
+                                 task);
+    ready_count--;

   }
   }

-  ret = t->callback_cls;
-#if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task,
-              t->callback_cls);
-#endif
-  destroy_task (t);
+  ret = task->callback_cls;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Canceling task %p\n",
+       task);
+  destroy_task (task);

   return ret;
 }
 
 
   return ret;
 }
 
 

+/**
+ * Initialize backtrace data for task @a t
+ *
+ * @param t task to initialize
+ */
+static void
+init_backtrace (struct GNUNET_SCHEDULER_Task *t)
+{
+#if EXECINFO
+  void *backtrace_array[MAX_TRACE_DEPTH];
+
+  t->num_backtrace_strings
+    = backtrace (backtrace_array, MAX_TRACE_DEPTH);
+  t->backtrace_strings =
+      backtrace_symbols (backtrace_array,
+       t->num_backtrace_strings);
+  dump_backtrace (t);
+#endif
+}
+
+

 /**
  * Continue the current execution with the given function.  This is
  * similar to the other "add" functions except that there is no delay
  * and the reason code can be specified.
  *
  * @param task main function of the task
 /**
  * Continue the current execution with the given function.  This is
  * similar to the other "add" functions except that there is no delay
  * and the reason code can be specified.
  *
  * @param task main function of the task

- * @param task_cls closure for 'main'
+ * @param task_cls closure for @a task

  * @param reason reason for task invocation
  * @param reason reason for task invocation

+ * @param priority priority to use for the task

  */
 void
  */
 void

-GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
-                                   enum GNUNET_SCHEDULER_Reason reason)
+GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback task,
+                                               void *task_cls,
+                                               enum GNUNET_SCHEDULER_Reason reason,
+                                               enum GNUNET_SCHEDULER_Priority priority)

 {
 {

-  struct Task *t;
-
-#if EXECINFO
-  void *backtrace_array[50];
-#endif
+  struct GNUNET_SCHEDULER_Task *t;

 
   GNUNET_assert (NULL != task);
 
   GNUNET_assert (NULL != task);

-  GNUNET_assert ((active_task != NULL) ||
-                 (reason == GNUNET_SCHEDULER_REASON_STARTUP));
-  t = GNUNET_malloc (sizeof (struct Task));
-#if EXECINFO
-  t->num_backtrace_strings = backtrace (backtrace_array, 50);
-  t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
-#endif
+  GNUNET_assert ((NULL != active_task) ||
+                 (GNUNET_SCHEDULER_REASON_STARTUP == reason));
+  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);

   t->read_fd = -1;
   t->write_fd = -1;
   t->callback = task;
   t->callback_cls = task_cls;
   t->read_fd = -1;
   t->write_fd = -1;
   t->callback = task;
   t->callback_cls = task_cls;

-  t->id = ++last_id;

 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->reason = reason;
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->reason = reason;

-  t->priority = current_priority;
+  t->priority = priority;

   t->lifeness = current_lifeness;
   t->lifeness = current_lifeness;

-#if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n",
-              t->id, t->callback_cls);
-#endif
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding continuation task %p\n",
+       t);
+  init_backtrace (t);

   queue_ready_task (t);
 }
 
 
   queue_ready_task (t);
 }
 
 

+/**
+ * Schedule a new task to be run at the specified time.  The task
+ * will be scheduled for execution at time @a at.
+ *
+ * @param at time when the operation should run
+ * @param priority priority to use for the task
+ * @param task main function of the task
+ * @param task_cls closure of @a task
+ * @return unique task identifier for the job
+ *         only valid until @a task is started!
+ */
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
+                                       enum GNUNET_SCHEDULER_Priority priority,
+                                       GNUNET_SCHEDULER_TaskCallback task,
+                                       void *task_cls)
+{
+  struct GNUNET_SCHEDULER_Task *t;
+  struct GNUNET_SCHEDULER_Task *pos;
+  struct GNUNET_SCHEDULER_Task *prev;
+
+  GNUNET_assert (NULL != active_task);
+  GNUNET_assert (NULL != task);
+  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+  t->callback = task;
+  t->callback_cls = task_cls;
+  t->read_fd = -1;
+  t->write_fd = -1;
+#if PROFILE_DELAYS
+  t->start_time = GNUNET_TIME_absolute_get ();
+#endif
+  t->timeout = at;
+  t->priority = priority;
+  t->lifeness = current_lifeness;
+  /* try tail first (optimization in case we are
+   * appending to a long list of tasks with timeouts) */
+  if ( (NULL == pending_timeout_head) ||
+       (at.abs_value_us < pending_timeout_head->timeout.abs_value_us) )
+  {
+    GNUNET_CONTAINER_DLL_insert (pending_timeout_head,
+                                 pending_timeout_tail,
+                                 t);
+  }
+  else
+  {
+    /* first move from heuristic start backwards to before start time */
+    prev = pending_timeout_last;
+    while ( (NULL != prev) &&
+            (prev->timeout.abs_value_us > t->timeout.abs_value_us) )
+      prev = prev->prev;
+    /* now, move from heuristic start (or head of list) forward to insertion point */
+    if (NULL == prev)
+      pos = pending_timeout_head;
+    else
+      pos = prev->next;
+    while ( (NULL != pos) &&
+            ( (pos->timeout.abs_value_us <= t->timeout.abs_value_us) ||
+              (0 != pos->reason) ) )
+    {
+      prev = pos;
+      pos = pos->next;
+    }
+    GNUNET_CONTAINER_DLL_insert_after (pending_timeout_head,
+                                       pending_timeout_tail,
+                                       prev,
+                                       t);
+  }
+  /* finally, update heuristic insertion point to last insertion... */
+  pending_timeout_last = t;
+
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding task: %p\n",
+       t);
+  init_backtrace (t);
+  return t;
+}
+

 
 /**
 
 /**

- * Schedule a new task to be run after the specified prerequisite task
- * has completed. It will be run with the priority of the calling
- * task.
+ * Schedule a new task to be run with a specified delay.  The task
+ * will be scheduled for execution once the delay has expired.

  *
  *

- * @param prerequisite_task run this task after the task with the given
- *        task identifier completes (and any of our other
- *        conditions, such as delay, read or write-readiness
- *        are satisfied).  Use  GNUNET_SCHEDULER_NO_TASK to not have any dependency
- *        on completion of other tasks (this will cause the task to run as
- *        soon as possible).
+ * @param delay when should this operation time out?
+ * @param priority priority to use for the task

  * @param task main function of the task
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
-                            GNUNET_SCHEDULER_Task task, void *task_cls)
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
+              enum GNUNET_SCHEDULER_Priority priority,
+              GNUNET_SCHEDULER_TaskCallback task,
+                                            void *task_cls)

 {
 {

-  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      prerequisite_task, GNUNET_TIME_UNIT_ZERO,
-                                      NULL, NULL, task, task_cls);
+  return GNUNET_SCHEDULER_add_at_with_priority (GNUNET_TIME_relative_to_absolute (delay),
+                                                priority,
+                                                task,
+                                                task_cls);

 }
 
 
 }
 
 


@@ -1115,135 +1324,131 @@ GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
  *
  * @param prio how important is the new task?
  * @param task main function of the task
  *
  * @param prio how important is the new task?
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
 GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,

-                                    GNUNET_SCHEDULER_Task task, void *task_cls)
+                                    GNUNET_SCHEDULER_TaskCallback task,
+                                    void *task_cls)

 {
 {

-  return GNUNET_SCHEDULER_add_select (prio, GNUNET_SCHEDULER_NO_TASK,
-                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                      task_cls);
+  return GNUNET_SCHEDULER_add_delayed_with_priority (GNUNET_TIME_UNIT_ZERO,
+                                                     prio,
+                                                     task,
+                                                     task_cls);

 }
 
 
 }
 
 

+/**
+ * Schedule a new task to be run at the specified time.  The task
+ * will be scheduled for execution once specified time has been
+ * reached. It will be run with the DEFAULT priority.
+ *
+ * @param at time at which this operation should run
+ * @param task main function of the task
+ * @param task_cls closure of @a task
+ * @return unique task identifier for the job
+ *         only valid until @a task is started!
+ */
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_at (struct GNUNET_TIME_Absolute at,
+                         GNUNET_SCHEDULER_TaskCallback task,
+                         void *task_cls)
+{
+  return GNUNET_SCHEDULER_add_at_with_priority (at,
+                                                GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                                task,
+                                                task_cls);
+}
+

 
 /**
  * Schedule a new task to be run with a specified delay.  The task
  * will be scheduled for execution once the delay has expired. It
 
 /**
  * Schedule a new task to be run with a specified delay.  The task
  * will be scheduled for execution once the delay has expired. It

- * will be run with the priority of the calling task.
+ * will be run with the DEFAULT priority.

  *
  *

- * @param delay when should this operation time out? Use
- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param delay when should this operation time out?

  * @param task main function of the task
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
 GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,

-                              GNUNET_SCHEDULER_Task task, void *task_cls)
+                              GNUNET_SCHEDULER_TaskCallback task,
+            void *task_cls)

 {
 {

-#if 1
-  /* new, optimized version */
-  struct Task *t;
-  struct Task *pos;
-  struct Task *prev;
-
-#if EXECINFO
-  void *backtrace_array[MAX_TRACE_DEPTH];
-#endif
-
-  GNUNET_assert (active_task != NULL);
-  GNUNET_assert (NULL != task);
-  t = GNUNET_malloc (sizeof (struct Task));
-  t->callback = task;
-  t->callback_cls = task_cls;
-#if EXECINFO
-  t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
-  t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
-#endif
-  t->read_fd = -1;
-  t->write_fd = -1;
-  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 = current_priority;
-  t->lifeness = current_lifeness;
-  /* try tail first (optimization in case we are
-   * appending to a long list of tasks with timeouts) */
-  prev = pending_timeout_last;
-  if (prev != NULL)
-  {
-    if (prev->timeout.abs_value > t->timeout.abs_value)
-      prev = NULL;
-    else
-      pos = prev->next;         /* heuristic success! */
-  }
-  if (prev == NULL)
-  {
-    /* heuristic failed, do traversal of timeout list */
-    pos = pending_timeout;
-  }
-  while ((pos != NULL) &&
-         ((pos->timeout.abs_value <= t->timeout.abs_value) ||
-          (pos->reason != 0)))
-  {
-    prev = pos;
-    pos = pos->next;
-  }
-  if (prev == NULL)
-    pending_timeout = t;
-  else
-    prev->next = t;
-  t->next = pos;
-  /* hyper-optimization... */
-  pending_timeout_last = t;
-
-#if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
-              t->callback_cls);
-#endif
-#if EXECINFO
-  int i;
+  return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
+                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                 task,
+                                                     task_cls);
+}

 
 

-  for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
-                t->backtrace_strings[i]);
-#endif
-  return t->id;

 
 

-#else
-  /* unoptimized version */
-  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      GNUNET_SCHEDULER_NO_TASK, delay, NULL,
-                                      NULL, task, task_cls);
-#endif
+/**
+ * Schedule a new task to be run as soon as possible.  Note that this
+ * does not guarantee that this will be the next task that is being
+ * run, as other tasks with higher priority (or that are already ready
+ * to run) might get to run first.  Just as with delays, clients must
+ * not rely on any particular order of execution between tasks
+ * scheduled concurrently.
+ *
+ * The task will be run with the DEFAULT priority.
+ *
+ * @param task main function of the task
+ * @param task_cls closure of @a task
+ * @return unique task identifier for the job
+ *         only valid until @a task is started!
+ */
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_TaskCallback task,
+        void *task_cls)
+{
+  return GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_ZERO,
+               task,
+               task_cls);

 }
 
 
 }
 
 

-

 /**
 /**

- * Schedule a new task to be run as soon as possible. The task
- * will be run with the priority of the calling task.
+ * Schedule a new task to be run on shutdown, that is when a CTRL-C
+ * signal is received, or when #GNUNET_SCHEDULER_shutdown() is being
+ * invoked.

  *
  * @param task main function of the task
  *
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
-GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls)
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_shutdown (GNUNET_SCHEDULER_TaskCallback task,
+             void *task_cls)

 {
 {

-  return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      GNUNET_SCHEDULER_NO_TASK,
-                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                      task_cls);
+  struct GNUNET_SCHEDULER_Task *t;
+
+  GNUNET_assert (NULL != active_task);
+  GNUNET_assert (NULL != task);
+  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
+  t->callback = task;
+  t->callback_cls = task_cls;
+  t->read_fd = -1;
+  t->write_fd = -1;
+#if PROFILE_DELAYS
+  t->start_time = GNUNET_TIME_absolute_get ();
+#endif
+  t->timeout = GNUNET_TIME_UNIT_FOREVER_ABS;
+  t->priority = GNUNET_SCHEDULER_PRIORITY_SHUTDOWN;
+  t->on_shutdown = GNUNET_YES;
+  t->lifeness = GNUNET_YES;
+  GNUNET_CONTAINER_DLL_insert (shutdown_head,
+             shutdown_tail,
+             t);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding task: %p\n",
+       t);
+  init_backtrace (t);
+  return t;

 }
 
 
 }
 
 


@@ -1252,34 +1457,41 @@ GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls)
  * (transitive) ignore-shutdown flag either explicitly set or
  * explicitly enabled.  This task (and all tasks created from it,
  * other than by another call to this function) will either count or
  * (transitive) ignore-shutdown flag either explicitly set or
  * explicitly enabled.  This task (and all tasks created from it,
  * other than by another call to this function) will either count or

- * not count for the 'lifeness' of the process.  This API is only
+ * not count for the "lifeness" of the process.  This API is only

  * useful in a few special cases.
  *
  * useful in a few special cases.
  *

- * @param lifeness GNUNET_YES if the task counts for lifeness, GNUNET_NO if not.
+ * @param lifeness #GNUNET_YES if the task counts for lifeness, #GNUNET_NO if not.

  * @param task main function of the task
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,

-                                        GNUNET_SCHEDULER_Task task,
+                                        GNUNET_SCHEDULER_TaskCallback task,

                                         void *task_cls)
 {
                                         void *task_cls)
 {

-  GNUNET_SCHEDULER_TaskIdentifier ret;
-
-  ret =
-      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                   GNUNET_SCHEDULER_NO_TASK,
-                                   GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                   task_cls);
-  GNUNET_assert (pending->id == ret);
-  pending->lifeness = lifeness;
+  struct GNUNET_SCHEDULER_Task *ret;
+
+  ret = GNUNET_SCHEDULER_add_now (task, task_cls);
+  ret->lifeness = lifeness;

   return ret;
 }
 
 
 
   return ret;
 }
 
 
 

+int scheduler_multi_function_call(struct GNUNET_SCHEDULER_Task *t, int (*driver_func)())
+{
+  if (t->fds_len > 1){
+    int success = GNUNET_YES;
+    for (int i = 0; i < t->fds_len;i++){
+      success = driver_func(scheduler_driver->cls, t , t->fds+i) && success;
+    }
+    return success;
+  }else{
+    return driver_func(scheduler_driver->cls, t , t->fds);
+  }
+}

 
 /**
  * Schedule a new task to be run with a specified delay or when any of
 
 /**
  * Schedule a new task to be run with a specified delay or when any of


@@ -1294,56 +1506,50 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
  * (prerequisite-run)
  * && (delay-ready
  *     || any-rs-ready
  * (prerequisite-run)
  * && (delay-ready
  *     || any-rs-ready

- *     || any-ws-ready
- *     || shutdown-active )
+ *     || any-ws-ready)

  * </code>
  *
  * </code>
  *

- * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever",
- *        which means that the task will only be run after we receive SIGTERM
+ * @param delay how long should we wait?
+ * @param priority priority to use

  * @param rfd file descriptor we want to read (can be -1)
  * @param wfd file descriptors we want to write (can be -1)
  * @param task main function of the task
  * @param rfd file descriptor we want to read (can be -1)
  * @param wfd file descriptors we want to write (can be -1)
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
 #ifndef MINGW
  */
 #ifndef MINGW

-GNUNET_SCHEDULER_TaskIdentifier
-add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
-                  GNUNET_SCHEDULER_Task task, void *task_cls)
+static struct GNUNET_SCHEDULER_Task *
+add_without_sets (struct GNUNET_TIME_Relative delay,
+                  enum GNUNET_SCHEDULER_Priority priority,
+                  const struct GNUNET_NETWORK_Handle *read_nh,
+                  const struct GNUNET_NETWORK_Handle *write_nh,
+                  const struct GNUNET_DISK_FileHandle *read_fh,
+                  const struct GNUNET_DISK_FileHandle *write_fh,
+                  //int rfd,
+                  //int wfd,
+                  GNUNET_SCHEDULER_TaskCallback task,
+                  void *task_cls)

 {
 {

-  struct Task *t;
+  struct GNUNET_SCHEDULER_Task *t;

 
 

-#if EXECINFO
-  void *backtrace_array[MAX_TRACE_DEPTH];
-#endif
-
-  GNUNET_assert (active_task != NULL);
+  GNUNET_assert (NULL != active_task);

   GNUNET_assert (NULL != task);
   GNUNET_assert (NULL != task);

-  t = GNUNET_malloc (sizeof (struct Task));
+  t= initFdInfo (read_nh, write_nh, read_fh, write_fh);
+

   t->callback = task;
   t->callback_cls = task_cls;
   t->callback = task;
   t->callback_cls = task_cls;

-#if EXECINFO
-  t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
-  t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
-#endif

 #if DEBUG_FDS
   if (-1 != rfd)
   {
     int flags = fcntl (rfd, F_GETFD);
 
 #if DEBUG_FDS
   if (-1 != rfd)
   {
     int flags = fcntl (rfd, F_GETFD);
 

-    if (flags == -1 && errno == EBADF)
+    if ((flags == -1) && (errno == EBADF))

     {
     {

-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n",
-                  rfd);
-#if EXECINFO
-      int i;
-
-      for (i = 0; i < t->num_backtrace_strings; i++)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n",
-                    t->backtrace_strings[i]);
-#endif
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Got invalid file descriptor %d!\n",
+           rfd);
+      init_backtrace (t);

       GNUNET_assert (0);
     }
   }
       GNUNET_assert (0);
     }
   }


@@ -1353,88 +1559,91 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
 
     if (flags == -1 && errno == EBADF)
     {
 
     if (flags == -1 && errno == EBADF)
     {

-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n",
-                  wfd);
-#if EXECINFO
-      int i;
-
-      for (i = 0; i < t->num_backtrace_strings; i++)
-        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n",
-                    t->backtrace_strings[i]);
-#endif
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Got invalid file descriptor %d!\n",
+           wfd);
+      init_backtrace (t);

       GNUNET_assert (0);
     }
   }
 #endif
       GNUNET_assert (0);
     }
   }
 #endif

-  t->read_fd = rfd;
-  GNUNET_assert (wfd >= -1);
-  t->write_fd = wfd;
-  t->id = ++last_id;
+

 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
 #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->timeout = GNUNET_TIME_relative_to_absolute (delay);

-  t->priority = check_priority (current_priority);
+  t->priority = check_priority ((priority == GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority : priority);

   t->lifeness = current_lifeness;
   t->lifeness = current_lifeness;

-  t->next = pending;
-  pending = t;
-  max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
-#if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
-              t->callback_cls);
-#endif
-#if EXECINFO
-  int i;

 
 

-  for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
-                t->backtrace_strings[i]);
-#endif
-  return t->id;
+
+
+  scheduler_multi_function_call(t, scheduler_driver->add);
+
+  max_priority_added = GNUNET_MAX (max_priority_added,
+                                   t->priority);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding task %p\n",
+       t);
+  init_backtrace (t);
+  return t;

 }
 #endif
 
 
 }
 #endif
 
 

-

 /**
  * Schedule a new task to be run with a specified delay or when the
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
 /**
  * Schedule a new task to be run with a specified delay or when the
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the

- * socket operation is ready.  It will be run with the priority of
- * the calling task.
+ * socket operation is ready.  It will be run with the DEFAULT priority.

  *
  *

- * @param delay when should this operation time out? Use
- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param delay when should this operation time out?

  * @param rfd read file-descriptor
  * @param task main function of the task
  * @param rfd read file-descriptor
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
                                struct GNUNET_NETWORK_Handle *rfd,
 GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
                                struct GNUNET_NETWORK_Handle *rfd,

-                               GNUNET_SCHEDULER_Task task, void *task_cls)
+                               GNUNET_SCHEDULER_TaskCallback task,
+                               void *task_cls)

 {
 {

-#if MINGW
-  struct GNUNET_NETWORK_FDSet *rs;
-  GNUNET_SCHEDULER_TaskIdentifier ret;
+  return GNUNET_SCHEDULER_add_read_net_with_priority (delay,
+                  GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                  rfd, task, task_cls);
+}

 
 

-  GNUNET_assert (rfd != NULL);
-  rs = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_set (rs, rfd);
-  ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                   GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
-                                   task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (rs);
-  return ret;
-#else
-  return add_without_sets (delay, GNUNET_NETWORK_get_fd (rfd), -1, task,
-                           task_cls);
-#endif
+
+/**
+ * Schedule a new task to be run with a specified priority and to be
+ * run after the specified delay or when the specified file descriptor
+ * is ready for reading.  The delay can be used as a timeout on the
+ * socket being ready.  The task will be scheduled for execution once
+ * either the delay has expired or the socket operation is ready.  It
+ * will be run with the DEFAULT priority.
+ *
+ * @param delay when should this operation time out?
+ * @param priority priority to use for the task
+ * @param rfd read file-descriptor
+ * @param task main function of the task
+ * @param task_cls closure of @a task
+ * @return unique task identifier for the job
+ *         only valid until @a task is started!
+ */
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
+               enum GNUNET_SCHEDULER_Priority priority,
+               struct GNUNET_NETWORK_Handle *rfd,
+               GNUNET_SCHEDULER_TaskCallback task,
+                                             void *task_cls)
+{
+  return GNUNET_SCHEDULER_add_net_with_priority (delay, priority,
+                                                 rfd,
+                                                 GNUNET_YES,
+                                                 GNUNET_NO,
+                                                 task, task_cls);

 }
 
 
 }
 
 


@@ -1446,36 +1655,75 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  * socket operation is ready.  It will be run with the priority of
  * the calling task.
  *
  * socket operation is ready.  It will be run with the priority of
  * the calling task.
  *

- * @param delay when should this operation time out? Use
- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param delay when should this operation time out?

  * @param wfd write file-descriptor
  * @param task main function of the task
  * @param wfd write file-descriptor
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
                                 struct GNUNET_NETWORK_Handle *wfd,
 GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
                                 struct GNUNET_NETWORK_Handle *wfd,

-                                GNUNET_SCHEDULER_Task task, void *task_cls)
+                                GNUNET_SCHEDULER_TaskCallback task,
+                                void *task_cls)

 {
 {

-#if MINGW
-  struct GNUNET_NETWORK_FDSet *ws;
-  GNUNET_SCHEDULER_TaskIdentifier ret;
+  return GNUNET_SCHEDULER_add_net_with_priority (delay,
+                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+                                                 wfd,
+                                                 GNUNET_NO, GNUNET_YES,
+                                                 task, task_cls);
+}

 
 

-  GNUNET_assert (wfd != NULL);
-  ws = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_set (ws, wfd);
-  ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                   GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
-                                   task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (ws);
+/**
+ * Schedule a new task to be run with a specified delay or when the
+ * specified file descriptor is ready.  The delay can be
+ * used as a timeout on the socket being ready.  The task will be
+ * scheduled for execution once either the delay has expired or the
+ * socket operation is ready.
+ *
+ * @param delay when should this operation time out?
+ * @param priority priority of the task
+ * @param fd file-descriptor
+ * @param on_read whether to poll the file-descriptor for readability
+ * @param on_write whether to poll the file-descriptor for writability
+ * @param task main function of the task
+ * @param task_cls closure of task
+ * @return unique task identifier for the job
+ *         only valid until "task" is started!
+ */
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_net_with_priority  (struct GNUNET_TIME_Relative delay,
+                                         enum GNUNET_SCHEDULER_Priority priority,
+                                         struct GNUNET_NETWORK_Handle *fd,
+                                         int on_read,
+                                         int on_write,
+                                         GNUNET_SCHEDULER_TaskCallback task,
+                                         void *task_cls)
+{
+#if MINGW
+  struct GNUNET_NETWORK_FDSet *s;
+  struct GNUNET_SCHEDULER_Task * ret;
+
+  GNUNET_assert (NULL != fd);
+  s = GNUNET_NETWORK_fdset_create ();
+  GNUNET_NETWORK_fdset_set (s, fd);
+  ret = GNUNET_SCHEDULER_add_select (
+      priority, delay,
+      on_read  ? s : NULL,
+      on_write ? s : NULL,
+      task, task_cls);
+  GNUNET_NETWORK_fdset_destroy (s);

   return ret;
 #else
   return ret;
 #else

-  GNUNET_assert (GNUNET_NETWORK_get_fd (wfd) >= 0);
-  return add_without_sets (delay, -1, GNUNET_NETWORK_get_fd (wfd), task,
-                           task_cls);
+  GNUNET_assert (on_read || on_write);
+  GNUNET_assert (GNUNET_NETWORK_get_fd (fd) >= 0);
+  return add_without_sets (delay, priority,
+                           on_read  ? fd : NULL,
+                           on_write ? fd : NULL,
+                           NULL,
+                           NULL,
+                           task, task_cls);

 #endif
 }
 
 #endif
 }
 


@@ -1485,42 +1733,24 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
  * specified file descriptor is ready for reading.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the

- * socket operation is ready. It will be run with the priority of
- * the calling task.
+ * socket operation is ready. It will be run with the DEFAULT priority.

  *
  *

- * @param delay when should this operation time out? Use
- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param delay when should this operation time out?

  * @param rfd read file-descriptor
  * @param task main function of the task
  * @param rfd read file-descriptor
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
                                 const struct GNUNET_DISK_FileHandle *rfd,
 GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
                                 const struct GNUNET_DISK_FileHandle *rfd,

-                                GNUNET_SCHEDULER_Task task, void *task_cls)
+                                GNUNET_SCHEDULER_TaskCallback task, void *task_cls)

 {
 {

-#if MINGW
-  struct GNUNET_NETWORK_FDSet *rs;
-  GNUNET_SCHEDULER_TaskIdentifier ret;
-
-  GNUNET_assert (rfd != NULL);
-  rs = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_handle_set (rs, rfd);
-  ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                   GNUNET_SCHEDULER_NO_TASK, delay, rs, NULL,
-                                   task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (rs);
-  return ret;
-#else
-  int fd;
-
-  GNUNET_DISK_internal_file_handle_ (rfd, &fd, sizeof (int));
-  return add_without_sets (delay, fd, -1, task, task_cls);
-
-#endif
+  return GNUNET_SCHEDULER_add_file_with_priority (
+      delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+      rfd, GNUNET_YES, GNUNET_NO,
+      task, task_cls);

 }
 
 
 }
 
 


@@ -1529,47 +1759,78 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  * specified file descriptor is ready for writing.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the
  * specified file descriptor is ready for writing.  The delay can be
  * used as a timeout on the socket being ready.  The task will be
  * scheduled for execution once either the delay has expired or the

- * socket operation is ready. It will be run with the priority of
- * the calling task.
+ * socket operation is ready. It will be run with the DEFAULT priority.

  *
  *

- * @param delay when should this operation time out? Use
- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @param delay when should this operation time out?

  * @param wfd write file-descriptor
  * @param task main function of the task
  * @param wfd write file-descriptor
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
                                  const struct GNUNET_DISK_FileHandle *wfd,
 GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
                                  const struct GNUNET_DISK_FileHandle *wfd,

-                                 GNUNET_SCHEDULER_Task task, void *task_cls)
+                                 GNUNET_SCHEDULER_TaskCallback task, void *task_cls)

 {
 {

-#if MINGW
-  struct GNUNET_NETWORK_FDSet *ws;
-  GNUNET_SCHEDULER_TaskIdentifier ret;
+  return GNUNET_SCHEDULER_add_file_with_priority (
+      delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+      wfd, GNUNET_NO, GNUNET_YES,
+      task, task_cls);
+}

 
 

-  GNUNET_assert (wfd != NULL);
-  ws = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_handle_set (ws, wfd);
-  ret =
-      GNUNET_SCHEDULER_add_select (check_priority (current_priority),
-                                   GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
-                                   task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (ws);
+
+/**
+ * Schedule a new task to be run with a specified delay or when the
+ * specified file descriptor is ready.  The delay can be
+ * used as a timeout on the socket being ready.  The task will be
+ * scheduled for execution once either the delay has expired or the
+ * socket operation is ready.
+ *
+ * @param delay when should this operation time out?
+ * @param priority priority of the task
+ * @param fd file-descriptor
+ * @param on_read whether to poll the file-descriptor for readability
+ * @param on_write whether to poll the file-descriptor for writability
+ * @param task main function of the task
+ * @param task_cls closure of @a task
+ * @return unique task identifier for the job
+ *         only valid until @a task is started!
+ */
+struct GNUNET_SCHEDULER_Task *
+GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
+                                         enum GNUNET_SCHEDULER_Priority priority,
+                                         const struct GNUNET_DISK_FileHandle *fd,
+                                         int on_read, int on_write,
+                                         GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
+{
+#if MINGW
+  struct GNUNET_NETWORK_FDSet *s;
+  struct GNUNET_SCHEDULER_Task * ret;
+
+  GNUNET_assert (NULL != fd);
+  s = GNUNET_NETWORK_fdset_create ();
+  GNUNET_NETWORK_fdset_handle_set (s, fd);
+  ret = GNUNET_SCHEDULER_add_select (
+      priority, delay,
+      on_read  ? s : NULL,
+      on_write ? s : NULL,
+      task, task_cls);
+  GNUNET_NETWORK_fdset_destroy (s);

   return ret;
 #else
   return ret;
 #else

-  int fd;
-
-  GNUNET_DISK_internal_file_handle_ (wfd, &fd, sizeof (int));
-  GNUNET_assert (fd >= 0);
-  return add_without_sets (delay, -1, fd, task, task_cls);
-
+  GNUNET_assert (on_read || on_write);
+  GNUNET_assert(fd->fd >= 0);
+  return add_without_sets (delay, priority,
+                           NULL,
+                           NULL,
+                           on_read ? fd : NULL,
+                           on_write ? fd : NULL,
+                           task, task_cls);

 #endif
 }
 
 
 #endif
 }
 
 

-

 /**
  * Schedule a new task to be run with a specified delay or when any of
  * the specified file descriptor sets is ready.  The delay can be used
 /**
  * Schedule a new task to be run with a specified delay or when any of
  * the specified file descriptor sets is ready.  The delay can be used


@@ -1583,87 +1844,392 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  * (prerequisite-run)
  * && (delay-ready
  *     || any-rs-ready
  * (prerequisite-run)
  * && (delay-ready
  *     || any-rs-ready

- *     || any-ws-ready
- *     || (shutdown-active && run-on-shutdown) )
+ *     || any-ws-ready) )

  * </code>
  *
  * @param prio how important is this task?
  * </code>
  *
  * @param prio how important is this task?

- * @param prerequisite_task run this task after the task with the given
- *        task identifier completes (and any of our other
- *        conditions, such as delay, read or write-readiness
- *        are satisfied).  Use GNUNET_SCHEDULER_NO_TASK to not have any dependency
- *        on completion of other tasks.
- * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever",
- *        which means that the task will only be run after we receive SIGTERM
+ * @param delay how long should we wait?

  * @param rs set of file descriptors we want to read (can be NULL)
  * @param ws set of file descriptors we want to write (can be NULL)
  * @param task main function of the task
  * @param rs set of file descriptors we want to read (can be NULL)
  * @param ws set of file descriptors we want to write (can be NULL)
  * @param task main function of the task

- * @param task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  * @return unique task identifier for the job

- *         only valid until "task" is started!
+ *         only valid until @a task is started!

  */
  */

-GNUNET_SCHEDULER_TaskIdentifier
+struct GNUNET_SCHEDULER_Task *

 GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
 GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,

-                             GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,

                              struct GNUNET_TIME_Relative delay,
                              const struct GNUNET_NETWORK_FDSet *rs,
                              const struct GNUNET_NETWORK_FDSet *ws,
                              struct GNUNET_TIME_Relative delay,
                              const struct GNUNET_NETWORK_FDSet *rs,
                              const struct GNUNET_NETWORK_FDSet *ws,

-                             GNUNET_SCHEDULER_Task task, void *task_cls)
+                             GNUNET_SCHEDULER_TaskCallback task,
+                             void *task_cls)

 {
 {

-  struct Task *t;
-
-#if EXECINFO
-  void *backtrace_array[MAX_TRACE_DEPTH];
-#endif
-
-  GNUNET_assert (active_task != NULL);
+  struct GNUNET_SCHEDULER_Task *t;
+
+  if ( (NULL == rs) &&
+       (NULL == ws) )
+    return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
+                                                       prio,
+                                                       task,
+                                                       task_cls);
+  GNUNET_assert (NULL != active_task);

   GNUNET_assert (NULL != task);
   GNUNET_assert (NULL != task);

-  t = GNUNET_malloc (sizeof (struct Task));
+  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);

   t->callback = task;
   t->callback_cls = task_cls;
   t->callback = task;
   t->callback_cls = task_cls;

-#if EXECINFO
-  t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
-  t->backtrace_strings =
-      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
-#endif

   t->read_fd = -1;
   t->write_fd = -1;
   t->read_fd = -1;
   t->write_fd = -1;

-  if (rs != NULL)
+  if (NULL != rs)

   {
     t->read_set = GNUNET_NETWORK_fdset_create ();
     GNUNET_NETWORK_fdset_copy (t->read_set, rs);
   }
   {
     t->read_set = GNUNET_NETWORK_fdset_create ();
     GNUNET_NETWORK_fdset_copy (t->read_set, rs);
   }

-  if (ws != NULL)
+  if (NULL != ws)

   {
     t->write_set = GNUNET_NETWORK_fdset_create ();
     GNUNET_NETWORK_fdset_copy (t->write_set, ws);
   }
   {
     t->write_set = GNUNET_NETWORK_fdset_create ();
     GNUNET_NETWORK_fdset_copy (t->write_set, ws);
   }

-  t->id = ++last_id;

 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
 #if PROFILE_DELAYS
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif

-  t->prereq_id = prerequisite_task;

   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
   t->priority =
       check_priority ((prio ==
                        GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
                       prio);
   t->lifeness = current_lifeness;
   t->timeout = GNUNET_TIME_relative_to_absolute (delay);
   t->priority =
       check_priority ((prio ==
                        GNUNET_SCHEDULER_PRIORITY_KEEP) ? current_priority :
                       prio);
   t->lifeness = current_lifeness;

-  t->next = pending;
-  pending = t;
-  max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
-#if DEBUG_TASKS
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
-              t->callback_cls);
+
+  scheduler_multi_function_call(t, scheduler_driver->add);
+
+  max_priority_added = GNUNET_MAX (max_priority_added,
+           t->priority);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding task %p\n",
+       t);
+  init_backtrace (t);
+  return t;
+}
+
+
+/**
+ * Function used by event-loop implementations to signal the scheduler
+ * that a particular @a task is ready due to an event of type @a et.
+ *
+ * This function will then queue the task to notify the application
+ * that the task is ready (with the respective priority).
+ *
+ * @param task the task that is ready, NULL for wake up calls
+ * @param et information about why the task is ready
+ */
+void
+GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
+           enum GNUNET_SCHEDULER_EventType et)
+{
+  enum GNUNET_SCHEDULER_Reason reason;
+  struct GNUNET_TIME_Absolute now;
+
+  now = GNUNET_TIME_absolute_get ();
+  reason = task->reason;
+  if (now.abs_value_us >= task->timeout.abs_value_us)
+    reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+  if ( (0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
+       (0 != (GNUNET_SCHEDULER_ET_IN & et)) )
+    reason |= GNUNET_SCHEDULER_REASON_READ_READY;
+  if ( (0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
+       (0 != (GNUNET_SCHEDULER_ET_OUT & et)) )
+    reason |= GNUNET_SCHEDULER_REASON_WRITE_READY;
+  reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
+  task->reason = reason;
+  task->fds = &task->fdx;
+  task->fdx.et = et;
+  task->fds_len = 1;
+  queue_ready_task (task);
+}
+
+
+/**
+ * Function called by the driver to tell the scheduler to run some of
+ * the tasks that are ready.  This function may return even though
+ * there are tasks left to run just to give other tasks a chance as
+ * well.  If we return #GNUNET_YES, the driver should call this
+ * function again as soon as possible, while if we return #GNUNET_NO
+ * it must block until the operating system has more work as the
+ * scheduler has no more work to do right now.
+ *
+ * @param sh scheduler handle that was given to the `loop`
+ * @return #GNUNET_OK if there are more tasks that are ready,
+ *          and thus we would like to run more (yield to avoid
+ *          blocking other activities for too long)
+ *         #GNUNET_NO if we are done running tasks (yield to block)
+ *         #GNUNET_SYSERR on error
+ */
+int
+GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
+{
+  enum GNUNET_SCHEDULER_Priority p;
+  struct GNUNET_SCHEDULER_Task *pos;
+  struct GNUNET_TIME_Absolute now;
+
+  /* check for tasks that reached the timeout! */
+  now = GNUNET_TIME_absolute_get ();
+  while (NULL != (pos = pending_timeout_head))
+  {
+    if (now.abs_value_us >= pos->timeout.abs_value_us)
+      pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+    if (0 == pos->reason)
+      break;
+    GNUNET_CONTAINER_DLL_remove (pending_timeout_head,
+                                 pending_timeout_tail,
+                                 pos);
+    if (pending_timeout_last == pos)
+      pending_timeout_last = NULL;
+    queue_ready_task (pos);
+  }
+
+  if (0 == ready_count)
+    return GNUNET_NO;
+
+  /* find out which task priority level we are going to
+     process this time */
+  max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
+  GNUNET_assert (NULL == ready_head[GNUNET_SCHEDULER_PRIORITY_KEEP]);
+  /* 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 = ready_head[p];
+    if (NULL != pos)
+      break;
+  }
+  GNUNET_assert (NULL != pos);        /* ready_count wrong? */
+
+  /* process all tasks at this priority level, then yield */
+  while (NULL != (pos = ready_head[p]))
+  {
+    GNUNET_CONTAINER_DLL_remove (ready_head[p],
+         ready_tail[p],
+         pos);
+    ready_count--;
+    current_priority = pos->priority;
+    current_lifeness = pos->lifeness;
+    active_task = pos;
+#if PROFILE_DELAYS
+    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
+  DELAY_THRESHOLD.rel_value_us)
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+     "Task %p took %s to be scheduled\n",
+     pos,
+     GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time),
+               GNUNET_YES));
+    }

 #endif
 #endif

-#if EXECINFO
-  int i;
+    tc.reason = pos->reason;
+    GNUNET_NETWORK_fdset_zero (sh->rs);
+    GNUNET_NETWORK_fdset_zero (sh->ws);
+    tc.fds_len = pos->fds_len;
+    tc.fds = pos->fds;
+    tc.read_ready = (NULL == pos->read_set) ? sh->rs : pos->read_set;
+    if ( (-1 != pos->read_fd) &&
+   (0 != (pos->reason & GNUNET_SCHEDULER_REASON_READ_READY)) )
+      GNUNET_NETWORK_fdset_set_native (sh->rs,
+               pos->read_fd);
+    tc.write_ready = (NULL == pos->write_set) ? sh->ws : pos->write_set;
+    if ((-1 != pos->write_fd) &&
+  (0 != (pos->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)))
+      GNUNET_NETWORK_fdset_set_native (sh->ws,
+               pos->write_fd);
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+   "Running task: %p\n",
+   pos);
+    pos->callback (pos->callback_cls);
+    active_task = NULL;
+    dump_backtrace (pos);
+    destroy_task (pos);
+    tasks_run++;
+  }
+  if (0 == ready_count)
+    return GNUNET_NO;
+  return GNUNET_OK;
+}

 
 

-  for (i = 0; i < t->num_backtrace_strings; i++)
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
-                t->backtrace_strings[i]);
+
+/**
+ * Initialize and run scheduler.  This function will return when all
+ * tasks have completed.  On systems with signals, receiving a SIGTERM
+ * (and other similar signals) will cause #GNUNET_SCHEDULER_shutdown
+ * to be run after the active task is complete.  As a result, SIGTERM
+ * causes all shutdown tasks to be scheduled with reason
+ * #GNUNET_SCHEDULER_REASON_SHUTDOWN.  (However, tasks added
+ * afterwards will execute normally!).  Note that any particular
+ * signal will only shut down one scheduler; applications should
+ * always only create a single scheduler.
+ *
+ * @param driver drive to use for the event loop
+ * @param task task to run first (and immediately)
+ * @param task_cls closure of @a task
+ * @return #GNUNET_OK on success, #GNUNET_SYSERR on failure
+ */
+int
+GNUNET_SCHEDULER_run_with_driver (const struct GNUNET_SCHEDULER_Driver *driver,
+          GNUNET_SCHEDULER_TaskCallback task,
+          void *task_cls)
+{
+  int ret;
+  struct GNUNET_SCHEDULER_Handle sh;
+  struct GNUNET_SIGNAL_Context *shc_int;
+  struct GNUNET_SIGNAL_Context *shc_term;
+#if (SIGTERM != GNUNET_TERM_SIG)
+  struct GNUNET_SIGNAL_Context *shc_gterm;
+#endif
+#ifndef MINGW
+  struct GNUNET_SIGNAL_Context *shc_quit;
+  struct GNUNET_SIGNAL_Context *shc_hup;
+  struct GNUNET_SIGNAL_Context *shc_pipe;
+#endif
+  struct GNUNET_SCHEDULER_Task tsk;
+  const struct GNUNET_DISK_FileHandle *pr;
+  scheduler_driver = driver;
+
+  /* general set-up */
+  GNUNET_assert (NULL == active_task);
+  GNUNET_assert (NULL == shutdown_pipe_handle);
+  shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO,
+                                           GNUNET_NO,
+                                           GNUNET_NO,
+                                           GNUNET_NO);
+  GNUNET_assert (NULL != shutdown_pipe_handle);
+  pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
+                                GNUNET_DISK_PIPE_END_READ);
+  GNUNET_assert (NULL != pr);
+  my_pid = getpid ();
+
+  /* install signal handlers */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Registering signal handlers\n");
+  shc_int = GNUNET_SIGNAL_handler_install (SIGINT,
+             &sighandler_shutdown);
+  shc_term = GNUNET_SIGNAL_handler_install (SIGTERM,
+              &sighandler_shutdown);
+#if (SIGTERM != GNUNET_TERM_SIG)
+  shc_gterm = GNUNET_SIGNAL_handler_install (GNUNET_TERM_SIG,
+               &sighandler_shutdown);

 #endif
 #endif

-  return t->id;
+#ifndef MINGW
+  shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE,
+              &sighandler_pipe);
+  shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT,
+              &sighandler_shutdown);
+  shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP,
+             &sighandler_shutdown);
+#endif
+
+  /* Setup initial tasks */
+  current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
+  current_lifeness = GNUNET_YES;
+  memset (&tsk,
+    0,
+    sizeof (tsk));
+  active_task = &tsk;
+  tsk.sh = &sh;
+  GNUNET_SCHEDULER_add_with_reason_and_priority (task,
+                                                 task_cls,
+                                                 GNUNET_SCHEDULER_REASON_STARTUP,
+                                                 GNUNET_SCHEDULER_PRIORITY_DEFAULT);
+  GNUNET_SCHEDULER_add_now_with_lifeness (GNUNET_NO,
+                                          &GNUNET_OS_install_parent_control_handler,
+                                          NULL);
+  active_task = NULL;
+  driver->set_wakeup (driver->cls,
+          GNUNET_TIME_absolute_get ());
+
+  /* begin main event loop */
+  sh.rs = GNUNET_NETWORK_fdset_create ();
+  sh.ws = GNUNET_NETWORK_fdset_create ();
+  GNUNET_NETWORK_fdset_handle_set (sh.rs, pr);
+  sh.driver = driver;
+  ret = driver->loop (driver->cls,
+          &sh);
+  GNUNET_NETWORK_fdset_destroy (sh.rs);
+  GNUNET_NETWORK_fdset_destroy (sh.ws);
+
+  /* uninstall signal handlers */
+  GNUNET_SIGNAL_handler_uninstall (shc_int);
+  GNUNET_SIGNAL_handler_uninstall (shc_term);
+#if (SIGTERM != GNUNET_TERM_SIG)
+  GNUNET_SIGNAL_handler_uninstall (shc_gterm);
+#endif
+#ifndef MINGW
+  GNUNET_SIGNAL_handler_uninstall (shc_pipe);
+  GNUNET_SIGNAL_handler_uninstall (shc_quit);
+  GNUNET_SIGNAL_handler_uninstall (shc_hup);
+#endif
+  GNUNET_DISK_pipe_close (shutdown_pipe_handle);
+  shutdown_pipe_handle = NULL;
+  return ret;
+}
+
+int
+select_add(void *cls,
+ struct GNUNET_SCHEDULER_Task *task,
+ struct GNUNET_SCHEDULER_FdInfo *fdi){
+
+  GNUNET_CONTAINER_DLL_insert (pending_head,
+                               pending_tail,
+                               task);
+
+}
+
+int
+select_del(void *cls,
+ struct GNUNET_SCHEDULER_Task *task,
+ struct GNUNET_SCHEDULER_FdInfo *fdi){
+
+  GNUNET_CONTAINER_DLL_remove (pending_head,
+                               pending_tail,
+                               task);
+
+}
+
+
+int
+select_loop(void *cls,
+        struct GNUNET_SCHEDULER_Handle *sh){
+
+  while_live(sh->rs, sh->ws);
+
+}
+
+static void
+select_set_wakeup(void *cls,
+                   struct GNUNET_TIME_Absolute dt){
+
+
+

 }
 
 }
 

+
+/**
+ * Obtain the driver for using select() as the event loop.
+ *
+ * @return NULL on error
+ */
+const struct GNUNET_SCHEDULER_Driver *
+GNUNET_SCHEDULER_driver_select ()
+{
+
+  struct GNUNET_SCHEDULER_Driver *select_driver;
+
+  select_driver = GNUNET_new (struct GNUNET_SCHEDULER_Driver);
+
+  select_driver->loop = &select_loop;
+  select_driver->add = &select_add;
+  select_driver->del = &select_del;
+  select_driver->set_wakeup = &select_set_wakeup;
+
+
+  return select_driver;
+}
+
+

 /* end of scheduler.c */
 /* end of scheduler.c */