1 files changed, 407 insertions, 418 deletions

diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 7c5077fab..0c4374471 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -269,7 +269,7 @@ static void *scheduler_select_cls;
  */
 void
 GNUNET_SCHEDULER_set_select (GNUNET_SCHEDULER_select new_select,
-                             void *new_select_cls)
+                             void *new_select_cls)
 {
   scheduler_select = new_select;
   scheduler_select_cls = new_select_cls;
@@ -288,7 +288,7 @@ check_priority (enum GNUNET_SCHEDULER_Priority p)
   if ((p >= 0) && (p < GNUNET_SCHEDULER_PRIORITY_COUNT))
     return p;
   GNUNET_assert (0);
-  return 0;                     /* make compiler happy */
+  return 0;                     /* make compiler happy */
 }
 
 
@@ -310,37 +310,37 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
 
   if (id < lowest_pending_id)
     return GNUNET_NO;
-  min = -1;                     /* maximum value */
+  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;
-    }
+  {
+    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;
+        return GNUNET_YES;
       if (pos->id < min)
-        min = pos->id;
+        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;
 }
@@ -355,7 +355,7 @@ is_pending (GNUNET_SCHEDULER_TaskIdentifier id)
  */
 static void
 update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
-             struct GNUNET_TIME_Relative *timeout)
+             struct GNUNET_TIME_Relative *timeout)
 {
   struct Task *pos;
   struct GNUNET_TIME_Absolute now;
@@ -364,40 +364,40 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
   now = GNUNET_TIME_absolute_get ();
   pos = pending_timeout;
   if (pos != NULL)
-    {
-      to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-      if (timeout->rel_value > to.rel_value)
-        *timeout = to;
-      if (pos->reason != 0)
-        *timeout = GNUNET_TIME_UNIT_ZERO;
-    }
+  {
+    to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
+    if (timeout->rel_value > to.rel_value)
+      *timeout = to;
+    if (pos->reason != 0)
+      *timeout = GNUNET_TIME_UNIT_ZERO;
+  }
   pos = pending;
   while (pos != NULL)
+  {
+    if ((pos->prereq_id != GNUNET_SCHEDULER_NO_TASK) &&
+        (GNUNET_YES == is_pending (pos->prereq_id)))
     {
-      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)
-        {
-          to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
-          if (timeout->rel_value > to.rel_value)
-            *timeout = to;
-        }
-      if (pos->read_fd != -1)
-        GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
-      if (pos->write_fd != -1)
-        GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
-      if (pos->read_set != NULL)
-        GNUNET_NETWORK_fdset_add (rs, pos->read_set);
-      if (pos->write_set != NULL)
-        GNUNET_NETWORK_fdset_add (ws, pos->write_set);
-      if (pos->reason != 0)
-        *timeout = GNUNET_TIME_UNIT_ZERO;
       pos = pos->next;
+      continue;
+    }
+    if (pos->timeout.abs_value != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value)
+    {
+      to = GNUNET_TIME_absolute_get_difference (now, pos->timeout);
+      if (timeout->rel_value > to.rel_value)
+        *timeout = to;
     }
+    if (pos->read_fd != -1)
+      GNUNET_NETWORK_fdset_set_native (rs, pos->read_fd);
+    if (pos->write_fd != -1)
+      GNUNET_NETWORK_fdset_set_native (ws, pos->write_fd);
+    if (pos->read_set != NULL)
+      GNUNET_NETWORK_fdset_add (rs, pos->read_set);
+    if (pos->write_set != NULL)
+      GNUNET_NETWORK_fdset_add (ws, pos->write_set);
+    if (pos->reason != 0)
+      *timeout = GNUNET_TIME_UNIT_ZERO;
+    pos = pos->next;
+  }
 }
 
 
@@ -412,17 +412,17 @@ update_sets (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws,
  */
 static int
 set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
-              struct GNUNET_NETWORK_FDSet *want)
+              struct GNUNET_NETWORK_FDSet *want)
 {
   if ((NULL == want) || (NULL == ready))
     return GNUNET_NO;
   if (GNUNET_NETWORK_fdset_overlap (ready, want))
-    {
-      /* copy all over (yes, there maybe unrelated bits,
-       * but this should not hurt well-written clients) */
-      GNUNET_NETWORK_fdset_copy (want, ready);
-      return GNUNET_YES;
-    }
+  {
+    /* copy all over (yes, there maybe unrelated bits,
+     * but this should not hurt well-written clients) */
+    GNUNET_NETWORK_fdset_copy (want, ready);
+    return GNUNET_YES;
+  }
   return GNUNET_NO;
 }
 
@@ -439,8 +439,8 @@ set_overlaps (const struct GNUNET_NETWORK_FDSet *ready,
  */
 static int
 is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
-          const struct GNUNET_NETWORK_FDSet *rs,
-          const struct GNUNET_NETWORK_FDSet *ws)
+          const struct GNUNET_NETWORK_FDSet *rs,
+          const struct GNUNET_NETWORK_FDSet *ws)
 {
   enum GNUNET_SCHEDULER_Reason reason;
 
@@ -449,25 +449,25 @@ is_ready (struct Task *task, struct GNUNET_TIME_Absolute now,
     reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ((0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
       (((task->read_fd != -1) &&
-        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, task->read_fd)))
-       || (set_overlaps (rs, task->read_set))))
+        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, task->read_fd))) ||
+       (set_overlaps (rs, task->read_set))))
     reason |= GNUNET_SCHEDULER_REASON_READ_READY;
   if ((0 == (reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
       (((task->write_fd != -1) &&
-        (GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, task->write_fd)))
+        (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)
-    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))
     {
-      if (GNUNET_YES == is_pending (task->prereq_id))
-        {
-          task->reason = reason;
-          return GNUNET_NO;     /* prereq waiting */
-        }
-      reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
+      task->reason = reason;
+      return GNUNET_NO;         /* prereq waiting */
     }
+    reason |= GNUNET_SCHEDULER_REASON_PREREQ_DONE;
+  }
   task->reason = reason;
   return GNUNET_YES;
 }
@@ -500,7 +500,7 @@ queue_ready_task (struct Task *task)
  */
 static void
 check_ready (const struct GNUNET_NETWORK_FDSet *rs,
-             const struct GNUNET_NETWORK_FDSet *ws)
+             const struct GNUNET_NETWORK_FDSet *ws)
 {
   struct Task *pos;
   struct Task *prev;
@@ -511,40 +511,39 @@ check_ready (const struct GNUNET_NETWORK_FDSet *rs,
   prev = NULL;
   pos = pending_timeout;
   while (pos != NULL)
-    {
-      next = pos->next;
-      if (now.abs_value >= pos->timeout.abs_value)
-        pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
-      if (0 == pos->reason)
-        break;
-      pending_timeout = next;
-      if (pending_timeout_last == pos)
-        pending_timeout_last = NULL;
-      queue_ready_task (pos);
-      pos = next;
-    }
+  {
+    next = pos->next;
+    if (now.abs_value >= pos->timeout.abs_value)
+      pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
+    if (0 == pos->reason)
+      break;
+    pending_timeout = next;
+    if (pending_timeout_last == pos)
+      pending_timeout_last = NULL;
+    queue_ready_task (pos);
+    pos = next;
+  }
   pos = pending;
   while (pos != NULL)
-    {
+  {
 #if DEBUG_TASKS
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Checking readiness of task: %llu / %p\n", pos->id,
-           pos->callback_cls);
+    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))
-        {
-          if (prev == NULL)
-            pending = next;
-          else
-            prev->next = next;
-          queue_ready_task (pos);
-          pos = next;
-          continue;
-        }
-      prev = pos;
+    next = pos->next;
+    if (GNUNET_YES == is_ready (pos, now, rs, ws))
+    {
+      if (prev == NULL)
+        pending = next;
+      else
+        prev->next = next;
+      queue_ready_task (pos);
       pos = next;
+      continue;
     }
+    prev = pos;
+    pos = next;
+  }
 }
 
 
@@ -563,15 +562,26 @@ GNUNET_SCHEDULER_shutdown ()
 
   pos = pending_timeout;
   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;
-    }
+  {
+    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
@@ -579,18 +589,7 @@ GNUNET_SCHEDULER_shutdown ()
        * 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;
-        }
-    }
+  }
 }
 
 
@@ -632,69 +631,68 @@ run_ready (struct GNUNET_NETWORK_FDSet *rs, struct GNUNET_NETWORK_FDSet *ws)
 
   max_priority_added = GNUNET_SCHEDULER_PRIORITY_KEEP;
   do
+  {
+    if (ready_count == 0)
+      return;
+    GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
+    /* yes, p>0 is correct, 0 is "KEEP" which should
+     * always be an empty queue (see assertion)! */
+    for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
     {
-      if (ready_count == 0)
-        return;
-      GNUNET_assert (ready[GNUNET_SCHEDULER_PRIORITY_KEEP] == NULL);
-      /* yes, p>0 is correct, 0 is "KEEP" which should
-       * always be an empty queue (see assertion)! */
-      for (p = GNUNET_SCHEDULER_PRIORITY_COUNT - 1; p > 0; p--)
-        {
-          pos = ready[p];
-          if (pos != NULL)
-            break;
-        }
-      GNUNET_assert (pos != NULL);      /* ready_count wrong? */
-      ready[p] = pos->next;
-      ready_count--;
-      if (current_priority != pos->priority)
-        {
-          current_priority = pos->priority;
-          (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (),
-                                                 pos->priority);
-        }
-      current_lifeness = pos->lifeness;
-      active_task = pos;
+      pos = ready[p];
+      if (pos != NULL)
+        break;
+    }
+    GNUNET_assert (pos != NULL);        /* ready_count wrong? */
+    ready[p] = pos->next;
+    ready_count--;
+    if (current_priority != pos->priority)
+    {
+      current_priority = pos->priority;
+      (void) GNUNET_OS_set_process_priority (GNUNET_OS_process_current (),
+                                             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)
-        {
-          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);
-        }
+    if (GNUNET_TIME_absolute_get_duration (pos->start_time).rel_value >
+        DELAY_THRESHOLD.rel_value)
+    {
+      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);
+    }
 #endif
-      tc.reason = pos->reason;
-      tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set;
-      if ((pos->read_fd != -1) &&
-          (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) &&
-          (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) &&
-          (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
-        abort ();               // added to ready in previous select loop!
+    tc.reason = pos->reason;
+    tc.read_ready = (pos->read_set == NULL) ? rs : pos->read_set;
+    if ((pos->read_fd != -1) &&
+        (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) &&
+        (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) &&
+        (!GNUNET_NETWORK_fdset_test_native (ws, pos->write_fd)))
+      abort ();                 // added to ready in previous select loop!
 #if DEBUG_TASKS
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-           "Running task: %llu / %p\n", pos->id, pos->callback_cls);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Running task: %llu / %p\n", pos->id,
+         pos->callback_cls);
 #endif
-      pos->callback (pos->callback_cls, &tc);
+    pos->callback (pos->callback_cls, &tc);
 #if EXECINFO
-      int 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, pos->backtrace_strings[i]);
+    for (i = 0; i < pos->num_backtrace_strings; 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++;
-    }
+    active_task = NULL;
+    destroy_task (pos);
+    tasks_run++;
+  }
   while ((pending == NULL) || (p >= max_priority_added));
 }
 
@@ -720,11 +718,11 @@ static void
 sighandler_shutdown ()
 {
   static char c;
-  int old_errno = errno;        /* backup errno */
+  int old_errno = errno;        /* backup errno */
 
   GNUNET_DISK_file_write (GNUNET_DISK_pipe_handle
-                          (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
-                          &c, sizeof (c));
+                          (shutdown_pipe_handle, GNUNET_DISK_PIPE_END_WRITE),
+                          &c, sizeof (c));
   errno = old_errno;
 }
 
@@ -750,10 +748,10 @@ check_lifeness ()
     if (t->lifeness == GNUNET_YES)
       return GNUNET_OK;
   if ((NULL != pending) || (NULL != pending_timeout))
-    {
-      GNUNET_SCHEDULER_shutdown ();
-      return GNUNET_OK;
-    }
+  {
+    GNUNET_SCHEDULER_shutdown ();
+    return GNUNET_OK;
+  }
   return GNUNET_NO;
 }
 
@@ -799,7 +797,7 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   shutdown_pipe_handle = GNUNET_DISK_pipe (GNUNET_NO, GNUNET_NO, GNUNET_NO);
   GNUNET_assert (shutdown_pipe_handle != NULL);
   pr = GNUNET_DISK_pipe_handle (shutdown_pipe_handle,
-                                GNUNET_DISK_PIPE_END_READ);
+                                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);
@@ -811,77 +809,76 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls)
   current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT;
   current_lifeness = GNUNET_YES;
   GNUNET_SCHEDULER_add_continuation (task, task_cls,
-                                     GNUNET_SCHEDULER_REASON_STARTUP);
+                                     GNUNET_SCHEDULER_REASON_STARTUP);
 #if ENABLE_WINDOWS_WORKAROUNDS
-  active_task = (void *) (long) -1;     /* force passing of sanity check */
+  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);
+                                          &GNUNET_OS_install_parent_control_handler,
+                                          NULL);
   active_task = NULL;
 #endif
   last_tr = 0;
   busy_wait_warning = 0;
   while (GNUNET_OK == check_lifeness ())
+  {
+    GNUNET_NETWORK_fdset_zero (rs);
+    GNUNET_NETWORK_fdset_zero (ws);
+    timeout = GNUNET_TIME_UNIT_FOREVER_REL;
+    update_sets (rs, ws, &timeout);
+    GNUNET_NETWORK_fdset_handle_set (rs, pr);
+    if (ready_count > 0)
     {
-      GNUNET_NETWORK_fdset_zero (rs);
-      GNUNET_NETWORK_fdset_zero (ws);
-      timeout = GNUNET_TIME_UNIT_FOREVER_REL;
-      update_sets (rs, ws, &timeout);
-      GNUNET_NETWORK_fdset_handle_set (rs, pr);
-      if (ready_count > 0)
-        {
-          /* no blocking, more work already ready! */
-          timeout = GNUNET_TIME_UNIT_ZERO;
-        }
-      if (NULL == scheduler_select)
-        ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout);
-      else
-        ret = scheduler_select (scheduler_select_cls, rs, ws, NULL, timeout);
-      if (ret == GNUNET_SYSERR)
-        {
-          if (errno == EINTR)
-            continue;
+      /* no blocking, more work already ready! */
+      timeout = GNUNET_TIME_UNIT_ZERO;
+    }
+    if (NULL == scheduler_select)
+      ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout);
+    else
+      ret = scheduler_select (scheduler_select_cls, rs, ws, NULL, timeout);
+    if (ret == GNUNET_SYSERR)
+    {
+      if (errno == EINTR)
+        continue;
 
-          LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "select");
+      LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "select");
 #ifndef MINGW
 #if USE_LSOF
-          char lsof[512];
+      char lsof[512];
 
-          snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
-          (void) close (1);
-          (void) dup2 (2, 1);
-          if (0 != system (lsof))
-            LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "system");
+      snprintf (lsof, sizeof (lsof), "lsof -p %d", getpid ());
+      (void) close (1);
+      (void) dup2 (2, 1);
+      if (0 != system (lsof))
+        LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "system");
 #endif
 #endif
-          abort ();
-          break;
-        }
-      if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
-        {
-          LOG (GNUNET_ERROR_TYPE_WARNING,
-               _("Looks like we're busy waiting...\n"));
-          sleep (1);            /* mitigate */
-        }
-      check_ready (rs, ws);
-      run_ready (rs, ws);
-      if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
-        {
-          /* consume the signal */
-          GNUNET_DISK_file_read (pr, &c, sizeof (c));
-          /* mark all active tasks as ready due to shutdown */
-          GNUNET_SCHEDULER_shutdown ();
-        }
-      if (last_tr == tasks_run)
-        {
-          busy_wait_warning++;
-        }
-      else
-        {
-          last_tr = tasks_run;
-          busy_wait_warning = 0;
-        }
+      abort ();
+      break;
+    }
+    if ((ret == 0) && (timeout.rel_value == 0) && (busy_wait_warning > 16))
+    {
+      LOG (GNUNET_ERROR_TYPE_WARNING, _("Looks like we're busy waiting...\n"));
+      sleep (1);                /* mitigate */
+    }
+    check_ready (rs, ws);
+    run_ready (rs, ws);
+    if (GNUNET_NETWORK_fdset_handle_isset (rs, pr))
+    {
+      /* consume the signal */
+      GNUNET_DISK_file_read (pr, &c, sizeof (c));
+      /* mark all active tasks as ready due to shutdown */
+      GNUNET_SCHEDULER_shutdown ();
+    }
+    if (last_tr == tasks_run)
+    {
+      busy_wait_warning++;
+    }
+    else
+    {
+      last_tr = tasks_run;
+      busy_wait_warning = 0;
     }
+  }
   GNUNET_SIGNAL_handler_uninstall (shc_int);
   GNUNET_SIGNAL_handler_uninstall (shc_term);
 #ifndef MINGW
@@ -934,10 +931,10 @@ GNUNET_SCHEDULER_get_load (enum GNUNET_SCHEDULER_Priority p)
   ret = 0;
   pos = ready[check_priority (p)];
   while (pos != NULL)
-    {
-      pos = pos->next;
-      ret++;
-    }
+  {
+    pos = pos->next;
+    ret++;
+  }
   return ret;
 }
 
@@ -963,77 +960,76 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
   prev = NULL;
   t = pending;
   while (t != NULL)
+  {
+    if (t->id == task)
+      break;
+    prev = t;
+    t = t->next;
+  }
+  if (t == NULL)
+  {
+    prev = NULL;
+    to = 1;
+    t = pending_timeout;
+    while (t != NULL)
     {
       if (t->id == task)
-        break;
+        break;
       prev = t;
       t = t->next;
     }
-  if (t == NULL)
-    {
-      prev = NULL;
-      to = 1;
-      t = pending_timeout;
-      while (t != NULL)
-        {
-          if (t->id == task)
-            break;
-          prev = t;
-          t = t->next;
-        }
-      if (pending_timeout_last == t)
-        pending_timeout_last = NULL;
-    }
+    if (pending_timeout_last == t)
+      pending_timeout_last = NULL;
+  }
   p = 0;
   while (t == NULL)
+  {
+    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"),
-               (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;
-        }
+      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 (p == 0)
-        {
-          if (to == 0)
-            {
-              pending = t->next;
-            }
-          else
-            {
-              pending_timeout = t->next;
-            }
-        }
+      if (to == 0)
+      {
+        pending = t->next;
+      }
       else
-        {
-          ready[p] = t->next;
-        }
+      {
+        pending_timeout = t->next;
+      }
     }
-  else
+    else
     {
-      prev->next = t->next;
+      ready[p] = t->next;
     }
+  }
+  else
+  {
+    prev->next = t->next;
+  }
   ret = t->callback_cls;
 #if DEBUG_TASKS
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Canceling task: %llu / %p\n", task, t->callback_cls);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Canceling task: %llu / %p\n", task,
+       t->callback_cls);
 #endif
   destroy_task (t);
   return ret;
@@ -1051,7 +1047,7 @@ GNUNET_SCHEDULER_cancel (GNUNET_SCHEDULER_TaskIdentifier task)
  */
 void
 GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
-                                   enum GNUNET_SCHEDULER_Reason reason)
+                                   enum GNUNET_SCHEDULER_Reason reason)
 {
   struct Task *t;
 
@@ -1061,12 +1057,12 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
 
   GNUNET_assert (NULL != task);
   GNUNET_assert ((active_task != NULL) ||
-                 (reason == GNUNET_SCHEDULER_REASON_STARTUP));
+                 (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);
+      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
@@ -1080,8 +1076,8 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
   t->priority = current_priority;
   t->lifeness = current_lifeness;
 #if DEBUG_TASKS
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding continuation task: %llu / %p\n", t->id, t->callback_cls);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Adding continuation task: %llu / %p\n", t->id,
+       t->callback_cls);
 #endif
   queue_ready_task (t);
 }
@@ -1106,12 +1102,11 @@ GNUNET_SCHEDULER_add_continuation (GNUNET_SCHEDULER_Task task, void *task_cls,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
-                            GNUNET_SCHEDULER_Task task, void *task_cls)
+                            GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   return GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_KEEP,
-                                      prerequisite_task,
-                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                      task_cls);
+                                      prerequisite_task, GNUNET_TIME_UNIT_ZERO,
+                                      NULL, NULL, task, task_cls);
 }
 
 
@@ -1126,12 +1121,11 @@ GNUNET_SCHEDULER_add_after (GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
-                                    GNUNET_SCHEDULER_Task task,
-                                    void *task_cls)
+                                    GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   return GNUNET_SCHEDULER_add_select (prio, GNUNET_SCHEDULER_NO_TASK,
-                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
-                                      task_cls);
+                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                      task_cls);
 }
 
 
@@ -1150,7 +1144,7 @@ GNUNET_SCHEDULER_add_with_priority (enum GNUNET_SCHEDULER_Priority prio,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
-                              GNUNET_SCHEDULER_Task task, void *task_cls)
+                              GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if 1
   /* new, optimized version */
@@ -1170,7 +1164,7 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
-    backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
@@ -1185,24 +1179,24 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
    * 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->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;
-    }
+  {
+    /* 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;
-    }
+         ((pos->timeout.abs_value <= t->timeout.abs_value) ||
+          (pos->reason != 0)))
+  {
+    prev = pos;
+    pos = pos->next;
+  }
   if (prev == NULL)
     pending_timeout = t;
   else
@@ -1212,23 +1206,23 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_TIME_Relative delay,
   pending_timeout_last = t;
 
 #if DEBUG_TASKS
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task: %llu / %p\n", t->id, t->callback_cls);
+  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++)
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+    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);
+                                      GNUNET_SCHEDULER_NO_TASK, delay, NULL,
+                                      NULL, task, task_cls);
 #endif
 }
 
@@ -1247,9 +1241,9 @@ GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task 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);
+                                      GNUNET_SCHEDULER_NO_TASK,
+                                      GNUNET_TIME_UNIT_ZERO, NULL, NULL, task,
+                                      task_cls);
 }
 
 
@@ -1269,16 +1263,16 @@ GNUNET_SCHEDULER_add_now (GNUNET_SCHEDULER_Task task, void *task_cls)
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
-                                        GNUNET_SCHEDULER_Task task,
-                                        void *task_cls)
+                                        GNUNET_SCHEDULER_Task task,
+                                        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_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;
   return ret;
@@ -1316,7 +1310,7 @@ GNUNET_SCHEDULER_add_now_with_lifeness (int lifeness,
 #ifndef MINGW
 GNUNET_SCHEDULER_TaskIdentifier
 add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
-                  GNUNET_SCHEDULER_Task task, void *task_cls)
+                  GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
 
@@ -1332,45 +1326,41 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
-    backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
 #if DEBUG_FDS
   if (-1 != rfd)
-    {
-      int flags = fcntl (rfd, F_GETFD);
+  {
+    int flags = fcntl (rfd, F_GETFD);
 
-      if ((flags == -1) && (errno == EBADF))
-        {
-          LOG (GNUNET_ERROR_TYPE_ERROR,
-               "Got invalid file descriptor %d!\n", rfd);
+    if ((flags == -1) && (errno == EBADF))
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", rfd);
 #if EXECINFO
-          int i;
+      int i;
 
-          for (i = 0; i < t->num_backtrace_strings; i++)
-            LOG (GNUNET_ERROR_TYPE_DEBUG,
-                 "Trace: %s\n", t->backtrace_strings[i]);
+      for (i = 0; i < t->num_backtrace_strings; i++)
+        LOG (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", t->backtrace_strings[i]);
 #endif
-          GNUNET_assert (0);
-        }
+      GNUNET_assert (0);
     }
+  }
   if (-1 != wfd)
-    {
-      int flags = fcntl (wfd, F_GETFD);
+  {
+    int flags = fcntl (wfd, F_GETFD);
 
-      if (flags == -1 && errno == EBADF)
-        {
-          LOG (GNUNET_ERROR_TYPE_ERROR,
-               "Got invalid file descriptor %d!\n", wfd);
+    if (flags == -1 && errno == EBADF)
+    {
+      LOG (GNUNET_ERROR_TYPE_ERROR, "Got invalid file descriptor %d!\n", wfd);
 #if EXECINFO
-          int i;
+      int i;
 
-          for (i = 0; i < t->num_backtrace_strings; i++)
-            LOG (GNUNET_ERROR_TYPE_DEBUG,
-                 "Trace: %s\n", t->backtrace_strings[i]);
+      for (i = 0; i < t->num_backtrace_strings; i++)
+        LOG (GNUNET_ERROR_TYPE_DEBUG, "Trace: %s\n", t->backtrace_strings[i]);
 #endif
-          GNUNET_assert (0);
-        }
+      GNUNET_assert (0);
     }
+  }
 #endif
   t->read_fd = rfd;
   GNUNET_assert (wfd >= -1);
@@ -1387,15 +1377,15 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
   pending = t;
   max_priority_added = GNUNET_MAX (max_priority_added, t->priority);
 #if DEBUG_TASKS
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task: %llu / %p\n", t->id, t->callback_cls);
+  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++)
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+         t->backtrace_strings[i]);
 #endif
   return t->id;
 }
@@ -1421,8 +1411,8 @@ add_without_sets (struct GNUNET_TIME_Relative delay, int rfd, int wfd,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 GNUNET_SCHEDULER_add_read_net (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;
@@ -1432,14 +1422,14 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
   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_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);
+                           task_cls);
 #endif
 }
 
@@ -1462,8 +1452,8 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_TIME_Relative delay,
  */
 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)
+                                struct GNUNET_NETWORK_Handle *wfd,
+                                GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if MINGW
   struct GNUNET_NETWORK_FDSet *ws;
@@ -1473,15 +1463,15 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
   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_SCHEDULER_add_select (check_priority (current_priority),
+                                   GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
+                                   task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
   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);
+                           task_cls);
 #endif
 }
 
@@ -1504,8 +1494,8 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_TIME_Relative delay,
  */
 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)
+                                const struct GNUNET_DISK_FileHandle *rfd,
+                                GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if MINGW
   struct GNUNET_NETWORK_FDSet *rs;
@@ -1515,9 +1505,9 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
   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_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
@@ -1548,8 +1538,8 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_TIME_Relative delay,
  */
 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)
+                                 const struct GNUNET_DISK_FileHandle *wfd,
+                                 GNUNET_SCHEDULER_Task task, void *task_cls)
 {
 #if MINGW
   struct GNUNET_NETWORK_FDSet *ws;
@@ -1559,9 +1549,9 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
   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_SCHEDULER_add_select (check_priority (current_priority),
+                                   GNUNET_SCHEDULER_NO_TASK, delay, NULL, ws,
+                                   task, task_cls);
   GNUNET_NETWORK_fdset_destroy (ws);
   return ret;
 #else
@@ -1610,12 +1600,11 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_TIME_Relative delay,
  */
 GNUNET_SCHEDULER_TaskIdentifier
 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,
-                             GNUNET_SCHEDULER_Task task, void *task_cls)
+                             GNUNET_SCHEDULER_TaskIdentifier prerequisite_task,
+                             struct GNUNET_TIME_Relative delay,
+                             const struct GNUNET_NETWORK_FDSet *rs,
+                             const struct GNUNET_NETWORK_FDSet *ws,
+                             GNUNET_SCHEDULER_Task task, void *task_cls)
 {
   struct Task *t;
 
@@ -1631,20 +1620,20 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
 #if EXECINFO
   t->num_backtrace_strings = backtrace (backtrace_array, MAX_TRACE_DEPTH);
   t->backtrace_strings =
-    backtrace_symbols (backtrace_array, t->num_backtrace_strings);
+      backtrace_symbols (backtrace_array, t->num_backtrace_strings);
 #endif
   t->read_fd = -1;
   t->write_fd = -1;
   if (rs != NULL)
-    {
-      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)
-    {
-      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 ();
@@ -1652,23 +1641,23 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
   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);
+      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
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-       "Adding task: %llu / %p\n", t->id, t->callback_cls);
+  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++)
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-         "Task %llu trace %d: %s\n", t->id, i, t->backtrace_strings[i]);
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "Task %llu trace %d: %s\n", t->id, i,
+         t->backtrace_strings[i]);
 #endif
   return t->id;
 }