9 files changed, 415 insertions, 128 deletions

diff --git a/src/gns/gnunet-gns-proxy.c b/src/gns/gnunet-gns-proxy.c
index 25092dcf0..591dff04f 100644
--- a/src/gns/gnunet-gns-proxy.c
+++ b/src/gns/gnunet-gns-proxy.c
@@ -1150,8 +1150,8 @@ curl_check_hdr (void *buffer, size_t size, size_t nmemb, void *cls)
                 hdr_type,
                 hdr_val);
     header = GNUNET_new (struct HttpResponseHeader);
-    header->type = GNUNET_strndup (hdr_type, strlen (hdr_type));
-    header->value = GNUNET_strndup (hdr_val, strlen (hdr_val));
+    header->type = GNUNET_strdup (hdr_type);
+    header->value = GNUNET_strdup (hdr_val);
     GNUNET_CONTAINER_DLL_insert (s5r->header_head,
                                  s5r->header_tail,
                                  header);
diff --git a/src/include/gnunet_namestore_service.h b/src/include/gnunet_namestore_service.h
index 0add8852a..6d3c07f1d 100644
--- a/src/include/gnunet_namestore_service.h
+++ b/src/include/gnunet_namestore_service.h
@@ -193,7 +193,7 @@ GNUNET_NAMESTORE_records_lookup (struct GNUNET_NAMESTORE_Handle *h,
  * Returns at most one result to the processor.
  *
  * @param h handle to the namestore
- * @param zone public key of the zone to look up in, never NULL
+ * @param zone private key of the zone to look up in, never NULL
  * @param value_zone public key of the target zone (value), never NULL
  * @param error_cb function to call on error (i.e. disconnect)
  *        the handle is afterwards invalid
diff --git a/src/namestore/Makefile.am b/src/namestore/Makefile.am
index 4f710e116..a848d4b72 100644
--- a/src/namestore/Makefile.am
+++ b/src/namestore/Makefile.am
@@ -59,8 +59,8 @@ TESTING_TESTS = \
  test_namestore_api_zone_iteration_specific_zone.nc \
  test_namestore_api_zone_iteration_stop.nc \
  test_namestore_api_monitoring.nc \
- test_namestore_api_monitoring_existing.nc
-# test_namestore_api_zone_to_name
+ test_namestore_api_monitoring_existing.nc \
+ test_namestore_api_zone_to_name
 endif
 
 # Declare .nc (NO-CONCURRENCY) as a test extension so that we can impart
@@ -298,12 +298,12 @@ test_namestore_api_remove_not_existing_record_nc_LDADD = \
   $(top_builddir)/src/gnsrecord/libgnunetgnsrecord.la \
   libgnunetnamestore.la
 
-#test_namestore_api_zone_to_name_SOURCES = \
-# test_namestore_api_zone_to_name.c
-#test_namestore_api_zone_to_name_LDADD = \
-#  $(top_builddir)/src/testing/libgnunettesting.la \
-#  $(top_builddir)/src/util/libgnunetutil.la \
-#  libgnunetnamestore.la
+test_namestore_api_zone_to_name_SOURCES = \
+ test_namestore_api_zone_to_name.c
+test_namestore_api_zone_to_name_LDADD = \
+  $(top_builddir)/src/testing/libgnunettesting.la \
+  $(top_builddir)/src/util/libgnunetutil.la \
+  libgnunetnamestore.la
 
 test_namestore_api_monitoring_nc_SOURCES = \
  test_namestore_api_monitoring.c
diff --git a/src/namestore/namestore_api.c b/src/namestore/namestore_api.c
index 92068cc01..a187bd250 100644
--- a/src/namestore/namestore_api.c
+++ b/src/namestore/namestore_api.c
@@ -405,6 +405,7 @@ check_lookup_result (void *cls,
   size_t name_len;
   size_t rd_len;
 
+  (void) cls;
   rd_len = ntohs (msg->rd_len);
   msg_len = ntohs (msg->gns_header.header.size);
   name_len = ntohs (msg->name_len);
@@ -517,6 +518,7 @@ check_record_result (void *cls,
   size_t name_len;
   size_t rd_len;
 
+  (void) cls;
   rd_len = ntohs (msg->rd_len);
   msg_len = ntohs (msg->gns_header.header.size);
   name_len = ntohs (msg->name_len);
@@ -656,6 +658,7 @@ check_zone_to_name_response (void *cls,
   size_t rd_ser_len;
   const char *name_tmp;
 
+  (void) cls;
   if (GNUNET_OK != ntohs (msg->res))
     return GNUNET_OK;
   name_len = ntohs (msg->name_len);
@@ -771,6 +774,7 @@ mq_error_handler (void *cls,
 {
   struct GNUNET_NAMESTORE_Handle *h = cls;
 
+  (void) error;
   force_reconnect (h);
 }
 
@@ -994,6 +998,7 @@ GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle *h,
   size_t name_len;
   uint32_t rid;
   struct RecordStoreMessage *msg;
+  ssize_t sret;
 
   name_len = strlen (label) + 1;
   if (name_len > MAX_NAME_LEN)
@@ -1029,11 +1034,16 @@ GNUNET_NAMESTORE_records_store (struct GNUNET_NAMESTORE_Handle *h,
                  label,
                  name_len);
   rd_ser = &name_tmp[name_len];
-  GNUNET_assert (rd_ser_len ==
-                 GNUNET_GNSRECORD_records_serialize (rd_count,
-                                                     rd,
-                                                     rd_ser_len,
-                                                     rd_ser));
+  sret = GNUNET_GNSRECORD_records_serialize (rd_count,
+                                             rd,
+                                             rd_ser_len,
+                                             rd_ser);
+  if (0 > sret)
+  {
+    GNUNET_free (env);
+    return NULL;
+  }
+  GNUNET_assert (rd_ser_len == (size_t) sret);
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Sending NAMESTORE_RECORD_STORE message for name `%s' with %u records\n",
        label,
diff --git a/src/namestore/test_namestore_api_zone_to_name.c b/src/namestore/test_namestore_api_zone_to_name.c
index ca33ee280..2bc7d34a3 100644
--- a/src/namestore/test_namestore_api_zone_to_name.c
+++ b/src/namestore/test_namestore_api_zone_to_name.c
@@ -37,28 +37,25 @@
 #define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 100)
 
 
-static struct GNUNET_NAMESTORE_Handle * nsh;
+static struct GNUNET_NAMESTORE_Handle *nsh;
 
-static struct GNUNET_SCHEDULER_Task * endbadly_task;
+static struct GNUNET_SCHEDULER_Task *endbadly_task;
 
-static struct GNUNET_CRYPTO_EcdsaPrivateKey * privkey;
+static struct GNUNET_CRYPTO_EcdsaPrivateKey *privkey;
 
 static struct GNUNET_CRYPTO_EcdsaPublicKey pubkey;
 
-static struct GNUNET_TIME_Absolute expire;
-
-static struct GNUNET_CRYPTO_ShortHashCode s_zone;
-
-static struct GNUNET_CRYPTO_ShortHashCode s_zone_value;
+static struct GNUNET_CRYPTO_EcdsaPublicKey s_zone_value;
 
 static char * s_name;
 
-static struct GNUNET_CRYPTO_EcdsaSignature *s_signature;
-
 static int res;
 
 static char *directory;
 
+static struct GNUNET_NAMESTORE_QueueEntry *qe;
+
+
 /**
  * Re-establish the connection to the service.
  *
@@ -67,12 +64,8 @@ static char *directory;
 static void
 endbadly (void *cls)
 {
-  if (nsh != NULL)
-    GNUNET_NAMESTORE_disconnect (nsh);
-  nsh = NULL;
-  if (privkey != NULL)
-    GNUNET_free (privkey);
-  privkey = NULL;
+  (void) cls;
+  GNUNET_SCHEDULER_shutdown ();
   res = 1;
 }
 
@@ -80,50 +73,69 @@ endbadly (void *cls)
 static void
 end (void *cls)
 {
-  if (endbadly_task != NULL)
+  if (NULL != qe)
+  {
+    GNUNET_NAMESTORE_cancel (qe);
+    qe = NULL;
+  }
+  if (NULL != endbadly_task)
   {
     GNUNET_SCHEDULER_cancel (endbadly_task);
     endbadly_task = NULL;
   }
-  if (privkey != NULL)
+  if (NULL != privkey)
+  {
     GNUNET_free (privkey);
-  privkey = NULL;
-  if (nsh != NULL)
+    privkey = NULL;
+  }
+  if (NULL != nsh)
+  {
     GNUNET_NAMESTORE_disconnect (nsh);
-  nsh = NULL;
+    nsh = NULL;
+  }
 }
 
 
 static void
 zone_to_name_proc (void *cls,
-                   const struct GNUNET_CRYPTO_EcdsaPublicKey *zone_key,
-                   struct GNUNET_TIME_Absolute expire,
+                   const struct GNUNET_CRYPTO_EcdsaPrivateKey *zone_key,
                    const char *n,
                    unsigned int rd_count,
-                   const struct GNUNET_GNSRECORD_Data *rd,
-                   const struct GNUNET_CRYPTO_EcdsaSignature *signature)
+                   const struct GNUNET_GNSRECORD_Data *rd)
 {
   int fail = GNUNET_NO;
 
-  if ((zone_key == NULL) && (n == NULL) && (rd_count == 0) && (rd == NULL) && (signature == NULL))
+  qe = NULL;
+  if ( (NULL == zone_key) &&
+       (NULL == n) &&
+       (0 == rd_count) &&
+       (NULL == rd) )
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "No result found\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "No result found\n");
     res = 1;
   }
   else
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Result found: `%s'\n", n);
-    if ((n == NULL) || (0 != strcmp(n, s_name)))
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Result found: `%s'\n",
+                n);
+    if ( (NULL == n) ||
+         (0 != strcmp (n,
+                       s_name)))
     {
       fail = GNUNET_YES;
       GNUNET_break (0);
     }
-    if (rd_count != 1)
+    if (1 != rd_count)
     {
       fail = GNUNET_YES;
       GNUNET_break (0);
     }
-    if ((zone_key == NULL) || (0 != memcmp (zone_key, &pubkey, sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey))))
+    if ( (NULL == zone_key) ||
+         (0 != memcmp (zone_key,
+                       privkey,
+                       sizeof (struct GNUNET_CRYPTO_EcdsaPrivateKey))))
     {
       fail = GNUNET_YES;
       GNUNET_break (0);
@@ -133,29 +145,54 @@ zone_to_name_proc (void *cls,
     else
       res = 1;
   }
-  GNUNET_SCHEDULER_add_now(&end, NULL);
+  GNUNET_SCHEDULER_add_now (&end,
+                            NULL);
 }
 
 
 static void
-put_cont (void *cls, int32_t success, const char *emsg)
+error_cb (void *cls)
+{
+  (void) cls;
+  qe = NULL;
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Not found!\n");
+  GNUNET_SCHEDULER_shutdown ();
+  res = 2;
+}
+
+
+static void
+put_cont (void *cls,
+          int32_t success,
+          const char *emsg)
 {
   char *name = cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Name store added record for `%s': %s\n", name, (success == GNUNET_OK) ? "SUCCESS" : "FAIL");
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Name store added record for `%s': %s\n",
+              name,
+              (success == GNUNET_OK) ? "SUCCESS" : emsg);
   if (success == GNUNET_OK)
   {
     res = 0;
 
-    /* create initial record */
-    GNUNET_NAMESTORE_zone_to_name (nsh, &s_zone, &s_zone_value, zone_to_name_proc, NULL);
-
+    qe = GNUNET_NAMESTORE_zone_to_name (nsh,
+                                        privkey,
+                                        &s_zone_value,
+                                        &error_cb,
+                                        NULL,
+                                        &zone_to_name_proc,
+                                        NULL);
   }
   else
   {
     res = 1;
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                "Failed to put records for name `%s'\n", name);
-    GNUNET_SCHEDULER_add_now(&end, NULL);
+                "Failed to put records for name `%s'\n",
+                name);
+    GNUNET_SCHEDULER_add_now (&end,
+                              NULL);
   }
 }
 
@@ -165,57 +202,72 @@ run (void *cls,
      const struct GNUNET_CONFIGURATION_Handle *cfg,
      struct GNUNET_TESTING_Peer *peer)
 {
-  struct GNUNET_TIME_Absolute et;
-
+  (void) cls;
+  (void) peer;
   directory = NULL;
-  GNUNET_CONFIGURATION_get_value_string(cfg, "PATHS", "GNUNET_TEST_HOME", &directory);
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                        "PATHS",
+                                                        "GNUNET_TEST_HOME",
+                                                        &directory));
   GNUNET_DISK_directory_remove (directory);
 
-  endbadly_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,endbadly, NULL);
+  endbadly_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                                &endbadly,
+                                                NULL);
+  GNUNET_SCHEDULER_add_shutdown (&end,
+                                 NULL);
   GNUNET_asprintf (&s_name, "dummy");
   /* load privat key */
-  char *hostkey_file;
-  GNUNET_asprintf(&hostkey_file,"zonefiles%s%s",DIR_SEPARATOR_STR,
-      "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using zonekey file `%s'\n",
-              hostkey_file);
-  privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file(hostkey_file);
-  GNUNET_free (hostkey_file);
-  GNUNET_assert (privkey != NULL);
+  {
+    char *zonekey_file;
+  
+    GNUNET_asprintf (&zonekey_file,
+                     "zonefiles%s%s",
+                     DIR_SEPARATOR_STR,
+                     "N0UJMP015AFUNR2BTNM3FKPBLG38913BL8IDMCO2H0A1LIB81960.zkey");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Using zonekey file `%s'\n",
+                zonekey_file);
+    privkey = GNUNET_CRYPTO_ecdsa_key_create_from_file (zonekey_file);
+    GNUNET_free (zonekey_file);
+  }
+  GNUNET_assert (NULL != privkey);
   /* get public key */
-  GNUNET_CRYPTO_ecdsa_key_get_public(privkey, &pubkey);
+  GNUNET_CRYPTO_ecdsa_key_get_public (privkey,
+                                      &pubkey);
 
-  /* zone hash */
-  GNUNET_CRYPTO_short_hash (&pubkey, sizeof (struct GNUNET_CRYPTO_EcdsaPublicKey), &s_zone);
-  GNUNET_CRYPTO_short_hash (s_name, strlen (s_name) + 1, &s_zone_value);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Using PKEY `%s' \n",
-              GNUNET_NAMESTORE_short_h2s (&s_zone_value));
-
-  struct GNUNET_GNSRECORD_Data rd;
-  rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
-  rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
-  rd.data_size = sizeof (struct GNUNET_CRYPTO_ShortHashCode);
-  rd.data = GNUNET_malloc(sizeof (struct GNUNET_CRYPTO_ShortHashCode));
-  rd.flags = 0;
-  GNUNET_memcpy ((char *) rd.data, &s_zone_value, sizeof (struct GNUNET_CRYPTO_ShortHashCode));
-  nsh = GNUNET_NAMESTORE_connect (cfg);
-  GNUNET_break (NULL != nsh);
-
-  expire = GNUNET_TIME_absolute_get ();
-  et.abs_value_us = rd.expiration_time;
-  s_signature = GNUNET_NAMESTORE_create_signature(privkey, et, s_name, &rd, 1);
-  GNUNET_NAMESTORE_record_put(nsh, &pubkey, s_name, expire, 1, &rd, s_signature, put_cont, NULL);
-
-  GNUNET_free ((void *) rd.data);
+  GNUNET_CRYPTO_random_block (GNUNET_CRYPTO_QUALITY_WEAK,
+                              &s_zone_value,
+                              sizeof (s_zone_value));
+  {
+    struct GNUNET_GNSRECORD_Data rd;
+    
+    rd.expiration_time = GNUNET_TIME_absolute_get().abs_value_us;
+    rd.record_type = GNUNET_GNSRECORD_TYPE_PKEY;
+    rd.data_size = sizeof (s_zone_value);
+    rd.data = &s_zone_value;
+    rd.flags = 0;
+    
+    nsh = GNUNET_NAMESTORE_connect (cfg);
+    GNUNET_break (NULL != nsh);
+    GNUNET_NAMESTORE_records_store (nsh,
+                                    privkey,
+                                    s_name,
+                                    1,
+                                    &rd,
+                                    &put_cont,
+                                    NULL);
+  }
 }
 
 
-
 int
-main (int argc, char *argv[])
+main (int argc,
+      char *argv[])
 {
+  (void) argc;
+  (void) argv;
   res = 1;
   if (0 !=
       GNUNET_TESTING_peer_run ("test-namestore-api-zone-to-name",
@@ -227,8 +279,8 @@ main (int argc, char *argv[])
   }
   if (NULL != directory)
   {
-      GNUNET_DISK_directory_remove (directory);
-      GNUNET_free (directory);
+    GNUNET_DISK_directory_remove (directory);
+    GNUNET_free (directory);
   }
   return res;
 }
diff --git a/src/rps/Makefile.am b/src/rps/Makefile.am
index de3469254..b5f712268 100644
--- a/src/rps/Makefile.am
+++ b/src/rps/Makefile.am
@@ -141,7 +141,9 @@ test_rps_churn_SOURCES = $(rps_test_src)
 test_rps_churn_LDADD = $(ld_rps_test_lib)
 
 gnunet_rps_profiler_SOURCES = $(rps_test_src)
-gnunet_rps_profiler_LDADD = $(ld_rps_test_lib)
+gnunet_rps_profiler_LDADD = \
+  $(top_builddir)/src/statistics/libgnunetstatistics.la \
+  $(ld_rps_test_lib)
 
 EXTRA_DIST = \
   test_rps.conf
diff --git a/src/rps/gnunet-service-rps.c b/src/rps/gnunet-service-rps.c
index ec70075cf..877893ee8 100644
--- a/src/rps/gnunet-service-rps.c
+++ b/src/rps/gnunet-service-rps.c
@@ -29,6 +29,7 @@
 #include "gnunet_cadet_service.h"
 #include "gnunet_peerinfo_service.h"
 #include "gnunet_nse_service.h"
+#include "gnunet_statistics_service.h"
 #include "rps.h"
 #include "rps-test_util.h"
 #include "gnunet-service-rps_sampler.h"
@@ -60,6 +61,11 @@
 static const struct GNUNET_CONFIGURATION_Handle *cfg;
 
 /**
+ * Handle to the statistics service.
+ */
+static struct GNUNET_STATISTICS_Handle *stats;
+
+/**
  * Our own identity.
  */
 static struct GNUNET_PeerIdentity own_identity;
@@ -2390,6 +2396,7 @@ send_pull_reply (const struct GNUNET_PeerIdentity *peer_id,
          send_size * sizeof (struct GNUNET_PeerIdentity));
 
   Peers_send_message (peer_id, ev, "PULL REPLY");
+  GNUNET_STATISTICS_update(stats, "# pull reply send issued", 1, GNUNET_NO);
 }
 
 
@@ -2961,6 +2968,7 @@ handle_peer_push (void *cls,
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Received PUSH (%s)\n",
        GNUNET_i2s (peer));
+  GNUNET_STATISTICS_update(stats, "# push messages received", 1, GNUNET_NO);
 
   #ifdef ENABLE_MALICIOUS
   struct AttackedPeer *tmp_att_peer;
@@ -3013,6 +3021,7 @@ handle_peer_pull_request (void *cls,
   const struct GNUNET_PeerIdentity *view_array;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REQUEST (%s)\n", GNUNET_i2s (peer));
+  GNUNET_STATISTICS_update(stats, "# pull request messages received", 1, GNUNET_NO);
 
   #ifdef ENABLE_MALICIOUS
   if (1 == mal_type
@@ -3096,6 +3105,7 @@ handle_peer_pull_reply (void *cls,
 #endif /* ENABLE_MALICIOUS */
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Received PULL REPLY (%s)\n", GNUNET_i2s (sender));
+  GNUNET_STATISTICS_update(stats, "# pull reply messages received", 1, GNUNET_NO);
 
   #ifdef ENABLE_MALICIOUS
   // We shouldn't even receive pull replies as we're not sending
@@ -3234,6 +3244,7 @@ send_pull_request (const struct GNUNET_PeerIdentity *peer)
 
   ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PULL_REQUEST);
   Peers_send_message (peer, ev, "PULL REQUEST");
+  GNUNET_STATISTICS_update(stats, "# pull request send issued", 1, GNUNET_NO);
 }
 
 
@@ -3253,6 +3264,7 @@ send_push (const struct GNUNET_PeerIdentity *peer_id)
 
   ev = GNUNET_MQ_msg_header (GNUNET_MESSAGE_TYPE_RPS_PP_PUSH);
   Peers_send_message (peer_id, ev, "PUSH");
+  GNUNET_STATISTICS_update(stats, "# push send issued", 1, GNUNET_NO);
 }
 
 
@@ -3554,6 +3566,7 @@ do_round (void *cls)
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Going to execute next round.\n");
+  GNUNET_STATISTICS_update(stats, "# rounds", 1, GNUNET_NO);
   do_round_task = NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Printing view:\n");
@@ -3706,6 +3719,7 @@ do_round (void *cls)
   else
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "No update of the view.\n");
+    GNUNET_STATISTICS_update(stats, "# rounds blocked", 1, GNUNET_NO);
   }
   // TODO independent of that also get some peers from CADET_get_peers()?
 
@@ -3881,6 +3895,11 @@ shutdown_task (void *cls)
   View_destroy ();
   CustomPeerMap_destroy (push_map);
   CustomPeerMap_destroy (pull_map);
+  if (NULL != stats)
+  {
+    GNUNET_STATISTICS_destroy (stats, GNUNET_NO);
+    stats = NULL;
+  }
   #ifdef ENABLE_MALICIOUS
   struct AttackedPeer *tmp_att_peer;
   GNUNET_free (file_name_view_log);
@@ -4129,6 +4148,8 @@ run (void *cls,
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Scheduled first round\n");
 
   GNUNET_SCHEDULER_add_shutdown (&shutdown_task, NULL);
+  stats = GNUNET_STATISTICS_create ("rps", cfg);
+
 }
 
 
diff --git a/src/rps/test_rps.c b/src/rps/test_rps.c
index 7d61ae6a1..c958194a8 100644
--- a/src/rps/test_rps.c
+++ b/src/rps/test_rps.c
@@ -41,6 +41,11 @@
 static uint32_t num_peers;
 
 /**
+ * How many peers are ready to shutdown?
+ */
+static uint32_t num_shutdown_ready;
+
+/**
  * How long do we run the test?
  */
 //#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30)
@@ -236,6 +241,16 @@ struct RPSPeer
    * Pending operation on that peer
    */
   const struct OpListEntry *entry_op_manage;
+
+  /**
+   * Testbed operation to connect to statistics service
+   */
+  struct GNUNET_TESTBED_Operation *stat_op;
+
+  /**
+   * Handle to the statistics service
+   */
+  struct GNUNET_STATISTICS_Handle *stats_h;
 };
 
 
@@ -318,7 +333,7 @@ typedef void (*ReplyHandle) (void *cls,
 /**
  * Called directly before disconnecting from the service
  */
-typedef void (*PostTest) (void *cls, struct GNUNET_RPS_Handle *h);
+typedef void (*PostTest) (const struct RPSPeer *peer);
 
 /**
  * Function called after disconnect to evaluate test success
@@ -355,6 +370,21 @@ enum OPTION_QUICK_QUIT {
 };
 
 /**
+ * @brief Do we collect statistics at the end?
+ */
+enum OPTION_COLLECT_STATISTICS {
+  /**
+   * @brief We collect statistics at the end
+   */
+  COLLECT_STATISTICS,
+
+  /**
+   * @brief We do not collect statistics at the end
+   */
+  NO_COLLECT_STATISTICS,
+};
+
+/**
  * Structure to define a single test
  */
 struct SingleTestRun
@@ -413,6 +443,11 @@ struct SingleTestRun
    * Quit test before timeout?
    */
   enum OPTION_QUICK_QUIT have_quick_quit;
+
+  /**
+   * Collect statistics at the end?
+   */
+  enum OPTION_COLLECT_STATISTICS have_collect_statistics;
 } cur_test_run;
 
 /**
@@ -575,9 +610,21 @@ shutdown_op (void *cls)
     churn_task = NULL;
   }
   for (i = 0; i < num_peers; i++)
+  {
     if (NULL != rps_peers[i].op)
       GNUNET_TESTBED_operation_done (rps_peers[i].op);
-  GNUNET_SCHEDULER_shutdown ();
+    if (NULL != cur_test_run.post_test)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Executing post_test for peer %u\n", i);
+      cur_test_run.post_test (&rps_peers[i]);
+    }
+  }
+  /* If we do not collect statistics, shut down directly */
+  if (NO_COLLECT_STATISTICS == cur_test_run.have_collect_statistics ||
+      num_peers <= num_shutdown_ready)
+  {
+    GNUNET_SCHEDULER_shutdown ();
+  }
 }
 
 
@@ -753,6 +800,76 @@ rps_connect_adapter (void *cls,
   return h;
 }
 
+/**
+ * Called to open a connection to the peer's statistics
+ *
+ * @param cls peer context
+ * @param cfg configuration of the peer to connect to; will be available until
+ *          GNUNET_TESTBED_operation_done() is called on the operation returned
+ *          from GNUNET_TESTBED_service_connect()
+ * @return service handle to return in 'op_result', NULL on error
+ */
+static void *
+stat_connect_adapter (void *cls,
+                      const struct GNUNET_CONFIGURATION_Handle *cfg)
+{
+  struct RPSPeer *peer = cls;
+
+  peer->stats_h = GNUNET_STATISTICS_create ("rps-profiler", cfg);
+  return peer->stats_h;
+}
+
+/**
+ * Called to disconnect from peer's statistics service
+ *
+ * @param cls peer context
+ * @param op_result service handle returned from the connect adapter
+ */
+static void
+stat_disconnect_adapter (void *cls, void *op_result)
+{
+  struct RPSPeer *peer = cls;
+
+  //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
+  //              (peer->stats_h, "core", "# peers connected",
+  //               stat_iterator, peer));
+  //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch_cancel
+  //              (peer->stats_h, "nse", "# peers connected",
+  //               stat_iterator, peer));
+  GNUNET_STATISTICS_destroy (op_result, GNUNET_NO);
+  peer->stats_h = NULL;
+}
+
+/**
+ * Called after successfully opening a connection to a peer's statistics
+ * service; we register statistics monitoring for CORE and NSE here.
+ *
+ * @param cls the callback closure from functions generating an operation
+ * @param op the operation that has been finished
+ * @param ca_result the service handle returned from GNUNET_TESTBED_ConnectAdapter()
+ * @param emsg error message in case the operation has failed; will be NULL if
+ *          operation has executed successfully.
+ */
+static void
+stat_complete_cb (void *cls, struct GNUNET_TESTBED_Operation *op,
+                  void *ca_result, const char *emsg )
+{
+  //struct GNUNET_STATISTICS_Handle *sh = ca_result;
+  //struct RPSPeer *peer = (struct RPSPeer *) cls;
+
+  if (NULL != emsg)
+  {
+    GNUNET_break (0);
+    return;
+  }
+  //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
+  //              (sh, "core", "# peers connected",
+  //               stat_iterator, peer));
+  //GNUNET_break (GNUNET_OK == GNUNET_STATISTICS_watch
+  //              (sh, "nse", "# peers connected",
+  //               stat_iterator, peer));
+}
+
 
 /**
  * Adapter function called to destroy connection to
@@ -1541,6 +1658,71 @@ profiler_eval (void)
   return evaluate ();
 }
 
+/**
+ * Continuation called by #GNUNET_STATISTICS_get() functions.
+ *
+ * Checks whether all peers received their statistics yet.
+ * Issues the shutdown.
+ *
+ * @param cls closure
+ * @param success #GNUNET_OK if statistics were
+ *        successfully obtained, #GNUNET_SYSERR if not.
+ */
+void
+post_test_shutdown_ready_cb (void *cls,
+                             int success)
+{
+  const struct RPSPeer *rps_peer = (const struct RPSPeer *) cls;
+  if (NULL != rps_peer->stat_op)
+  {
+    GNUNET_TESTBED_operation_done (rps_peer->stat_op);
+  }
+  num_shutdown_ready++;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+      "%" PRIu32 " of %" PRIu32 " Peers are ready to shut down\n",
+      num_shutdown_ready,
+      num_peers);
+  if (num_peers <= num_shutdown_ready)
+  {
+    GNUNET_SCHEDULER_shutdown ();
+  }
+}
+
+/**
+ * Callback function to process statistic values.
+ *
+ * @param cls closure
+ * @param subsystem name of subsystem that created the statistic
+ * @param name the name of the datum
+ * @param value the current value
+ * @param is_persistent #GNUNET_YES if the value is persistent, #GNUNET_NO if not
+ * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
+ */
+int
+stat_iterator (void *cls,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
+{
+  //const struct RPSPeer *rps_peer = (const struct RPSPeer *) cls;
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Got stat value: %" PRIu64 "\n", value);
+  return GNUNET_OK;
+}
+
+void post_profiler (const struct RPSPeer *rps_peer)
+{
+  if (COLLECT_STATISTICS == cur_test_run.have_collect_statistics)
+  {
+    GNUNET_STATISTICS_get (rps_peer->stats_h,
+                           "rps",
+                           "# rounds",
+                           post_test_shutdown_ready_cb,
+                           stat_iterator,
+                           (struct RPSPeer *) rps_peer);
+  }
+}
+
 
 /***********************************************************************
  * /Definition of tests
@@ -1623,6 +1805,19 @@ run (void *cls,
                                         &rps_disconnect_adapter,
                                         &rps_peers[i]);
     }
+    /* Connect all peers to statistics service */
+    if (COLLECT_STATISTICS == cur_test_run.have_collect_statistics)
+    {
+      rps_peers[i].stat_op =
+        GNUNET_TESTBED_service_connect (NULL,
+                                        peers[i],
+                                        "statistics",
+                                        stat_complete_cb,
+                                        &rps_peers[i],
+                                        &stat_connect_adapter,
+                                        &stat_disconnect_adapter,
+                                        &rps_peers[i]);
+    }
   }
 
   if (NULL != churn_task)
@@ -1644,12 +1839,15 @@ main (int argc, char *argv[])
   int ret_value;
 
   num_peers = 5;
+  num_shutdown_ready = 0;
   cur_test_run.name = "test-rps-default";
   cur_test_run.init_peer = default_init_peer;
   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.post_test = NULL;
   cur_test_run.have_churn = HAVE_CHURN;
+  cur_test_run.have_collect_statistics = NO_COLLECT_STATISTICS;
   churn_task = NULL;
   timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 30);
 
@@ -1767,10 +1965,12 @@ main (int argc, char *argv[])
     cur_test_run.main_test = profiler_cb;
     cur_test_run.reply_handle = profiler_reply_handle;
     cur_test_run.eval_cb = profiler_eval;
+    cur_test_run.post_test = post_profiler;
     cur_test_run.request_interval = 2;
     cur_test_run.num_requests = 5;
     cur_test_run.have_churn = HAVE_CHURN;
     cur_test_run.have_quick_quit = HAVE_NO_QUICK_QUIT;
+    cur_test_run.have_collect_statistics = COLLECT_STATISTICS;
     timeout = GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300);
 
     /* 'Clean' directory */
diff --git a/src/util/scheduler.c b/src/util/scheduler.c
index e92405a96..1e52dce9f 100644
--- a/src/util/scheduler.c
+++ b/src/util/scheduler.c
@@ -424,7 +424,7 @@ get_timeout ()
   {
     if (0 != pos->reason)
     {
-      timeout = now;
+      return now;
     }
     else
     {
@@ -435,7 +435,7 @@ get_timeout ()
   {
     if (0 != pos->reason)
     {
-      timeout = now;
+      return now;
     }
     else if ((pos->timeout.abs_value_us != GNUNET_TIME_UNIT_FOREVER_ABS.abs_value_us) &&
              (timeout.abs_value_us > pos->timeout.abs_value_us))
@@ -994,7 +994,7 @@ GNUNET_SCHEDULER_add_with_reason_and_priority (GNUNET_SCHEDULER_TaskCallback tas
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->reason = reason;
-  t->priority = priority;
+  t->priority = check_priority (priority);
   t->lifeness = current_lifeness;
   LOG (GNUNET_ERROR_TYPE_DEBUG,
        "Adding continuation task %p\n",
@@ -1036,7 +1036,7 @@ GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
   t->start_time = GNUNET_TIME_absolute_get ();
 #endif
   t->timeout = at;
-  t->priority = priority;
+  t->priority = check_priority (priority);
   t->lifeness = current_lifeness;
   /* try tail first (optimization in case we are
    * appending to a long list of tasks with timeouts) */
@@ -1095,8 +1095,8 @@ GNUNET_SCHEDULER_add_at_with_priority (struct GNUNET_TIME_Absolute at,
  */
 struct GNUNET_SCHEDULER_Task *
 GNUNET_SCHEDULER_add_delayed_with_priority (struct GNUNET_TIME_Relative delay,
-              enum GNUNET_SCHEDULER_Priority priority,
-              GNUNET_SCHEDULER_TaskCallback task,
+                                            enum GNUNET_SCHEDULER_Priority priority,
+                                            GNUNET_SCHEDULER_TaskCallback task,
                                             void *task_cls)
 {
   return GNUNET_SCHEDULER_add_at_with_priority (GNUNET_TIME_relative_to_absolute (delay),
@@ -1839,12 +1839,8 @@ GNUNET_SCHEDULER_task_ready (struct GNUNET_SCHEDULER_Task *task,
                              struct GNUNET_SCHEDULER_FdInfo *fdi)
 {
   enum GNUNET_SCHEDULER_Reason reason;
-  struct GNUNET_TIME_Absolute now;
 
-  now = GNUNET_TIME_absolute_get ();
   reason = task->reason;
-  if (now.abs_value_us >= task->timeout.abs_value_us)
-    reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
   if ( (0 == (reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
        (0 != (GNUNET_SCHEDULER_ET_IN & fdi->et)) )
     reason |= GNUNET_SCHEDULER_REASON_READ_READY;
@@ -1889,8 +1885,10 @@ GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
 
   /* check for tasks that reached the timeout! */
   now = GNUNET_TIME_absolute_get ();
-  while (NULL != (pos = pending_timeout_head))
+  pos = pending_timeout_head;
+  while (NULL != pos)
   {
+    struct GNUNET_SCHEDULER_Task *next = pos->next;
     if (now.abs_value_us >= pos->timeout.abs_value_us)
       pos->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT;
     if (0 == pos->reason)
@@ -1901,6 +1899,7 @@ GNUNET_SCHEDULER_run_from_driver (struct GNUNET_SCHEDULER_Handle *sh)
     if (pending_timeout_last == pos)
       pending_timeout_last = NULL;
     queue_ready_task (pos);
+    pos = next;
   }
   pos = pending_head;
   while (NULL != pos)
@@ -2276,24 +2275,27 @@ select_loop (void *cls,
       GNUNET_NETWORK_fdset_destroy (ws);
       return GNUNET_SYSERR;
     }
-    for (pos = context->scheduled_head; NULL != pos; pos = pos->next)
+    if (select_result > 0)
     {
-      int is_ready = GNUNET_NO;
-      if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et) &&
-          GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, pos->fdi->sock))
-      {
-        pos->fdi->et |= GNUNET_SCHEDULER_ET_IN;
-        is_ready = GNUNET_YES;
-      }
-      if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et) &&
-          GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, pos->fdi->sock))
+      for (pos = context->scheduled_head; NULL != pos; pos = pos->next)
       {
-        pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT;
-        is_ready = GNUNET_YES;
-      }
-      if (GNUNET_YES == is_ready)
-      {
-        GNUNET_SCHEDULER_task_ready (pos->task, pos->fdi);
+        int is_ready = GNUNET_NO;
+        if (0 != (GNUNET_SCHEDULER_ET_IN & pos->et) &&
+            GNUNET_YES == GNUNET_NETWORK_fdset_test_native (rs, pos->fdi->sock))
+        {
+          pos->fdi->et |= GNUNET_SCHEDULER_ET_IN;
+          is_ready = GNUNET_YES;
+        }
+        if (0 != (GNUNET_SCHEDULER_ET_OUT & pos->et) &&
+            GNUNET_YES == GNUNET_NETWORK_fdset_test_native (ws, pos->fdi->sock))
+        {
+          pos->fdi->et |= GNUNET_SCHEDULER_ET_OUT;
+          is_ready = GNUNET_YES;
+        }
+        if (GNUNET_YES == is_ready)
+        {
+          GNUNET_SCHEDULER_task_ready (pos->task, pos->fdi);
+        }
       }
     }
     tasks_ready = GNUNET_SCHEDULER_run_from_driver (sh);
@@ -2306,8 +2308,8 @@ select_loop (void *cls,
 
 
 void
-select_set_wakeup(void *cls,
-                  struct GNUNET_TIME_Absolute dt)
+select_set_wakeup (void *cls,
+                   struct GNUNET_TIME_Absolute dt)
 {
   struct DriverContext *context = cls;
   GNUNET_assert (NULL != context);