Merge remote-tracking branch 'gnunet/master' into identity_oidc

8 files changed, 172 insertions, 94 deletions

diff --git a/src/cadet/gnunet-service-cadet_peer.c b/src/cadet/gnunet-service-cadet_peer.c
index da78a03c4..05555e693 100644
--- a/src/cadet/gnunet-service-cadet_peer.c
+++ b/src/cadet/gnunet-service-cadet_peer.c
@@ -59,7 +59,10 @@
  */
 #define IDLE_PATH_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MINUTES, 2)
 
-
+/**
+ * Queue size when we start dropping OOO messages.
+ */
+#define MAX_OOO_QUEUE_SIZE  100
 
 
 /**
@@ -1464,6 +1467,11 @@ GCP_send_ooo (struct CadetPeer *cp,
     GNUNET_MQ_discard (env);
     return;
   }
+  if (GNUNET_MQ_get_length (cp->core_mq) > MAX_OOO_QUEUE_SIZE)
+  {
+    GNUNET_MQ_discard (env);
+    return;
+  }
   GNUNET_MQ_notify_sent (env,
                          &mqm_send_done,
                          cp);
diff --git a/src/fs/gnunet-service-fs_cp.c b/src/fs/gnunet-service-fs_cp.c
index 817aed257..6e28ca606 100644
--- a/src/fs/gnunet-service-fs_cp.c
+++ b/src/fs/gnunet-service-fs_cp.c
@@ -1230,7 +1230,9 @@ handle_p2p_get (void *cls,
                               GNUNET_NO);
     return;
   }
-  if (cp->ppd.pending_replies + cp->delay_queue_size > MAX_QUEUE_PER_PEER)
+  unsigned int queue_size = GNUNET_MQ_get_length (cp->mq);
+  queue_size += cp->ppd.pending_replies + cp->delay_queue_size;
+  if (queue_size > MAX_QUEUE_PER_PEER)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Peer `%s' has too many replies queued already. Dropping query.\n",
diff --git a/src/gns/gnunet-gns-proxy.c b/src/gns/gnunet-gns-proxy.c
index 3af571eba..25092dcf0 100644
--- a/src/gns/gnunet-gns-proxy.c
+++ b/src/gns/gnunet-gns-proxy.c
@@ -1957,8 +1957,10 @@ mhd_log_callback (void *cls,
   }
   s5r->url = GNUNET_strdup (url);
   if (NULL != s5r->timeout_task)
+  {
     GNUNET_SCHEDULER_cancel (s5r->timeout_task);
-  s5r->timeout_task = NULL;
+    s5r->timeout_task = NULL;
+  }
   GNUNET_assert (s5r->state == SOCKS5_SOCKET_WITH_MHD);
   return s5r;
 }
@@ -2060,7 +2062,10 @@ schedule_httpd (struct MhdHttpList *hd)
     wws = NULL;
   }
   if (NULL != hd->httpd_task)
+  {
     GNUNET_SCHEDULER_cancel (hd->httpd_task);
+    hd->httpd_task = NULL;
+  }
   if ( (MHD_YES != haveto) &&
        (-1 == max) &&
        (hd != httpd) )
@@ -2108,8 +2113,7 @@ do_httpd (void *cls)
 static void
 run_mhd_now (struct MhdHttpList *hd)
 {
-  if (NULL !=
-      hd->httpd_task)
+  if (NULL != hd->httpd_task)
     GNUNET_SCHEDULER_cancel (hd->httpd_task);
   hd->httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd,
                                              hd);
@@ -2891,18 +2895,17 @@ do_accept (void *cls)
   struct GNUNET_NETWORK_Handle *s;
   struct Socks5Request *s5r;
 
-  if (lsock == lsock4)
-    ltask4 = NULL;
-  else
-    ltask6 = NULL;
+  GNUNET_assert (NULL != lsock);
   if (lsock == lsock4)
     ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             lsock,
                                             &do_accept, lsock);
-  else
+  else if (lsock == lsock6)
     ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             lsock,
                                             &do_accept, lsock);
+  else
+    GNUNET_assert (0);
   s = GNUNET_NETWORK_socket_accept (lsock, NULL, NULL);
   if (NULL == s)
   {
diff --git a/src/identity/plugin_rest_identity.c b/src/identity/plugin_rest_identity.c
index 33804143d..6044d0641 100644
--- a/src/identity/plugin_rest_identity.c
+++ b/src/identity/plugin_rest_identity.c
@@ -241,7 +241,10 @@ cleanup_handle (struct RequestHandle *handle)
   if (NULL != handle->name)
     GNUNET_free (handle->name);
   if (NULL != handle->timeout_task)
+  {
     GNUNET_SCHEDULER_cancel (handle->timeout_task);
+    handle->timeout_task = NULL;
+  }
   if (NULL != handle->identity_handle)
     GNUNET_IDENTITY_disconnect (handle->identity_handle);
   if (NULL != handle->subsys)
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h
index e886a561c..f46afa6cc 100644
--- a/src/include/gnunet_crypto_lib.h
+++ b/src/include/gnunet_crypto_lib.h
@@ -363,7 +363,7 @@ struct GNUNET_CRYPTO_PaillierPublicKey
 
 
 /**
- * Paillier public key.
+ * Paillier private key.
  */
 struct GNUNET_CRYPTO_PaillierPrivateKey
 {
diff --git a/src/rest/gnunet-rest-server.c b/src/rest/gnunet-rest-server.c
index 5415937a7..c14b09819 100644
--- a/src/rest/gnunet-rest-server.c
+++ b/src/rest/gnunet-rest-server.c
@@ -154,11 +154,14 @@ do_httpd (void *cls);
 static void
 run_mhd_now ()
 {
-  if (NULL !=
-      httpd_task)
+  if (NULL != httpd_task)
+  {
     GNUNET_SCHEDULER_cancel (httpd_task);
+    httpd_task = NULL;
+  }
   httpd_task = GNUNET_SCHEDULER_add_now (&do_httpd,
                                          NULL);
+
 }
 
 /**
@@ -449,7 +452,18 @@ kill_httpd ()
     GNUNET_SCHEDULER_cancel (ltask6);
     ltask6 = NULL;
   }
-}
+
+  if (NULL != lsock4)
+  {
+    GNUNET_NETWORK_socket_close (lsock4);
+    lsock4 = NULL;
+  }
+  if (NULL != lsock6)
+  {
+    GNUNET_NETWORK_socket_close (lsock6);
+    lsock6 = NULL;
+  }
+  }
 
 
 /**
@@ -499,7 +513,10 @@ schedule_httpd ()
     wws = NULL;
   }
   if (NULL != httpd_task)
+  {
     GNUNET_SCHEDULER_cancel (httpd_task);
+    httpd_task = NULL;
+  }
   if ( (MHD_YES == haveto) ||
        (-1 != max))
   {
@@ -507,6 +524,7 @@ schedule_httpd ()
       GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
                                    tv, wrs, wws,
                                    &do_httpd, NULL);
+    
   }
   if (NULL != wrs)
     GNUNET_NETWORK_fdset_destroy (wrs);
@@ -543,18 +561,23 @@ do_accept (void *cls)
   const struct sockaddr *addr;
   socklen_t len;
 
+  GNUNET_assert (NULL != lsock);
   if (lsock == lsock4)
-    ltask4 = NULL;
-  else
-    ltask6 = NULL;
-  if (lsock == lsock4)
+  {
     ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             lsock,
                                             &do_accept, lsock);
-  else
+
+  }
+  else if (lsock == lsock6)
+  {
     ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                             lsock,
                                             &do_accept, lsock);
+
+  }
+  else
+    GNUNET_assert (0);
   s = GNUNET_NETWORK_socket_accept (lsock, NULL, NULL);
   if (NULL == s)
   {
@@ -759,6 +782,7 @@ run (void *cls,
     {
       ltask6 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                               lsock6, &do_accept, lsock6);
+
     }
   }
   lsock4 = bind_v4 ();
@@ -778,6 +802,7 @@ run (void *cls,
     {
       ltask4 = GNUNET_SCHEDULER_add_read_net (GNUNET_TIME_UNIT_FOREVER_REL,
                                               lsock4, &do_accept, lsock4);
+
     }
   }
   if ( (NULL == lsock4) &&
@@ -824,10 +849,10 @@ main (int argc, char *const *argv)
 {
   struct GNUNET_GETOPT_CommandLineOption options[] = {
     GNUNET_GETOPT_option_ulong ('p',
-                                    "port",
-                                    "PORT",
-                                    gettext_noop ("listen on specified port (default: 7776)"),
-                                    &port),
+                                "port",
+                                "PORT",
+                                gettext_noop ("listen on specified port (default: 7776)"),
+                                &port),
     GNUNET_GETOPT_OPTION_END
   };
   static const char* err_page =
diff --git a/src/rps/test_rps.c b/src/rps/test_rps.c
index 2cc1ac62e..6189557f6 100644
--- a/src/rps/test_rps.c
+++ b/src/rps/test_rps.c
@@ -325,6 +325,34 @@ typedef void (*PostTest) (void *cls, struct GNUNET_RPS_Handle *h);
  */
 typedef int (*EvaluationCallback) (void);
 
+/**
+ * @brief Do we have Churn?
+ */
+enum OPTION_CHURN {
+  /**
+   * @brief If we have churn this is set
+   */
+  HAVE_CHURN,
+  /**
+   * @brief If we have no churn this is set
+   */
+  HAVE_NO_CHURN,
+};
+
+/**
+ * @brief Is it ok to quit the test before the timeout?
+ */
+enum OPTION_QUICK_QUIT {
+  /**
+   * @brief It is ok for the test to quit before the timeout triggers
+   */
+  HAVE_QUICK_QUIT,
+
+  /**
+   * @brief It is NOT ok for the test to quit before the timeout triggers
+   */
+  HAVE_NO_QUICK_QUIT,
+};
 
 /**
  * Structure to define a single test
@@ -377,9 +405,14 @@ struct SingleTestRun
   uint32_t num_requests;
 
   /**
-   * Run with churn
+   * Run with (-out) churn
    */
-  int have_churn;
+  enum OPTION_CHURN have_churn;
+
+  /**
+   * Quit test before timeout?
+   */
+  enum OPTION_QUICK_QUIT have_quick_quit;
 } cur_test_run;
 
 /**
@@ -801,8 +834,9 @@ default_reply_handle (void *cls,
     rps_peer->num_recv_ids++;
   }
 
-  if (0 == evaluate ())
+  if (0 == evaluate () && HAVE_QUICK_QUIT == cur_test_run.have_quick_quit)
   {
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test succeeded before timeout\n");
     GNUNET_assert (NULL != shutdown_task);
     GNUNET_SCHEDULER_cancel (shutdown_task);
     shutdown_task = GNUNET_SCHEDULER_add_now (&shutdown_op, NULL);
@@ -1143,7 +1177,7 @@ churn_test_cb (struct RPSPeer *rps_peer)
   }
 
   /* Start churn */
-  if (GNUNET_YES == cur_test_run.have_churn && NULL == churn_task)
+  if (HAVE_CHURN == cur_test_run.have_churn && NULL == churn_task)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Starting churn task\n");
@@ -1265,8 +1299,6 @@ manage_service_wrapper (unsigned int i, unsigned int j,
   struct OpListEntry *entry;
   uint32_t prob;
 
-  GNUNET_assert (GNUNET_YES == rps_peers[j].online);
-
   /* make sure that management operation is not already scheduled */
   if (NULL != rps_peers[j].entry_op_manage)
   {
@@ -1288,10 +1320,6 @@ manage_service_wrapper (unsigned int i, unsigned int j,
                 GNUNET_i2s (rps_peers[j].peer_id),
                 (PEER_GO_OFFLINE == delta) ? "offline" : "online");
 
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "testbed_peers points to %p, peer 0 to %p\n",
-                testbed_peers, testbed_peers[0]);
-
     if (PEER_GO_OFFLINE == delta)
       cancel_pending_req_rep (&rps_peers[j]);
     entry = make_oplist_entry ();
@@ -1441,7 +1469,7 @@ profiler_cb (struct RPSPeer *rps_peer)
   }
 
   /* Start churn */
-  if (GNUNET_YES == cur_test_run.have_churn && NULL == churn_task)
+  if (HAVE_CHURN == cur_test_run.have_churn && NULL == churn_task)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "Starting churn task\n");
@@ -1621,7 +1649,7 @@ main (int argc, char *argv[])
   cur_test_run.pre_test = NULL;
   cur_test_run.reply_handle = default_reply_handle;
   cur_test_run.eval_cb = default_eval_cb;
-  cur_test_run.have_churn = GNUNET_YES;
+  cur_test_run.have_churn = HAVE_CHURN;
   churn_task = NULL;
   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
 
@@ -1656,7 +1684,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test single request\n");
     cur_test_run.name = "test-rps-single-req";
     cur_test_run.main_test = single_req_cb;
-    cur_test_run.have_churn = GNUNET_NO;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
   }
 
   else if (strstr (argv[0], "_delayed_reqs") != NULL)
@@ -1664,7 +1692,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test delayed requests\n");
     cur_test_run.name = "test-rps-delayed-reqs";
     cur_test_run.main_test = delay_req_cb;
-    cur_test_run.have_churn = GNUNET_NO;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
   }
 
   else if (strstr (argv[0], "_seed_big") != NULL)
@@ -1674,7 +1702,7 @@ main (int argc, char *argv[])
     cur_test_run.name = "test-rps-seed-big";
     cur_test_run.main_test = seed_big_cb;
     cur_test_run.eval_cb = no_eval;
-    cur_test_run.have_churn = GNUNET_NO;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
   }
 
@@ -1683,7 +1711,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on a single peer\n");
     cur_test_run.name = "test-rps-single-peer-seed";
     cur_test_run.main_test = single_peer_seed_cb;
-    cur_test_run.have_churn = GNUNET_NO;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
   }
 
   else if (strstr (argv[0], "_seed_request") != NULL)
@@ -1691,7 +1719,7 @@ main (int argc, char *argv[])
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test seeding and requesting on multiple peers\n");
     cur_test_run.name = "test-rps-seed-request";
     cur_test_run.main_test = seed_req_cb;
-    cur_test_run.have_churn = GNUNET_NO;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
   }
 
   else if (strstr (argv[0], "_seed") != NULL)
@@ -1700,7 +1728,7 @@ main (int argc, char *argv[])
     cur_test_run.name = "test-rps-seed";
     cur_test_run.main_test = seed_cb;
     cur_test_run.eval_cb = no_eval;
-    cur_test_run.have_churn = GNUNET_NO;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
   }
 
   else if (strstr (argv[0], "_req_cancel") != NULL)
@@ -1710,7 +1738,7 @@ main (int argc, char *argv[])
     num_peers = 1;
     cur_test_run.main_test = req_cancel_cb;
     cur_test_run.eval_cb = no_eval;
-    cur_test_run.have_churn = GNUNET_NO;
+    cur_test_run.have_churn = HAVE_NO_CHURN;
     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
   }
 
@@ -1723,7 +1751,8 @@ main (int argc, char *argv[])
     cur_test_run.main_test = churn_test_cb;
     cur_test_run.reply_handle = default_reply_handle;
     cur_test_run.eval_cb = default_eval_cb;
-    cur_test_run.have_churn = GNUNET_YES;
+    cur_test_run.have_churn = HAVE_CHURN;
+    cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10);
   }
 
@@ -1740,8 +1769,9 @@ main (int argc, char *argv[])
     cur_test_run.eval_cb = profiler_eval;
     cur_test_run.request_interval = 2;
     cur_test_run.num_requests = 5;
-    cur_test_run.have_churn = GNUNET_YES;
-    timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 90);
+    cur_test_run.have_churn = HAVE_CHURN;
+    cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
+    timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300);
 
     /* 'Clean' directory */
     (void) GNUNET_DISK_directory_remove ("/tmp/rps/");
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index 9d37231e7..279a4ed02 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -1659,8 +1659,7 @@ GNUNET_SCHEDULER_add_file_with_priority (struct GNUNET_TIME_Relative delay,
 
 
 void
-extract_handles (struct GNUNET_SCHEDULER_Task *t,
-                 const struct GNUNET_NETWORK_FDSet *fdset,
+extract_handles (const struct GNUNET_NETWORK_FDSet *fdset,
                  const struct GNUNET_NETWORK_Handle ***ntarget,
                  unsigned int *extracted_nhandles,
                  const struct GNUNET_DISK_FileHandle ***ftarget,
@@ -1673,7 +1672,6 @@ extract_handles (struct GNUNET_SCHEDULER_Task *t,
   unsigned int nhandles_len;
   unsigned int fhandles_len;
 
-  (void) t;
   nhandles = NULL;
   fhandles = NULL;
   nhandles_len = 0;
@@ -1748,57 +1746,63 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                              void *task_cls)
 {
   struct GNUNET_SCHEDULER_Task *t;
-  const struct GNUNET_NETWORK_Handle **read_nhandles;
-  const struct GNUNET_NETWORK_Handle **write_nhandles;
-  const struct GNUNET_DISK_FileHandle **read_fhandles;
-  const struct GNUNET_DISK_FileHandle **write_fhandles;
-  unsigned int read_nhandles_len, write_nhandles_len,
-               read_fhandles_len, write_fhandles_len;
-  int no_fdsets = (NULL == rs) && (NULL == ws);
-  int no_socket_descriptors =
-    ((NULL != rs) && (0 == rs->nsds)) && ((NULL != ws) && (0 == ws->nsds));
-
-  if (no_fdsets || no_socket_descriptors)
-    return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
-                                                       prio,
-                                                       task,
-                                                       task_cls);
+  const struct GNUNET_NETWORK_Handle **read_nhandles = NULL;
+  const struct GNUNET_NETWORK_Handle **write_nhandles = NULL;
+  const struct GNUNET_DISK_FileHandle **read_fhandles = NULL;
+  const struct GNUNET_DISK_FileHandle **write_fhandles = NULL;
+  unsigned int read_nhandles_len = 0;
+  unsigned int write_nhandles_len = 0;
+  unsigned int read_fhandles_len = 0;
+  unsigned int write_fhandles_len = 0;
+
   /* scheduler must be running */
   GNUNET_assert (NULL != scheduler_driver);
   GNUNET_assert (NULL != active_task);
   GNUNET_assert (NULL != task);
-  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
-  t->callback = task;
-  t->callback_cls = task_cls;
-  t->read_fd = -1;
-  t->write_fd = -1;
-  t->own_handles = GNUNET_YES;
-  read_nhandles = NULL;
-  write_nhandles = NULL;
-  read_fhandles = NULL;
-  write_fhandles = NULL;
-  read_nhandles_len = 0;
-  write_nhandles_len = 0;
-  read_fhandles_len = 0;
-  write_fhandles_len = 0;
-  if (NULL != rs)
-  {
-    extract_handles (t,
-                     rs,
-                     &read_nhandles,
-                     &read_nhandles_len,
-                     &read_fhandles,
-                     &read_fhandles_len);
-  }
-  if (NULL != ws)
+  int no_rs = (NULL == rs);
+  int no_ws = (NULL == ws);
+  int empty_rs = (NULL != rs) && (0 == rs->nsds);
+  int empty_ws = (NULL != ws) && (0 == ws->nsds);
+  int no_fds = (no_rs && no_ws) ||
+               (empty_rs && empty_ws) ||
+               (no_rs && empty_ws) ||
+               (no_ws && empty_rs);
+  if (! no_fds)
   {
-    extract_handles (t,
-                     ws,
-                     &write_nhandles,
-                     &write_nhandles_len,
-                     &write_fhandles,
-                     &write_fhandles_len);
+    if (NULL != rs)
+    {
+      extract_handles (rs,
+                       &read_nhandles,
+                       &read_nhandles_len,
+                       &read_fhandles,
+                       &read_fhandles_len);
+    }
+    if (NULL != ws)
+    {
+      extract_handles (ws,
+                       &write_nhandles,
+                       &write_nhandles_len,
+                       &write_fhandles,
+                       &write_fhandles_len);
+    }
   }
+  /**
+   * here we consider the case that a GNUNET_NETWORK_FDSet might be empty
+   * although its maximum FD number (nsds) is greater than 0. We handle
+   * this case gracefully because some libraries such as libmicrohttpd
+   * only provide a hint what the maximum FD number in an FD set might be
+   * and not the exact FD number (see e.g. gnunet-rest-service.c)
+   */
+  int no_fds_extracted = (0 == read_nhandles_len) &&
+                         (0 == read_fhandles_len) &&
+                         (0 == write_nhandles_len) &&
+                         (0 == write_fhandles_len);
+  if (no_fds || no_fds_extracted)
+    return GNUNET_SCHEDULER_add_delayed_with_priority (delay,
+                                                       prio,
+                                                       task,
+                                                       task_cls);
+  t = GNUNET_new (struct GNUNET_SCHEDULER_Task);
   init_fd_info (t,
                 read_nhandles,
                 read_nhandles_len,
@@ -1808,6 +1812,9 @@ GNUNET_SCHEDULER_add_select (enum GNUNET_SCHEDULER_Priority prio,
                 read_fhandles_len,
                 write_fhandles,
                 write_fhandles_len);
+  t->callback = task;
+  t->callback_cls = task_cls;
+  t->own_handles = GNUNET_YES;
   /* free the arrays of pointers to network / file handles, the actual
    * handles will be freed in destroy_task */
   GNUNET_array_grow (read_nhandles, read_nhandles_len, 0);
@@ -2006,7 +2013,7 @@ GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
       if (GNUNET_OK != del_result)
       {
         LOG (GNUNET_ERROR_TYPE_ERROR,
-             "driver could not delete task\n");
+           "driver could not delete task %p\n", pos);
         GNUNET_assert (0);
       }
     }