- add user feedback

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

diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 9b49df79a3d007a761c0acfe44cfe3802b094b90..87a107dba78f526ab29dfd8d289d50d4fab436be 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)
+      (C) 2009-2013 Christian Grothoff (and other contributing authors)

 
       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


@@ -24,11 +24,7 @@
  * @author Christian Grothoff
  */
 #include "platform.h"
  * @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"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)
 #include "disk.h"
 
 #define LOG(kind,...) GNUNET_log_from (kind, "util-scheduler", __VA_ARGS__)


@@ -90,7 +86,7 @@ struct Task
   GNUNET_SCHEDULER_Task callback;
 
   /**
   GNUNET_SCHEDULER_Task callback;
 
   /**

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

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


@@ -239,7 +235,7 @@ 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;
 


@@ -252,7 +248,7 @@ 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


@@ -297,32 +293,32 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
 
   now = GNUNET_TIME_absolute_get ();
   pos = pending_timeout;
 
   now = GNUNET_TIME_absolute_get ();
   pos = pending_timeout;

-  if (pos != NULL)
+  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;
     if (pos->reason != 0)
       *timeout = GNUNET_TIME_UNIT_ZERO;
   }
   pos = pending;
       *timeout = to;
     if (pos->reason != 0)
       *timeout = GNUNET_TIME_UNIT_ZERO;
   }
   pos = pending;

-  while (pos != NULL)
+  while (NULL != pos)

   {
   {

-    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;
     pos = pos->next;
   }
       *timeout = GNUNET_TIME_UNIT_ZERO;
     pos = pos->next;
   }


@@ -363,7 +359,7 @@ 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
 is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
  */
 static int
 is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,


@@ -373,7 +369,7 @@ is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
   enum GNUNET_SCHEDULER_Reason reason;
 
   reason = task->reason;
   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) &&


@@ -385,9 +381,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 */

-  reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;  
+  reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;

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


@@ -430,10 +426,10 @@ check_ready (const struct GNUNET_NETWORK_FDSet *rs,
   now = GNUNET_TIME_absolute_get ();
   prev = NULL;
   pos = pending_timeout;
   now = GNUNET_TIME_absolute_get ();
   prev = NULL;
   pos = pending_timeout;

-  while (pos != NULL)
+  while (NULL != pos)

   {
     next = pos->next;
   {
     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;


@@ -444,15 +440,15 @@ check_ready (const struct GNUNET_NETWORK_FDSet *rs,
     pos = next;
   }
   pos = pending;
     pos = next;
   }
   pos = pending;

-  while (pos != NULL)
+  while (NULL != pos)

   {
   {

-    LOG (GNUNET_ERROR_TYPE_DEBUG, 
+    LOG (GNUNET_ERROR_TYPE_DEBUG,

         "Checking readiness of task: %llu / %p\n",
          pos->id, pos->callback_cls);
     next = pos->next;
     if (GNUNET_YES == is_ready (pos, now, rs, ws))
     {
         "Checking readiness of task: %llu / %p\n",
          pos->id, pos->callback_cls);
     next = pos->next;
     if (GNUNET_YES == is_ready (pos, now, rs, ws))
     {

-      if (prev == NULL)
+      if (NULL == prev)

         pending = next;
       else
         prev->next = next;
         pending = next;
       else
         prev->next = next;


@@ -480,7 +476,7 @@ GNUNET_SCHEDULER_shutdown ()
   int i;
 
   pos = pending_timeout;
   int i;
 
   pos = pending_timeout;

-  while (pos != NULL)
+  while (NULL != pos)

   {
     pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
     /* we don't move the task into the ready queue yet; check_ready
   {
     pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
     /* we don't move the task into the ready queue yet; check_ready


@@ -489,7 +485,7 @@ GNUNET_SCHEDULER_shutdown ()
     pos = pos->next;
   }
   pos = pending;
     pos = pos->next;
   }
   pos = pending;

-  while (pos != NULL)
+  while (NULL != pos)

   {
     pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
     /* we don't move the task into the ready queue yet; check_ready
   {
     pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
     /* we don't move the task into the ready queue yet; check_ready


@@ -500,7 +496,7 @@ GNUNET_SCHEDULER_shutdown ()
   for (i = 0; i < GNUNET_SCHEDULER_PRIORITY_COUNT; i++)
   {
     pos = ready[i];
   for (i = 0; i < GNUNET_SCHEDULER_PRIORITY_COUNT; i++)
   {
     pos = ready[i];

-    while (pos != NULL)
+    while (NULL != pos)

     {
       pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
       /* we don't move the task into the ready queue yet; check_ready
     {
       pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN;
       /* we don't move the task into the ready queue yet; check_ready


@@ -542,7 +538,8 @@ 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;
   struct Task *pos;
 {
   enum GNUNET_SCHEDULER_Priority p;
   struct Task *pos;


@@ -551,7 +548,7 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
   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;
     GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
     /* yes, p>0 is correct, 0 is "KEEP" which should
       return;
     GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
     /* yes, p>0 is correct, 0 is "KEEP" which should


@@ -559,23 +556,24 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
     for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
     {
       pos = ready[p];
     for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
     {
       pos = ready[p];

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

         break;
     }
         break;
     }

-    GNUNET_assert (pos != NULL);        /* ready_count wrong? */
+    GNUNET_assert (NULL != pos);        /* ready_count wrong? */

     ready[p] = pos->next;
     ready_count--;
     current_priority = pos->priority;
     current_lifeness = pos->lifeness;
     active_task = pos;
 #if PROFILE_DELAYS
     ready[p] = pos->next;
     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 >
-        DELAY_THRESHOLD.rel_value)
+    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value_us >
+        DELAY_THRESHOLD.rel_value_us)

     {
     {

-      LOG (GNUNET_ERROR_TYPE_DEBUG, 
+      LOG (GNUNET_ERROR_TYPE_DEBUG,

           "Task %llu took %s to be scheduled\n",
            (unsigned long long) pos->id,
           "Task %llu took %s to be scheduled\n",
            (unsigned long long) pos->id,

-           GNUNET_STRINGS_relative_time_to_string (GNUNET_TIME_absolute_get_duration (pos->start_time), GNUNET_YES));
+           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;


@@ -591,7 +589,7 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
         (pos->write_fd != -1) &&
         (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
       GNUNET_abort ();          // added to ready in previous select loop!
         (pos->write_fd != -1) &&
         (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
       GNUNET_abort ();          // added to ready in previous select loop!

-    LOG (GNUNET_ERROR_TYPE_DEBUG, 
+    LOG (GNUNET_ERROR_TYPE_DEBUG,

         "Running task: %llu / %p\n", pos->id,
          pos->callback_cls);
     pos->callback (pos->callback_cls, &tc);
         "Running task: %llu / %p\n", pos->id,
          pos->callback_cls);
     pos->callback (pos->callback_cls, &tc);


@@ -599,14 +597,17 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
     int i;
 
     for (i = 0; i < pos->num_backtrace_strings; i++)
     int i;
 
     for (i = 0; i < pos->num_backtrace_strings; i++)

-      LOG (GNUNET_ERROR_TYPE_ERROR, "Task %llu trace %d: %s\n", pos->id, i,
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           "Task %llu trace %d: %s\n",
+           pos->id,
+           i,

            pos->backtrace_strings[i]);
 #endif
     active_task = NULL;
     destroy_task (pos);
     tasks_run++;
   }
            pos->backtrace_strings[i]);
 #endif
     active_task = NULL;
     destroy_task (pos);
     tasks_run++;
   }

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

 }
 
 /**
 }
 
 /**


@@ -630,6 +631,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.
  */


@@ -642,8 +663,6 @@ sighandler_shutdown ()
   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 */
   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 */

-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Got signal %d from parent, writing to shutdown pipe\n");

   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));


@@ -655,8 +674,8 @@ sighandler_shutdown ()
  * Check if the system is still life. Trigger shutdown if we
  * have tasks, but none of them give us lifeness.
  *
  * Check if the system is still life. Trigger shutdown if we
  * 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 ()


@@ -683,16 +702,16 @@ check_lifeness ()
 /**
  * Initialize and run scheduler.  This function will return when all
  * tasks have completed.  On systems with signals, receiving a SIGTERM
 /**
  * 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"
+ * (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
  * 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
+ * #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
  * 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
+ * @param task_cls closure of @a task

  */
 void
 GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
  */
 void
 GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)


@@ -703,6 +722,9 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   int ret;
   struct GNUNET_SIGNAL_Context *shc_int;
   struct GNUNET_SIGNAL_Context *shc_term;
   int ret;
   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;
 
 #ifndef MINGW
   struct GNUNET_SIGNAL_Context *shc_quit;


@@ -714,12 +736,12 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   const struct GNUNET_DISK_FileHandle *pr;
   char c;
 
   const struct GNUNET_DISK_FileHandle *pr;
   char c;
 

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

   rs = GNUNET_NETWORK_fdset_create ();
   ws = GNUNET_NETWORK_fdset_create ();
   rs = GNUNET_NETWORK_fdset_create ();
   ws = GNUNET_NETWORK_fdset_create ();

-  GNUNET_assert (shutdown_pipe_handle == NULL);
+  GNUNET_assert (NULL == shutdown_pipe_handle);

   shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);
   shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO, GNUNET_NO);

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

   pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
                                 GNUNET_DISK_PIPE_END_READ);
   GNUNET_assert (pr != NULL);
   pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
                                 GNUNET_DISK_PIPE_END_READ);
   GNUNET_assert (pr != NULL);


@@ -727,6 +749,9 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   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);
   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);
 #ifndef MINGW
   shc_pipe = GNUNET_SIGNAL_handler_install (SIGPIPE, &sighandler_pipe);
   shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown);


@@ -773,16 +798,20 @@ 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))

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

 #endif
 #endif
       GNUNET_abort ();
       break;
     }
 #endif
 #endif
       GNUNET_abort ();
       break;
     }

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

     {
     {

-      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);


@@ -795,6 +824,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


@@ -805,6 +835,9 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   }
   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);


@@ -820,7 +853,7 @@ 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
 /**
  * Obtain the reason code for why the current task was
  * started.  Will return the same value as

- * the GNUNET_SCHEDULER_TaskContext's reason field.
+ * the `struct GNUNET_SCHEDULER_TaskContext`'s reason field.

  *
  * @return reason(s) why the current task is run
  */
  *
  * @return reason(s) why the current task is run
  */


@@ -854,7 +887,7 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
     p = current_priority;
   ret = 0;
   pos = ready[check_priority (p)];
     p = current_priority;
   ret = 0;
   pos = ready[check_priority (p)];

-  while (pos != NULL)
+  while (NULL != pos)

   {
     pos = pos->next;
     ret++;
   {
     pos = pos->next;
     ret++;


@@ -879,18 +912,18 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
   int to;
   void *ret;
 
   int to;
   void *ret;
 

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

   to = 0;
   prev = NULL;
   t = pending;
   to = 0;
   prev = NULL;
   t = pending;

-  while (t != NULL)
+  while (NULL != t)

   {
     if (t->id == task)
       break;
     prev = t;
     t = t->next;
   }
   {
     if (t->id == task)
       break;
     prev = t;
     t = t->next;
   }

-  if (t == NULL)
+  if (NULL == t)

   {
     prev = NULL;
     to = 1;
   {
     prev = NULL;
     to = 1;


@@ -906,18 +939,19 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
       pending_timeout_last = NULL;
   }
   p = 0;
       pending_timeout_last = NULL;
   }
   p = 0;

-  while (t == NULL)
+  while (NULL == t)

   {
     p++;
     if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT)
     {
   {
     p++;
     if (p >= GNUNET_SCHEDULER_PRIORITY_COUNT)
     {

-      LOG (GNUNET_ERROR_TYPE_ERROR, _("Attempt to cancel dead task %llu!\n"),
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _("Attempt to cancel dead task %llu!\n"),

            (unsigned long long) task);
       GNUNET_assert (0);
     }
     prev = NULL;
     t = ready[p];
            (unsigned long long) task);
       GNUNET_assert (0);
     }
     prev = NULL;
     t = ready[p];

-    while (t != NULL)
+    while (NULL != t)

     {
       if (t->id == task)
       {
     {
       if (t->id == task)
       {


@@ -928,11 +962,11 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
       t = t->next;
     }
   }
       t = t->next;
     }
   }

-  if (prev == NULL)
+  if (NULL == prev)

   {
   {

-    if (p == 0)
+    if (0 == p)

     {
     {

-      if (to == 0)
+      if (0 == to)

       {
         pending = t->next;
       }
       {
         pending = t->next;
       }


@@ -951,7 +985,9 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
     prev->next = t->next;
   }
   ret = t->callback_cls;
     prev->next = t->next;
   }
   ret = t->callback_cls;

-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task,
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Canceling task: %llu / %p\n",
+       task,

        t->callback_cls);
   destroy_task (t);
   return ret;
        t->callback_cls);
   destroy_task (t);
   return ret;


@@ -964,7 +1000,7 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
  * and the reason code can be specified.
  *
  * @param task main function of the task
  * 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 priority priority to use for the task
  */
  * @param reason reason for task invocation
  * @param priority priority to use for the task
  */


@@ -980,9 +1016,9 @@ GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, voi
 #endif
 
   GNUNET_assert (NULL != task);
 #endif
 
   GNUNET_assert (NULL != task);

-  GNUNET_assert ((active_task != NULL) ||
-                 (reason == GNUNET_SCHEDULER_REASON_STARTUP));
-  t = GNUNET_malloc (sizeof (struct Task));
+  GNUNET_assert ((NULL != active_task) ||
+                 (GNUNET_SCHEDULER_REASON_STARTUP == reason));
+  t = GNUNET_new (struct Task);

 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, 50);
   t->backtrace_strings =
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, 50);
   t->backtrace_strings =


@@ -999,7 +1035,9 @@ GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, voi
   t->reason = reason;
   t->priority = priority;
   t->lifeness = current_lifeness;
   t->reason = reason;
   t->priority = priority;
   t->lifeness = current_lifeness;

-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n", t->id,
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding continuation task: %llu / %p\n",
+       t->id,

        t->callback_cls);
   queue_ready_task (t);
 }
        t->callback_cls);
   queue_ready_task (t);
 }


@@ -1011,7 +1049,7 @@ GNUNET_SCHEDULER_add_continuation_with_priority (GNUNET_SCHEDULER_Task task, voi
  * and the reason code can be specified.
  *
  * @param task main function of the task
  * 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
  */
 void
  * @param reason reason for task invocation
  */
 void


@@ -1029,15 +1067,15 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
  *
  * @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
 GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
                                     GNUNET_SCHEDULER_Task task, void *task_cls)
 {
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
                                     GNUNET_SCHEDULER_Task task, void *task_cls)
 {

-  return GNUNET_SCHEDULER_add_select (prio, 
+  return GNUNET_SCHEDULER_add_select (prio,

                                       GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
                                       task_cls);
 }
                                       GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
                                       task_cls);
 }


@@ -1049,12 +1087,12 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
  * will be scheduled for execution once the delay has expired.
  *
  * @param delay when should this operation time out? Use
  * will be scheduled for execution once the delay has expired.
  *
  * @param delay when should this operation time out? Use

- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ *        #GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"

  * @param priority priority to use for the task
  * @param task main function of the task
  * @param priority priority to use for 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_delayed_with_priority (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,


@@ -1069,9 +1107,9 @@ GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
   void *backtrace_array[MAX_TRACE_DEPTH];
 #endif
 
   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 = GNUNET_new (struct Task);

   t->callback = task;
   t->callback_cls = task_cls;
 #if EXECINFO
   t->callback = task;
   t->callback_cls = task_cls;
 #if EXECINFO


@@ -1093,7 +1131,7 @@ GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
   prev = pending_timeout_last;
   if (prev != NULL)
   {
   prev = pending_timeout_last;
   if (prev != NULL)
   {

-    if (prev->timeout.abs_value > t->timeout.abs_value)
+    if (prev->timeout.abs_value_us > t->timeout.abs_value_us)

       prev = NULL;
     else
       pos = prev->next;         /* heuristic success! */
       prev = NULL;
     else
       pos = prev->next;         /* heuristic success! */


@@ -1104,8 +1142,8 @@ GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
     pos = pending_timeout;
   }
   while ((pos != NULL) &&
     pos = pending_timeout;
   }
   while ((pos != NULL) &&

-         ((pos->timeout.abs_value <= t->timeout.abs_value) ||
-          (pos->reason != 0)))
+         ((pos->timeout.abs_value_us <= t->timeout.abs_value_us) ||
+          (0 != pos->reason)))

   {
     prev = pos;
     pos = pos->next;
   {
     prev = pos;
     pos = pos->next;


@@ -1154,11 +1192,17 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
 
 
 /**
 
 
 /**

- * Schedule a new task to be run as soon as possible. The task
- * will be run with the DEFAULT priority.
+ * 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 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
  *         only valid until "task" is started!
  */
  * @return unique task identifier for the job
  *         only valid until "task" is started!
  */


@@ -1174,14 +1218,14 @@ 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
 GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,


@@ -1217,19 +1261,19 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
  *     || shutdown-active )
  * </code>
  *
  *     || shutdown-active )
  * </code>
  *

- * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever",
+ * @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 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
  *        which means that the task will only be run after we receive SIGTERM
  * @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 task_cls closure of task
+ * @param task_cls closure of @a task

  * @return unique task identifier for the job
  *         only valid until "task" is started!
  */
 #ifndef MINGW
 static GNUNET_SCHEDULER_TaskIdentifier
  * @return unique task identifier for the job
  *         only valid until "task" is started!
  */
 #ifndef MINGW
 static GNUNET_SCHEDULER_TaskIdentifier

-add_without_sets (struct GNUNET_TIME_Relative delay, 
+add_without_sets (struct GNUNET_TIME_Relative delay,

                  enum GNUNET_SCHEDULER_Priority priority,
                  int rfd, int wfd,
                   GNUNET_SCHEDULER_Task task, void *task_cls)
                  enum GNUNET_SCHEDULER_Priority priority,
                  int rfd, int wfd,
                   GNUNET_SCHEDULER_Task task, void *task_cls)


@@ -1240,9 +1284,9 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
   void *backtrace_array[MAX_TRACE_DEPTH];
 #endif
 
   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 = GNUNET_new (struct Task);

   t->callback = task;
   t->callback_cls = task_cls;
 #if EXECINFO
   t->callback = task;
   t->callback_cls = task_cls;
 #if EXECINFO


@@ -1257,12 +1301,16 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
 
     if ((flags == -1) && (errno == EBADF))
     {
 
     if ((flags == -1) && (errno == EBADF))
     {

-      LOG (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", rfd);
+      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++)
 #if EXECINFO
       int i;
 
       for (i = 0; i < t->num_backtrace_strings; i++)

-        LOG (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", t->backtrace_strings[i]);
+        LOG (GNUNET_ERROR_TYPE_DEBUG,
+             "Trace: %s\n",
+             t->backtrace_strings[i]);

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


@@ -1273,12 +1321,16 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
 
     if (flags == -1 && errno == EBADF)
     {
 
     if (flags == -1 && errno == EBADF)
     {

-      LOG (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", wfd);
+      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++)
 #if EXECINFO
       int i;
 
       for (i = 0; i < t->num_backtrace_strings; i++)

-        LOG (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", t->backtrace_strings[i]);
+        LOG (GNUNET_ERROR_TYPE_DEBUG,
+             "Trace: %s\n",
+             t->backtrace_strings[i]);

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


@@ -1297,13 +1349,18 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
   t->next = pending;
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
   t->next = pending;
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);

-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding task: %llu / %p\n",
+       t->id,

        t->callback_cls);
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
        t->callback_cls);
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)

-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Task %llu trace %d: %s\n",
+         t->id,
+         i,

          t->backtrace_strings[i]);
 #endif
   return t->id;
          t->backtrace_strings[i]);
 #endif
   return t->id;


@@ -1320,12 +1377,12 @@ add_without_sets (struct GNUNET_TIME_Relative delay,
  * socket operation is ready.  It will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use
  * 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"
+ *        #GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"

  * @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
 GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,


@@ -1347,13 +1404,13 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  * will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use
  * will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use

- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ *        #GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"

  * @param priority priority to use for the task
  * @param rfd read file-descriptor
  * @param task main function of the task
  * @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 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_read_net_with_priority (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,


@@ -1361,29 +1418,13 @@ GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
                                             struct GNUNET_NETWORK_Handle *rfd,
                                             GNUNET_SCHEDULER_Task task, void *task_cls)
 {
                                             struct GNUNET_NETWORK_Handle *rfd,
                                             GNUNET_SCHEDULER_Task 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_set (rs, rfd);
-  ret =
-    GNUNET_SCHEDULER_add_select (priority,
-                                delay, rs, NULL,
-                                task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (rs);
-  return ret;
-#else
-  return add_without_sets (delay, 
-                          priority,
-                          GNUNET_NETWORK_get_fd (rfd), -1, task,
-                           task_cls);
-#endif
+  return GNUNET_SCHEDULER_add_net_with_priority (
+      delay, priority,
+      rfd, GNUNET_YES, GNUNET_NO,
+      task, task_cls);

 }
 
 
 }
 
 

-

 /**
  * Schedule a new task to be run with a specified delay or when the
  * specified file descriptor is ready for writing.  The delay can be
 /**
  * Schedule a new task to be run with a specified delay or when the
  * specified file descriptor is ready for writing.  The delay can be


@@ -1393,37 +1434,70 @@ GNUNET_SCHEDULER_add_read_net_with_priority (struct GNUNET_TIME_Relative delay,
  * the calling task.
  *
  * @param delay when should this operation time out? Use
  * the calling task.
  *
  * @param delay when should this operation time out? Use

- *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ *        #GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"

  * @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
 GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
                                 struct GNUNET_NETWORK_Handle *wfd,
                                 GNUNET_SCHEDULER_Task task, void *task_cls)
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
                                 struct GNUNET_NETWORK_Handle *wfd,
                                 GNUNET_SCHEDULER_Task task, void *task_cls)

+{
+  return GNUNET_SCHEDULER_add_net_with_priority (
+      delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+      wfd, GNUNET_NO, GNUNET_YES,
+      task, task_cls);
+}
+
+/**
+ * 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? Use
+ *        GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @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!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+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_Task task, void *task_cls)

 {
 #if MINGW
 {
 #if MINGW

-  struct GNUNET_NETWORK_FDSet *ws;
+  struct GNUNET_NETWORK_FDSet *s;

   GNUNET_SCHEDULER_TaskIdentifier ret;
 
   GNUNET_SCHEDULER_TaskIdentifier ret;
 

-  GNUNET_assert (wfd != NULL);
-  ws = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_set (ws, wfd);
-  ret =
-    GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                delay, NULL, ws,
-                                   task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (ws);
+  GNUNET_assert (fd != NULL);
+  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, 
-                          GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                          -1, GNUNET_NETWORK_get_fd (wfd), task,
-                           task_cls);
+  GNUNET_assert (GNUNET_NETWORK_get_fd (fd) >= 0);
+  return add_without_sets (
+      delay, priority,
+      on_read  ? GNUNET_NETWORK_get_fd (fd) : -1,
+      on_write ? GNUNET_NETWORK_get_fd (fd) : -1,
+      task, task_cls);

 #endif
 }
 
 #endif
 }
 


@@ -1436,40 +1510,22 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  * socket operation is ready. It will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use
  * 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"
+ *        #GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"

  * @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
 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_TaskIdentifier
 GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
                                 const struct GNUNET_DISK_FileHandle *rfd,
                                 GNUNET_SCHEDULER_Task 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 (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                   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, 
-                          GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                          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);

 }
 
 
 }
 
 


@@ -1481,45 +1537,78 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  * socket operation is ready. It will be run with the DEFAULT priority.
  *
  * @param delay when should this operation time out? Use
  * 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"
+ *        #GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"

  * @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
 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_TaskIdentifier
 GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
                                  const struct GNUNET_DISK_FileHandle *wfd,
                                  GNUNET_SCHEDULER_Task task, void *task_cls)

+{
+  return GNUNET_SCHEDULER_add_file_with_priority (
+      delay, GNUNET_SCHEDULER_PRIORITY_DEFAULT,
+      wfd, GNUNET_NO, GNUNET_YES,
+      task, task_cls);
+}
+
+
+/**
+ * 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? Use
+ *        #GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown"
+ * @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!
+ */
+GNUNET_SCHEDULER_TaskIdentifier
+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_Task task, void *task_cls)

 {
 #if MINGW
 {
 #if MINGW

-  struct GNUNET_NETWORK_FDSet *ws;
+  struct GNUNET_NETWORK_FDSet *s;

   GNUNET_SCHEDULER_TaskIdentifier ret;
 
   GNUNET_SCHEDULER_TaskIdentifier ret;
 

-  GNUNET_assert (wfd != NULL);
-  ws = GNUNET_NETWORK_fdset_create ();
-  GNUNET_NETWORK_fdset_handle_set (ws, wfd);
-  ret =
-      GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                                   delay, NULL, ws,
-                                   task, task_cls);
-  GNUNET_NETWORK_fdset_destroy (ws);
+  GNUNET_assert (fd != NULL);
+  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, 
-                          GNUNET_SCHEDULER_PRIORITY_DEFAULT,
-                          -1, fd, task, task_cls);
-
+  int real_fd;
+
+  GNUNET_DISK_internal_file_handle_ (fd, &real_fd, sizeof (int));
+  GNUNET_assert (real_fd >= 0);
+  return add_without_sets (
+      delay, priority,
+      on_read  ? real_fd : -1,
+      on_write ? real_fd : -1,
+      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


@@ -1538,14 +1627,14 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  * </code>
  *
  * @param prio how important is this task?
  * </code>
  *
  * @param prio how important is this task?

- * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever",
+ * @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 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
  *        which means that the task will only be run after we receive SIGTERM
  * @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
 GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,


@@ -1555,14 +1644,13 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                              GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
                              GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;

-

 #if EXECINFO
   void *backtrace_array[MAX_TRACE_DEPTH];
 #endif
 
 #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 = GNUNET_new (struct Task);

   t->callback = task;
   t->callback_cls = task_cls;
 #if EXECINFO
   t->callback = task;
   t->callback_cls = task_cls;
 #if EXECINFO


@@ -1572,12 +1660,12 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
 #endif
   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);


@@ -1595,13 +1683,17 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
   t->next = pending;
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
   t->next = pending;
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);

-  LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding task: %llu / %p\n", t->id,
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Adding task: %llu / %p\n",
+       t->id,

        t->callback_cls);
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)
        t->callback_cls);
 #if EXECINFO
   int i;
 
   for (i = 0; i < t->num_backtrace_strings; i++)

-    LOG (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Task %llu trace %d: %s\n",
+         t->id, i,

          t->backtrace_strings[i]);
 #endif
   return t->id;
          t->backtrace_strings[i]);
 #endif
   return t->id;