9 files changed, 629 insertions, 117 deletions

diff --git a/contrib/Makefile.am b/contrib/Makefile.am
index 1e348233d..158e43998 100644
--- a/contrib/Makefile.am
+++ b/contrib/Makefile.am
@@ -87,8 +87,6 @@ do_subst = $(SED) -e 's,[@]PYTHON[@],$(PYTHON),g'
 #       chmod +x $@
 #
 # instead of this:
-
-SUFFIXES =
 SUFFIXES = .py.in .py
 
 .py.in.py:
diff --git a/doc/man/gnunet-statistics.1 b/doc/man/gnunet-statistics.1
index 36f445a09..2aa889382 100644
--- a/doc/man/gnunet-statistics.1
+++ b/doc/man/gnunet-statistics.1
@@ -41,6 +41,13 @@ non\-persistent.
 Statistics are kept for various subsystems.  With this option, the
 output can be restricted to a particular subsystem only.
 .B
+.IP "\-S SEPARATOR,  \-\-csv-separator=SEPARATOR"
+Specify a separator for generating csv-output.
+.B
+.IP "\-t TESTBED_PATH,  \-\-subsystem=TESTBED_PATH"
+When running testbed, you can get statistics of all peers with specefying the
+folder containing the data of all testbed nodes like \fBgnunet\-statistics -t /tmp/testbedARtmQv\fP.
+.B
 .IP "\-v, \-\-version"
 Print GNUnet version number.
 
diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c
index 6924ca676..b56c9c0a8 100644
--- a/src/arm/gnunet-service-arm.c
+++ b/src/arm/gnunet-service-arm.c
@@ -346,11 +346,15 @@ get_server_addresses (const char *service_name,
   *addrs = NULL;
   *addr_lens = NULL;
   desc = NULL;
-  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6"))
+  if (GNUNET_CONFIGURATION_have_value (cfg,
+                                       service_name,
+                                       "DISABLEV6"))
   {
     if (GNUNET_SYSERR ==
         (disablev6 =
-         GNUNET_CONFIGURATION_get_value_yesno (cfg, service_name, "DISABLEV6")))
+         GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                               service_name,
+                                               "DISABLEV6")))
       return GNUNET_SYSERR;
   }
   else
@@ -359,18 +363,24 @@ get_server_addresses (const char *service_name,
   if (! disablev6)
   {
     /* probe IPv6 support */
-    desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0);
+    desc = GNUNET_NETWORK_socket_create (PF_INET6,
+                                         SOCK_STREAM,
+                                         0);
     if (NULL == desc)
     {
-      if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
-          (EACCES == errno))
+      if ( (ENOBUFS == errno) ||
+           (ENOMEM == errno) ||
+           (ENFILE == errno) ||
+           (EACCES == errno) )
       {
-        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
+        LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR,
+                      "socket");
         return GNUNET_SYSERR;
       }
       LOG (GNUNET_ERROR_TYPE_INFO,
            _("Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"),
-           service_name, STRERROR (errno));
+           service_name,
+           STRERROR (errno));
       disablev6 = GNUNET_YES;
     }
     else
@@ -381,11 +391,15 @@ get_server_addresses (const char *service_name,
   }
 
   port = 0;
-  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT"))
+  if (GNUNET_CONFIGURATION_have_value (cfg,
+                                       service_name,
+                                       "PORT"))
   {
     if (GNUNET_OK !=
-        GNUNET_CONFIGURATION_get_value_number (cfg, service_name,
-                                               "PORT", &port))
+        GNUNET_CONFIGURATION_get_value_number (cfg,
+                                               service_name,
+                                               "PORT",
+                                               &port))
     {
       LOG (GNUNET_ERROR_TYPE_ERROR,
            _("Require valid port number for service `%s' in configuration!\n"),
@@ -400,11 +414,15 @@ get_server_addresses (const char *service_name,
     }
   }
 
-  if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO"))
+  if (GNUNET_CONFIGURATION_have_value (cfg,
+                                       service_name,
+                                       "BINDTO"))
   {
     GNUNET_break (GNUNET_OK ==
-                  GNUNET_CONFIGURATION_get_value_string (cfg, service_name,
-                                                         "BINDTO", &hostname));
+                  GNUNET_CONFIGURATION_get_value_string (cfg,
+                                                         service_name,
+                                                         "BINDTO",
+                                                         &hostname));
   }
   else
     hostname = NULL;
@@ -413,10 +431,14 @@ get_server_addresses (const char *service_name,
   abstract = GNUNET_NO;
 #ifdef AF_UNIX
   if ((GNUNET_YES ==
-       GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) &&
+       GNUNET_CONFIGURATION_have_value (cfg,
+                                        service_name,
+                                        "UNIXPATH")) &&
       (GNUNET_OK ==
-       GNUNET_CONFIGURATION_get_value_filename (cfg, service_name, "UNIXPATH",
-                                              &unixpath)) &&
+       GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                                service_name,
+                                                "UNIXPATH",
+                                                &unixpath)) &&
       (0 < strlen (unixpath)))
   {
     /* probe UNIX support */
@@ -425,7 +447,8 @@ get_server_addresses (const char *service_name,
     if (strlen (unixpath) >= sizeof (s_un.sun_path))
     {
       LOG (GNUNET_ERROR_TYPE_WARNING,
-           _("UNIXPATH `%s' too long, maximum length is %llu\n"), unixpath,
+           _("UNIXPATH `%s' too long, maximum length is %llu\n"),
+           unixpath,
            (unsigned long long) sizeof (s_un.sun_path));
       unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath);
       LOG (GNUNET_ERROR_TYPE_INFO,
@@ -439,9 +462,9 @@ get_server_addresses (const char *service_name,
     if (GNUNET_SYSERR == abstract)
       abstract = GNUNET_NO;
 #endif
-    if ((GNUNET_YES != abstract)
-        && (GNUNET_OK !=
-            GNUNET_DISK_directory_create_for_file (unixpath)))
+    if ( (GNUNET_YES != abstract) &&
+         (GNUNET_OK !=
+          GNUNET_DISK_directory_create_for_file (unixpath)) ) 
       GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR,
                                 "mkdir",
                                 unixpath);
@@ -451,8 +474,10 @@ get_server_addresses (const char *service_name,
     desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0);
     if (NULL == desc)
     {
-      if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) ||
-          (EACCES == errno))
+      if ( (ENOBUFS == errno) ||
+           (ENOMEM == errno) ||
+           (ENFILE == errno) ||
+           (EACCES == errno) )
       {
         LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket");
         GNUNET_free_non_null (hostname);
@@ -474,19 +499,29 @@ get_server_addresses (const char *service_name,
   }
 #endif
 
-  if ((0 == port) && (NULL == unixpath))
+  if ( (0 == port) &&
+       (NULL == unixpath) )
   {
-    LOG (GNUNET_ERROR_TYPE_ERROR,
-         _("Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
-         service_name);
+    if (GNUNET_YES ==
+        GNUNET_CONFIGURATION_get_value_yesno (cfg,
+                                              service_name,
+                                              "AUTOSTART"))
+      LOG (GNUNET_ERROR_TYPE_ERROR,
+           _("Have neither PORT nor UNIXPATH for service `%s', but one is required\n"),
+           service_name);
     GNUNET_free_non_null (hostname);
     return GNUNET_SYSERR;
   }
   if (0 == port)
   {
-    saddrs = GNUNET_malloc (2 * sizeof (struct sockaddr *));
-    saddrlens = GNUNET_malloc (2 * sizeof (socklen_t));
-    add_unixpath (saddrs, saddrlens, unixpath, abstract);
+    saddrs = GNUNET_new_array (2,
+                               struct sockaddr *);
+    saddrlens = GNUNET_new_array (2,
+                                  socklen_t);
+    add_unixpath (saddrs,
+                  saddrlens,
+                  unixpath,
+                  abstract);
     GNUNET_free_non_null (unixpath);
     GNUNET_free_non_null (hostname);
     *addrs = saddrs;
@@ -504,7 +539,10 @@ get_server_addresses (const char *service_name,
     if (disablev6)
       hints.ai_family = AF_INET;
     hints.ai_protocol = IPPROTO_TCP;
-    if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) ||
+    if ((0 != (ret = getaddrinfo (hostname,
+                                  NULL,
+                                  &hints,
+                                  &res))) ||
         (NULL == res))
     {
       LOG (GNUNET_ERROR_TYPE_ERROR,
@@ -538,8 +576,10 @@ get_server_addresses (const char *service_name,
     resi = i;
     if (NULL != unixpath)
       resi++;
-    saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
-    saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+    saddrs = GNUNET_new_array (resi + 1,
+                               struct sockaddr *);
+    saddrlens = GNUNET_new_array (resi + 1,
+                                  socklen_t);
     i = 0;
     if (NULL != unixpath)
     {
@@ -591,8 +631,10 @@ get_server_addresses (const char *service_name,
       if (NULL != unixpath)
         resi++;
       i = 0;
-      saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
-      saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+      saddrs = GNUNET_new_array (resi + 1,
+                                 struct sockaddr *);
+      saddrlens = GNUNET_new_array (resi + 1,
+                                    socklen_t);
       if (NULL != unixpath)
       {
         add_unixpath (saddrs, saddrlens, unixpath, abstract);
@@ -612,12 +654,17 @@ get_server_addresses (const char *service_name,
       resi = 2;
       if (NULL != unixpath)
         resi++;
-      saddrs = GNUNET_malloc ((resi + 1) * sizeof (struct sockaddr *));
-      saddrlens = GNUNET_malloc ((resi + 1) * sizeof (socklen_t));
+      saddrs = GNUNET_new_array (resi + 1,
+                                 struct sockaddr *);
+      saddrlens = GNUNET_new_array (resi + 1,
+                                    socklen_t);
       i = 0;
       if (NULL != unixpath)
       {
-        add_unixpath (saddrs, saddrlens, unixpath, abstract);
+        add_unixpath (saddrs,
+                      saddrlens,
+                      unixpath,
+                      abstract);
         i++;
       }
       saddrlens[i] = sizeof (struct sockaddr_in6);
@@ -663,6 +710,7 @@ signal_result (struct GNUNET_SERVICE_Client *client,
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_ARM_ResultMessage *msg;
 
+  (void) name;
   env = GNUNET_MQ_msg (msg,
                        GNUNET_MESSAGE_TYPE_ARM_RESULT);
   msg->result = htonl (result);
@@ -1184,6 +1232,7 @@ check_start (void *cls,
   uint16_t size;
   const char *servicename;
 
+  (void) cls;
   size = ntohs (amsg->header.size) - sizeof (struct GNUNET_ARM_Message);
   servicename = (const char *) &amsg[1];
   if ( (0 == size) ||
@@ -1254,6 +1303,7 @@ handle_start (void *cls,
 static void
 trigger_shutdown (void *cls)
 {
+  (void) cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Triggering shutdown\n");
   GNUNET_SCHEDULER_shutdown ();
@@ -1275,6 +1325,7 @@ check_stop (void *cls,
   uint16_t size;
   const char *servicename;
 
+  (void) cls;
   size = ntohs (amsg->header.size) - sizeof (struct GNUNET_ARM_Message);
   servicename = (const char *) &amsg[1];
   if ( (0 == size) ||
@@ -1451,6 +1502,7 @@ handle_test (void *cls,
   struct GNUNET_MQ_Envelope *env;
   struct GNUNET_MessageHeader *msg;
 
+  (void) message;
   env = GNUNET_MQ_msg (msg,
                        GNUNET_MESSAGE_TYPE_ARM_TEST);
   GNUNET_MQ_send (GNUNET_SERVICE_client_get_mq (client),
@@ -1498,7 +1550,7 @@ list_count (struct ServiceList *running_head)
   struct ServiceList *i;
   unsigned int res;
 
-  for (res = 0, i = running_head; i; i = i->next, res++)
+  for (res = 0, i = running_head; NULL != i; i = i->next, res++)
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                 "%s\n",
                 i->name);
@@ -1518,6 +1570,7 @@ shutdown_task (void *cls)
   struct ServiceList *nxt;
   struct ServiceListeningInfo *sli;
 
+  (void) cls;
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "First shutdown phase\n");
   if (NULL != child_restart_task)
@@ -1589,6 +1642,7 @@ delayed_restart_task (void *cls)
   struct GNUNET_TIME_Relative lowestRestartDelay;
   struct ServiceListeningInfo *sli;
 
+  (void) cls;
   child_restart_task = NULL;
   GNUNET_assert (GNUNET_NO == in_shutdown);
   lowestRestartDelay = GNUNET_TIME_UNIT_FOREVER_REL;
@@ -1656,7 +1710,7 @@ delayed_restart_task (void *cls)
  * Task triggered whenever we receive a SIGCHLD (child
  * process died).
  *
- * @param cls closure, NULL if we need to self-restart
+ * @param cls closure, NULL 
  */
 static void
 maint_child_death (void *cls)
@@ -1672,6 +1726,7 @@ maint_child_death (void *cls)
   unsigned long statusCode;
   const struct GNUNET_DISK_FileHandle *pr;
 
+  (void) cls;
   pr = GNUNET_DISK_pipe_handle (sigpipe,
                                 GNUNET_DISK_PIPE_END_READ);
   child_death_task = NULL;
@@ -1914,6 +1969,7 @@ setup_service (void *cls,
   socklen_t *addr_lens;
   int ret;
 
+  (void) cls;
   if (0 == strcasecmp (section,
                        "arm"))
     return;
@@ -2024,7 +2080,7 @@ setup_service (void *cls,
                                         &addr_lens)))
     return;
   /* this will free (or capture) addrs[i] */
-  for (unsigned int i = 0; i < ret; i++)
+  for (unsigned int i = 0; i < (unsigned int) ret; i++)
     create_listen_socket (addrs[i],
                           addr_lens[i],
                           sl);
@@ -2049,6 +2105,8 @@ client_connect_cb (void *cls,
   /* All clients are considered to be of the "monitor" kind
    * (that is, they don't affect ARM shutdown).
    */
+  (void) cls;
+  (void) mq;
   GNUNET_SERVICE_client_mark_monitor (client);
   return client;
 }
@@ -2066,11 +2124,9 @@ client_disconnect_cb (void *cls,
                       struct GNUNET_SERVICE_Client *client,
                       void *app_ctx)
 {
-  struct ServiceList *sl;
-
+  (void) cls;
   GNUNET_assert (client == app_ctx);
-
-  for (sl = running_head; NULL != sl; sl = sl->next)
+  for (struct ServiceList *sl = running_head; NULL != sl; sl = sl->next)
     if (sl->killing_client == client)
       sl->killing_client = NULL;
 }
@@ -2090,6 +2146,7 @@ handle_monitor (void *cls,
 {
   struct GNUNET_SERVICE_Client *client = cls;
 
+  (void) message;
   /* FIXME: might want to start by letting monitor know about
      services that are already running */
   /* Removal is handled by the server implementation, internally. */
@@ -2105,7 +2162,7 @@ handle_monitor (void *cls,
 /**
  * Process arm requests.
  *
- * @param cls closure
+ * @param cls closure, NULL
  * @param serv the initialized service
  * @param c configuration to use
  */
@@ -2116,6 +2173,7 @@ run (void *cls,
 {
   struct ServiceList *sl;
 
+  (void) cls;
   cfg = c;
   service = serv;
   GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
diff --git a/src/dns/gnunet-service-dns.c b/src/dns/gnunet-service-dns.c
index c191f0531..6b75fd0f4 100644
--- a/src/dns/gnunet-service-dns.c
+++ b/src/dns/gnunet-service-dns.c
@@ -1097,7 +1097,10 @@ run (void *cls,
 
   helper_argv[0] = GNUNET_strdup ("gnunet-dns");
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string (cfg, "dns", "IFNAME", &ifc_name))
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "dns",
+                                             "IFNAME",
+                                             &ifc_name))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
                 "No entry 'IFNAME' in configuration!\n");
@@ -1106,7 +1109,9 @@ run (void *cls,
   }
   helper_argv[1] = ifc_name;
   if ( (GNUNET_SYSERR ==
-        GNUNET_CONFIGURATION_get_value_string (cfg, "dns", "IPV6ADDR",
+        GNUNET_CONFIGURATION_get_value_string (cfg,
+                                               "dns",
+                                               "IPV6ADDR",
                                                &ipv6addr)) )
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -1116,7 +1121,9 @@ run (void *cls,
   }
   helper_argv[2] = ipv6addr;
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string (cfg, "dns", "IPV6PREFIX",
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "dns",
+                                             "IPV6PREFIX",
                                              &ipv6prefix))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -1127,7 +1134,9 @@ run (void *cls,
   helper_argv[3] = ipv6prefix;
 
   if (GNUNET_SYSERR ==
-      GNUNET_CONFIGURATION_get_value_string (cfg, "dns", "IPV4ADDR",
+      GNUNET_CONFIGURATION_get_value_string (cfg,
+                                             "dns",
+                                             "IPV4ADDR",
                                              &ipv4addr))
   {
     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
diff --git a/src/gns/gns.conf.in b/src/gns/gns.conf.in
index f7682cda7..de50d1047 100644
--- a/src/gns/gns.conf.in
+++ b/src/gns/gns.conf.in
@@ -20,7 +20,7 @@ MAX_PARALLEL_BACKGROUND_QUERIES = 1000
 # we will ask gnunet-service-dns to pass DNS queries to us. Otherwise,
 # we only answer GNS queries via the API (which itself may be
 # called via NSS or other mechanisms).
-INTERCEPT_DNS = YES
+INTERCEPT_DNS = NO
 
 # PREFIX = valgrind --leak-check=full --track-origins=yes
 
diff --git a/src/gns/gnunet-gns-proxy.c b/src/gns/gnunet-gns-proxy.c
index 9a405c49b..9c3c78b76 100644
--- a/src/gns/gnunet-gns-proxy.c
+++ b/src/gns/gnunet-gns-proxy.c
@@ -1,6 +1,6 @@
 /*
      This file is part of GNUnet.
-     Copyright (C) 2012-2014 GNUnet e.V.
+     Copyright (C) 2012-2018 GNUnet e.V.
 
      GNUnet is free software: you can redistribute it and/or modify it
      under the terms of the GNU Affero General Public License as published
@@ -46,14 +46,6 @@
 #include "gns.h"
 
 
-/**
- * FIXME: GnuTLS right now sometimes rejects valid certs, so as a
- * VERY temporary workaround we just WARN the user instead of 
- * dropping the page.  THIS SHOULD NOT BE USED IN PRODUCTION,
- * set to 1 in production!!! FIXME!!!
- */
-#define FIXED_CERT_VALIDATION_BUG 0
-
 
 /**
  * Default Socks5 listen port.
@@ -1079,10 +1071,8 @@ check_ssl_certificate (struct Socks5Request *s5r)
                     certdn,
                     name,
                     rc);
-#if FIXED_CERT_VALIDATION_BUG
         gnutls_x509_crt_deinit (x509_cert);
         return GNUNET_SYSERR;
-#endif
       }
     }
     else
@@ -1197,6 +1187,15 @@ curl_check_hdr (void *buffer,
                              s5r->domain);
           continue;
         }
+        else if ( ('.' == cookie_domain[0]) &&
+                  (0 == strcmp (&cookie_domain[1],
+                                s5r->leho)) )
+        {
+          offset += sprintf (new_cookie_hdr + offset,
+                             " domain=.%s;",
+                             s5r->domain);
+          continue;
+        }
         GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                     _("Cookie domain `%s' supplied by server is invalid\n"),
                     tok);
@@ -1996,7 +1995,8 @@ create_response (void *cls,
         us = MHD_lookup_connection_value (con,
                                           MHD_HEADER_KIND,
                                           MHD_HTTP_HEADER_CONTENT_LENGTH);
-        if ( (NULL != us) && (1 == sscanf (us,
+        if ( (NULL != us) &&
+             (1 == sscanf (us,
                            "%ld",
                            &upload_size)) &&
              (upload_size >= 0) )
@@ -2041,6 +2041,20 @@ create_response (void *cls,
                         CURLOPT_WRITEDATA,
                         s5r);
     }
+    else if (0 == strcasecmp (meth,
+                              MHD_HTTP_METHOD_DELETE))
+    {
+      s5r->state = SOCKS5_SOCKET_DOWNLOAD_STARTED;
+      curl_easy_setopt (s5r->curl,
+                        CURLOPT_CUSTOMREQUEST,
+                        "DELETE");
+      curl_easy_setopt (s5r->curl,
+                        CURLOPT_WRITEFUNCTION,
+                        &curl_download_cb);
+      curl_easy_setopt (s5r->curl,
+                        CURLOPT_WRITEDATA,
+                        s5r);
+    }
     else
     {
       GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
diff --git a/src/gns/gnunet-service-gns_resolver.c b/src/gns/gnunet-service-gns_resolver.c
index 54c3cba23..67960ef97 100644
--- a/src/gns/gnunet-service-gns_resolver.c
+++ b/src/gns/gnunet-service-gns_resolver.c
@@ -2397,6 +2397,8 @@ handle_dht_response (void *cls,
                 "Received expired block from the DHT, will not cache it.\n");
     return;
   }
+  if (GNUNET_YES == disable_cache)
+    return;
   /* Cache well-formed blocks */
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "Caching response from the DHT in namecache\n");
@@ -2407,7 +2409,7 @@ handle_dht_response (void *cls,
                                                          co);
   GNUNET_CONTAINER_DLL_insert (co_head,
                                co_tail,
-                               co);
+                               co);  
 }
 
 
diff --git a/src/psyc/Makefile.am b/src/psyc/Makefile.am
index 61618d176..26db608f3 100644
--- a/src/psyc/Makefile.am
+++ b/src/psyc/Makefile.am
@@ -58,13 +58,13 @@ AM_TESTS_ENVIRONMENT=export GNUNET_PREFIX=$${GNUNET_PREFIX:-@libdir@};export PAT
 TESTS = $(check_PROGRAMS)
 endif
 
-test_psyc_SOURCES = \
- test_psyc.c
-test_psyc_LDADD = \
-  libgnunetpsyc.la \
-  $(top_builddir)/src/psycutil/libgnunetpsycutil.la \
-  $(top_builddir)/src/testing/libgnunettesting.la \
-  $(top_builddir)/src/util/libgnunetutil.la
+#test_psyc_SOURCES = \
+# test_psyc.c
+#test_psyc_LDADD = \
+#  libgnunetpsyc.la \
+#  $(top_builddir)/src/psycutil/libgnunetpsycutil.la \
+#  $(top_builddir)/src/testing/libgnunettesting.la \
+#  $(top_builddir)/src/util/libgnunetutil.la
 test_psyc2_SOURCES = \
   test_psyc2.c
 test_psyc2_LDADD = \
diff --git a/src/statistics/gnunet-statistics.c b/src/statistics/gnunet-statistics.c
index 648fc89bb..9093336e1 100644
--- a/src/statistics/gnunet-statistics.c
+++ b/src/statistics/gnunet-statistics.c
@@ -39,6 +39,11 @@ static int ret;
 static char *subsystem;
 
 /**
+ * The path of the testbed data.
+ */
+static char *path_testbed;
+
+/**
  * Set to the specific stat value that we are after (or NULL for all).
  */
 static char *name;
@@ -59,6 +64,11 @@ static int watch;
 static int quiet;
 
 /**
+ * @brief Separator string for csv.
+ */
+static char *csv_separator;
+
+/**
  * Remote host
  */
 static char *remote_host;
@@ -79,10 +89,200 @@ static unsigned long long set_val;
 static int set_value;
 
 /**
- * Handle for pending GET operation.
+ * @brief Representation of all (testbed) nodes.
+ */
+static struct Node {
+  /**
+   * @brief Index of the node in this array.
+   */
+  unsigned index_node;
+
+  /**
+   * @brief Configuration handle for this node
+   */
+  struct GNUNET_CONFIGURATION_Handle *conf;
+
+  /**
+   * Handle for pending GET operation.
+   */
+  struct GNUNET_STATISTICS_GetHandle *gh;
+
+  /**
+   * @brief Statistics handle nodes.
+   */
+  struct GNUNET_STATISTICS_Handle *handle;
+  /**
+   * @brief Identifier for shutdown task for this node.
+   */
+  struct GNUNET_SCHEDULER_Task *shutdown_task;
+} *nodes;
+
+/**
+ * @brief Number of configurations of all (testbed) nodes.
+ */
+static unsigned num_nodes;
+
+/**
+ * @brief Set of values for a combination of subsystem and name.
+ */
+struct ValueSet
+{
+  /**
+   * @brief Subsystem of the valueset.
+   */
+  char *subsystem;
+
+  /**
+   * @brief Name of the valueset.
+   */
+  char *name;
+
+  /**
+   * @brief The values.
+   */
+  uint64_t *values;
+
+  /**
+   * @brief Persistence of the values.
+   */
+  int is_persistent;
+};
+
+/**
+ * @brief Collection of all values (represented with #ValueSet).
+ */
+static struct GNUNET_CONTAINER_MultiHashMap *values;
+
+/**
+ * @brief Number of nodes that have their values ready.
+ */
+static int num_nodes_ready;
+
+/**
+ * @brief Create a new #ValueSet
+ *
+ * @param subsystem Subsystem of the valueset.
+ * @param name Name of the valueset.
+ * @param num_values Number of values in valueset - number of peers.
+ * @param is_persistent Persistence status of values.
+ *
+ * @return Newly allocated #ValueSet.
+ */
+static struct ValueSet *
+new_value_set (const char *subsystem,
+               const char *name,
+               unsigned num_values,
+               int is_persistent)
+{
+  struct ValueSet *value_set;
+
+  value_set = GNUNET_new (struct ValueSet);
+  value_set->subsystem = GNUNET_strdup (subsystem);
+  value_set->name = GNUNET_strdup (name);
+  value_set->values = GNUNET_new_array (num_values, uint64_t);
+  value_set->is_persistent = persistent;
+  return value_set;
+}
+
+/**
+ * @brief Print the (collected) values.
+ *
+ * Implements #GNUNET_CONTAINER_HashMapIterator.
+ *
+ * @param cls Closure - unused
+ * @param key #GNUNET_HashCode key of #GNUNET_CONTAINER_MultiHashMap iterator -
+ *        unused
+ * @param value Values represented as #ValueSet.
+ *
+ * @return GNUNET_YES - continue iteration.
+ */
+static int
+printer (void *cls,
+         const struct GNUNET_HashCode *key,
+         void *value)
+{
+  struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
+  const char *now_str;
+  struct ValueSet *value_set = value;
+
+  if (quiet == GNUNET_NO)
+  {
+    if (GNUNET_YES == watch)
+    {
+      now_str = GNUNET_STRINGS_absolute_time_to_string (now);
+      FPRINTF (stdout,
+               "%24s%s %s%s%12s%s %50s%s ",
+               now_str,
+               csv_separator,
+               value_set->is_persistent ? "!" : " ",
+               csv_separator,
+               value_set->subsystem,
+               csv_separator,
+                     _(value_set->name),
+               (0 == strlen (csv_separator) ? ":": csv_separator));
+    }
+    else
+    {
+      FPRINTF (stdout,
+               "%s%s%12s%s %50s%s ",
+               value_set->is_persistent ? "!" : " ",
+               csv_separator,
+               value_set->subsystem,
+               csv_separator,
+               _(value_set->name),
+               (0 == strlen (csv_separator) ? ":": csv_separator));
+    }
+  }
+  for (unsigned i = 0; i < num_nodes; i++)
+  {
+    FPRINTF (stdout,
+            "%16llu%s",
+            (unsigned long long) value_set->values[i],
+            csv_separator);
+  }
+  FPRINTF (stdout, "\n");
+  GNUNET_free (value_set->subsystem);
+  GNUNET_free (value_set->name);
+  GNUNET_free (value_set->values);
+  GNUNET_free (value_set);
+  return GNUNET_YES;
+}
+
+/**
+ * @brief Called once all statistic values are available.
+ *
+ * Implements #GNUNET_STATISTICS_Callback
+ *
+ * @param cls Closure - The index of the node.
+ * @param succes Whether statistics were obtained successfully.
  */
-static struct GNUNET_STATISTICS_GetHandle *gh;
+static void
+continuation_print (void *cls,
+                    int success)
+{
+  const unsigned index_node = *(unsigned *) cls;
 
+  nodes[index_node].gh = NULL;
+  if (GNUNET_OK != success)
+  {
+    if (NULL == remote_host)
+      FPRINTF (stderr,
+               "%s",
+               _("Failed to obtain statistics.\n"));
+    else
+      FPRINTF (stderr,
+               _("Failed to obtain statistics from host `%s:%llu'\n"),
+               remote_host,
+               remote_port);
+    ret = 1;
+  }
+  num_nodes_ready++;
+  if (num_nodes_ready == num_nodes)
+  {
+    GNUNET_CONTAINER_multihashmap_iterate (values, printer, NULL);
+    GNUNET_SCHEDULER_shutdown();
+  }
+}
 
 /**
  * Callback function to process statistic values.
@@ -95,11 +295,11 @@ static struct GNUNET_STATISTICS_GetHandle *gh;
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-printer (void *cls,
-         const char *subsystem,
-         const char *name,
-         uint64_t value,
-         int is_persistent)
+printer_watch (void *cls,
+               const char *subsystem,
+               const char *name,
+               uint64_t value,
+               int is_persistent)
 {
   struct GNUNET_TIME_Absolute now = GNUNET_TIME_absolute_get();
   const char *now_str;
@@ -110,21 +310,28 @@ printer (void *cls,
     {
       now_str = GNUNET_STRINGS_absolute_time_to_string (now);
       FPRINTF (stdout,
-               "%24s %s%12s %50s: %16llu\n",
+               "%24s%s %s%s%12s%s %50s%s %16llu\n",
                now_str,
+               csv_separator,
                is_persistent ? "!" : " ",
+               csv_separator,
                subsystem,
-               _(name),
-               (unsigned long long) value);
+               csv_separator,
+               _(name),
+               (0 == strlen (csv_separator) ? ":": csv_separator),
+               (unsigned long long) value);
     }
     else
     {
       FPRINTF (stdout,
-               "%s%12s %50s: %16llu\n",
+               "%s%s%12s%s %50s%s %16llu\n",
                is_persistent ? "!" : " ",
+               csv_separator,
                subsystem,
-               _(name),
-               (unsigned long long) value);
+               csv_separator,
+               _(name),
+               (0 == strlen (csv_separator) ? ":": csv_separator),
+               (unsigned long long) value);
     }
   }
   else
@@ -135,7 +342,6 @@ printer (void *cls,
   return GNUNET_OK;
 }
 
-
 /**
  * Function called last by the statistics code.
  *
@@ -147,7 +353,10 @@ static void
 cleanup (void *cls,
          int success)
 {
-  gh = NULL;
+  for (unsigned i = 0; i < num_nodes; i++)
+  {
+    nodes[i].gh = NULL;
+  }
   if (GNUNET_OK != success)
   {
     if (NULL == remote_host)
@@ -164,6 +373,55 @@ cleanup (void *cls,
   GNUNET_SCHEDULER_shutdown ();
 }
 
+/**
+ * @brief Iterate over statistics values and store them in #values.
+ * They will be printed once all are available.
+ *
+ * @param cls Cosure - Node index.
+ * @param subsystem Subsystem of the value.
+ * @param name Name of the value.
+ * @param value Value itself.
+ * @param is_persistent Persistence.
+ *
+ * @return GNUNET_OK - continue.
+ */
+static int
+collector (void *cls,
+           const char *subsystem,
+           const char *name,
+           uint64_t value,
+           int is_persistent)
+{
+  const unsigned index_node = *(unsigned *) cls;
+  struct GNUNET_HashCode *key;
+  struct GNUNET_HashCode hc;
+  char *subsys_name;
+  unsigned len_subsys_name;
+  struct ValueSet *value_set;
+
+  len_subsys_name = strlen (subsystem) + 3 + strlen (name) + 1;
+  subsys_name = GNUNET_malloc (len_subsys_name);
+  SPRINTF (subsys_name, "%s---%s", subsystem, name);
+  key = &hc;
+  GNUNET_CRYPTO_hash (subsys_name, len_subsys_name, key);
+  GNUNET_free (subsys_name);
+  if (GNUNET_YES == GNUNET_CONTAINER_multihashmap_contains (values, key))
+  {
+    // get
+    value_set = GNUNET_CONTAINER_multihashmap_get (values, key);
+  }
+  else
+  {
+    // new
+    value_set = new_value_set (subsystem, name, num_nodes, is_persistent);
+  }
+  // write
+  value_set->values[index_node] = value;
+  // put
+  GNUNET_CONTAINER_multihashmap_put (values, key, value_set,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+  return GNUNET_OK;
+}
 
 /**
  * Function run on shutdown to clean up.
@@ -173,10 +431,30 @@ cleanup (void *cls,
 static void
 shutdown_task (void *cls)
 {
-  struct GNUNET_STATISTICS_Handle *h = cls;
+  const unsigned index_node = *(unsigned *) cls;
+  struct GNUNET_STATISTICS_Handle *h;
+  struct GNUNET_STATISTICS_GetHandle *gh;
 
+  nodes[index_node].shutdown_task = NULL;
+  if ( (NULL != path_testbed) &&
+       (NULL != nodes[index_node].conf) )
+  {
+    GNUNET_CONFIGURATION_destroy (nodes[index_node].conf);
+    nodes[index_node].conf = NULL;
+  }
+
+  h = nodes[index_node].handle;
+  gh = nodes[index_node].gh;
   if (NULL == h)
+  {
+    num_nodes_ready--;
+    if (0 == num_nodes_ready)
+    {
+      GNUNET_array_grow (nodes, num_nodes, 0);
+      GNUNET_CONTAINER_multihashmap_destroy (values);
+    }
     return;
+  }
   if (NULL != gh)
   {
     GNUNET_STATISTICS_get_cancel (gh);
@@ -186,14 +464,21 @@ shutdown_task (void *cls)
        (NULL != subsystem) &&
        (NULL != name) )
     GNUNET_assert (GNUNET_OK ==
-                   GNUNET_STATISTICS_watch_cancel (h,
+       GNUNET_STATISTICS_watch_cancel (h,
                                                    subsystem,
                                                    name,
-                                                   &printer,
-                                                   h));
+                                                   &printer_watch,
+               &nodes[index_node].index_node));
   GNUNET_STATISTICS_destroy (h,
                              GNUNET_NO);
   h = NULL;
+
+  num_nodes_ready--;
+  if (0 == num_nodes_ready)
+  {
+    GNUNET_array_grow (nodes, num_nodes, 0);
+    GNUNET_CONTAINER_multihashmap_destroy (values);
+  }
 }
 
 
@@ -205,8 +490,8 @@ shutdown_task (void *cls)
 static void
 main_task (void *cls)
 {
-  const struct GNUNET_CONFIGURATION_Handle *cfg = cls;
-  struct GNUNET_STATISTICS_Handle *h;
+  unsigned index_node = *(unsigned *) cls;
+  const struct GNUNET_CONFIGURATION_Handle *cfg = nodes[index_node].conf;
 
   if (set_value)
   {
@@ -226,23 +511,23 @@ main_task (void *cls)
       ret = 1;
       return;
     }
-    h = GNUNET_STATISTICS_create (subsystem,
+    nodes[index_node].handle = GNUNET_STATISTICS_create (subsystem,
                                   cfg);
-    if (NULL == h)
+    if (NULL == nodes[index_node].handle)
     {
       ret = 1;
       return;
     }
-    GNUNET_STATISTICS_set (h,
+    GNUNET_STATISTICS_set (nodes[index_node].handle,
                            name,
                            (uint64_t) set_val,
                            persistent);
-    GNUNET_STATISTICS_destroy (h,
+    GNUNET_STATISTICS_destroy (nodes[index_node].handle,
                                GNUNET_YES);
-    h = NULL;
+    nodes[index_node].handle = NULL;
     return;
   }
-  if (NULL == (h = GNUNET_STATISTICS_create ("gnunet-statistics",
+  if (NULL == (nodes[index_node].handle = GNUNET_STATISTICS_create ("gnunet-statistics",
                                              cfg)))
   {
     ret = 1;
@@ -251,13 +536,13 @@ main_task (void *cls)
   if (GNUNET_NO == watch)
   {
     if (NULL ==
-        (gh = GNUNET_STATISTICS_get (h,
-                                     subsystem,
-                                     name,
-                                     &cleanup,
-                                     &printer,
-                                     h)) )
-      cleanup (h,
+        (nodes[index_node].gh = GNUNET_STATISTICS_get (nodes[index_node].handle,
+                                                       subsystem,
+                                                       name,
+                                                       &continuation_print,
+                                                       &collector,
+                                     &nodes[index_node].index_node)) )
+      cleanup (nodes[index_node].handle,
                GNUNET_SYSERR);
   }
   else
@@ -266,30 +551,128 @@ main_task (void *cls)
          (NULL == name) )
     {
       printf (_("No subsystem or name given\n"));
-      GNUNET_STATISTICS_destroy (h,
+      GNUNET_STATISTICS_destroy (nodes[index_node].handle,
                                  GNUNET_NO);
-      h = NULL;
+      nodes[index_node].handle = NULL;
       ret = 1;
       return;
     }
     if (GNUNET_OK !=
-        GNUNET_STATISTICS_watch (h,
+        GNUNET_STATISTICS_watch (nodes[index_node].handle,
                                  subsystem,
                                  name,
-                                 &printer,
-                                 h))
+                                 &printer_watch,
+                                 &nodes[index_node].index_node))
     {
       fprintf (stderr,
                _("Failed to initialize watch routine\n"));
-      GNUNET_SCHEDULER_add_now (&shutdown_task,
-                                h);
+      nodes[index_node].shutdown_task =
+        GNUNET_SCHEDULER_add_now (&shutdown_task,
+                                  &nodes[index_node].index_node);
       return;
     }
   }
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 h);
+  nodes[index_node].shutdown_task =
+    GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                   &nodes[index_node].index_node);
+}
+
+/**
+ * @brief Iter over content of a node's directory to check for existence of a
+ * config file.
+ *
+ * Implements #GNUNET_FileNameCallback
+ *
+ * @param cls pointer to indicate success
+ * @param filename filename inside the directory of the potential node
+ *
+ * @return to continue iteration or not to
+ */
+static int
+iter_check_config (void *cls,
+                   const char *filename)
+{
+  if (0 == strncmp (GNUNET_STRINGS_get_short_name (filename), "config", 6))
+  {
+    /* Found the config - stop iteration successfully */
+    GNUNET_array_grow (nodes, num_nodes, num_nodes+1);
+    nodes[num_nodes-1].conf = GNUNET_CONFIGURATION_create();
+    nodes[num_nodes-1].index_node = num_nodes-1;
+    if (GNUNET_OK != GNUNET_CONFIGURATION_load (nodes[num_nodes-1].conf, filename))
+    {
+      FPRINTF (stderr, "Failed loading config `%s'\n", filename);
+      return GNUNET_SYSERR;
+    }
+    return GNUNET_NO;
+  }
+  else
+  {
+    /* Continue iteration */
+    return GNUNET_OK;
+  }
+}
+
+/**
+ * @brief Iterates over filenames in testbed directory.
+ *
+ * Implements #GNUNET_FileNameCallback
+ *
+ * Checks if the file is a directory for a testbed node
+ * and counts the nodes.
+ *
+ * @param cls counter of nodes
+ * @param filename full path of the file in testbed
+ *
+ * @return status whether to continue iteration
+ */
+static int
+iter_testbed_path (void *cls,
+                   const char *filename)
+{
+  unsigned index_node;
+
+  GNUNET_assert (NULL != filename);
+  if (1 == SSCANF (GNUNET_STRINGS_get_short_name (filename),
+                  "%u",
+                  &index_node))
+  {
+    if (-1 == GNUNET_DISK_directory_scan (filename,
+                                          iter_check_config,
+                                          NULL))
+    {
+      /* This is probably no directory for a testbed node
+       * Go on with iteration */
+      return GNUNET_OK;
+    }
+    return GNUNET_OK;
+  }
+  return GNUNET_OK;
 }
 
+/**
+ * @brief Count the number of nodes running in the testbed
+ *
+ * @param path_testbed path to the testbed data
+ *
+ * @return number of running nodes
+ */
+static int
+discover_testbed_nodes (const char *path_testbed)
+{
+  int num_dir_entries;
+
+  num_dir_entries = GNUNET_DISK_directory_scan (path_testbed,
+                                                iter_testbed_path,
+                                                NULL);
+  if (-1 == num_dir_entries)
+  {
+    FPRINTF (stderr,
+            "Failure during scanning directory `%s'\n",
+            path_testbed);
+    return -1;
+  }
+  return 0;
+}
 
 /**
  * Main function that will be run by the scheduler.
@@ -309,6 +692,7 @@ run (void *cls,
 
   c = (struct GNUNET_CONFIGURATION_Handle *) cfg;
   set_value = GNUNET_NO;
+  if (NULL == csv_separator) csv_separator = "";
   if (NULL != args[0])
   {
     if (1 != SSCANF (args[0],
@@ -361,8 +745,34 @@ run (void *cls,
                                            "PORT",
                                            remote_port);
   }
-  GNUNET_SCHEDULER_add_now (&main_task,
-                            c);
+  if (NULL == path_testbed)
+  {
+    values = GNUNET_CONTAINER_multihashmap_create (1, GNUNET_NO);
+    GNUNET_array_grow (nodes, num_nodes, 1);
+    nodes[0].index_node = 0;
+    nodes[0].conf = c;
+    GNUNET_SCHEDULER_add_now (&main_task, &nodes[0].index_node);
+  }
+  else
+  {
+    if (GNUNET_YES == watch)
+    {
+      printf (_("Not able to watch testbed nodes (yet - feel free to implement)\n"));
+      ret = 1;
+      return;
+    }
+    values = GNUNET_CONTAINER_multihashmap_create (4, GNUNET_NO);
+    if (-1 == discover_testbed_nodes (path_testbed))
+    {
+      return;
+    }
+    /* For each config/node collect statistics */
+    for (unsigned i = 0; i < num_nodes; i++)
+    {
+      GNUNET_SCHEDULER_add_now (&main_task,
+              &nodes[i].index_node);
+    }
+  }
 }
 
 
@@ -394,6 +804,18 @@ main (int argc, char *const *argv)
                                  gettext_noop ("limit output to the given SUBSYSTEM"),
                                  &subsystem),
 
+    GNUNET_GETOPT_option_string ('S',
+                                 "csv-separator",
+                                 "CSV_SEPARATOR",
+                                 gettext_noop ("use as csv separator"),
+                                 &csv_separator),
+
+    GNUNET_GETOPT_option_filename ('t',
+                                  "testbed",
+                                  "TESTBED",
+                                  gettext_noop ("path to the folder containing the testbed data"),
+                                  &path_testbed),
+
     GNUNET_GETOPT_option_flag ('q',
                                   "quiet",
                                   gettext_noop ("just print the statistics value"),
@@ -409,11 +831,13 @@ main (int argc, char *const *argv)
                                  "REMOTE",
                                  gettext_noop ("connect to remote host"),
                                  &remote_host),
+
     GNUNET_GETOPT_option_ulong ('o',
                                     "port",
                                     "PORT",
                                     gettext_noop ("port for remote host"),
                                     &remote_port),
+
     GNUNET_GETOPT_OPTION_END
   };
   remote_port = 0;