1 files changed, 154 insertions, 193 deletions

diff --git a/src/fs/perf_gnunet_service_fs_p2p_trust.c b/src/fs/perf_gnunet_service_fs_p2p_trust.c
index 0128e281d..a78ff0571 100644
--- a/src/fs/perf_gnunet_service_fs_p2p_trust.c
+++ b/src/fs/perf_gnunet_service_fs_p2p_trust.c
@@ -87,11 +87,9 @@ static struct GNUNET_FS_Uri *uri1;
 static struct GNUNET_FS_Uri *uri2;
 
 static void
-do_stop (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_stop (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                               daemons);
+  GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
 }
 
 
@@ -100,7 +98,7 @@ do_stop (void *cls,
  */
 struct StatMaster
 {
-  struct GNUNET_STATISTICS_Handle *stat;  
+  struct GNUNET_STATISTICS_Handle *stat;
   unsigned int daemon;
   unsigned int value;
 };
@@ -114,30 +112,29 @@ struct StatValues
 /**
  * Statistics we print out.
  */
-static struct StatValues stats[] =
-  {
-    { "fs", "# artificial delays introduced (ms)"},
-    { "fs", "# queries forwarded"},
-    { "fs", "# replies received and matched"},
-    { "fs", "# results found locally"},
-    { "fs", "# requests forwarded due to high load"},
-    { "fs", "# requests done for free (low load)"},
-    { "fs", "# requests dropped, priority insufficient"},
-    { "fs", "# requests done for a price (normal load)"},
-    { "fs", "# requests dropped by datastore (queue length limit)"},
-    { "fs", "# P2P searches received"},
-    { "fs", "# P2P searches discarded (queue length bound)"},
-    { "fs", "# replies received for local clients"},
-    { "fs", "# queries retransmitted to same target"},
-    { "core", "# bytes decrypted"},
-    { "core", "# bytes encrypted"},
-    { "core", "# discarded CORE_SEND requests"},
-    { "core", "# discarded lower priority CORE_SEND requests"},
-    { "transport", "# bytes received via TCP"},
-    { "transport", "# bytes transmitted via TCP"},
-    { "datacache", "# bytes stored"},
-    { NULL, NULL}
-  };
+static struct StatValues stats[] = {
+  {"fs", "# artificial delays introduced (ms)"},
+  {"fs", "# queries forwarded"},
+  {"fs", "# replies received and matched"},
+  {"fs", "# results found locally"},
+  {"fs", "# requests forwarded due to high load"},
+  {"fs", "# requests done for free (low load)"},
+  {"fs", "# requests dropped, priority insufficient"},
+  {"fs", "# requests done for a price (normal load)"},
+  {"fs", "# requests dropped by datastore (queue length limit)"},
+  {"fs", "# P2P searches received"},
+  {"fs", "# P2P searches discarded (queue length bound)"},
+  {"fs", "# replies received for local clients"},
+  {"fs", "# queries retransmitted to same target"},
+  {"core", "# bytes decrypted"},
+  {"core", "# bytes encrypted"},
+  {"core", "# discarded CORE_SEND requests"},
+  {"core", "# discarded lower priority CORE_SEND requests"},
+  {"transport", "# bytes received via TCP"},
+  {"transport", "# bytes transmitted via TCP"},
+  {"datacache", "# bytes stored"},
+  {NULL, NULL}
+};
 
 
 /**
@@ -152,18 +149,14 @@ static struct StatValues stats[] =
  */
 static int
 print_stat (void *cls,
-            const char *subsystem,
-            const char *name,
-            uint64_t value,
-            int is_persistent)
+            const char *subsystem,
+            const char *name, uint64_t value, int is_persistent)
 {
   struct StatMaster *sm = cls;
+
   fprintf (stderr,
-           "Peer %2u: %12s/%50s = %12llu\n",
-           sm->daemon,
-           subsystem,
-           name,
-           (unsigned long long) value);
+           "Peer %2u: %12s/%50s = %12llu\n",
+           sm->daemon, subsystem, name, (unsigned long long) value);
   return GNUNET_OK;
 }
 
@@ -171,20 +164,18 @@ print_stat (void *cls,
 /**
  * Function that gathers stats from all daemons.
  */
-static void
-stat_run (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc);
+static void stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc);
 
 
 /**
  * Function called when GET operation on stats is done.
  */
 static void
-get_done (void *cls,
-          int success)
+get_done (void *cls, int success)
 {
   struct StatMaster *sm = cls;
-  GNUNET_break (GNUNET_OK ==  success);
+
+  GNUNET_break (GNUNET_OK == success);
   sm->value++;
   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 }
@@ -194,154 +185,140 @@ get_done (void *cls,
  * Function that gathers stats from all daemons.
  */
 static void
-stat_run (void *cls,
-          const struct GNUNET_SCHEDULER_TaskContext *tc)
+stat_run (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct StatMaster *sm = cls;
- 
+
   if (stats[sm->value].name != NULL)
-    {
-      GNUNET_STATISTICS_get (sm->stat,
+  {
+    GNUNET_STATISTICS_get (sm->stat,
 #if 0
-                             NULL, NULL, 
+                           NULL, NULL,
 #else
-                             stats[sm->value].subsystem,
-                             stats[sm->value].name,
+                           stats[sm->value].subsystem, stats[sm->value].name,
 #endif
-                             GNUNET_TIME_UNIT_FOREVER_REL,
-                             &get_done,
-                             &print_stat, sm);
-      return;
-    }
+                           GNUNET_TIME_UNIT_FOREVER_REL,
+                           &get_done, &print_stat, sm);
+    return;
+  }
   GNUNET_STATISTICS_destroy (sm->stat, GNUNET_NO);
   sm->value = 0;
   sm->daemon++;
   if (sm->daemon == NUM_DAEMONS)
-    {
-      GNUNET_free (sm);
-      GNUNET_SCHEDULER_add_now (&do_stop, NULL);
-      return;
-    }
+  {
+    GNUNET_free (sm);
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+    return;
+  }
   sm->stat = GNUNET_STATISTICS_create ("<driver>",
-                                       GNUNET_FS_TEST_get_configuration (daemons,
-                                                                         sm->daemon));
+                                       GNUNET_FS_TEST_get_configuration
+                                       (daemons, sm->daemon));
   GNUNET_SCHEDULER_add_now (&stat_run, sm);
 }
 
 
 static void
-do_report (void *cls,
-         const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_report (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   static int download_counter;
   const char *type = cls;
   struct GNUNET_TIME_Relative del;
-  char *fancy; 
+  char *fancy;
   struct StatMaster *sm;
-  
+
   if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE))
-    {
-      del = GNUNET_TIME_absolute_get_duration (start_time);
-      if (del.rel_value == 0)
-        del.rel_value = 1;
-      fancy = GNUNET_STRINGS_byte_size_fancy (((unsigned long long)FILESIZE) * 1000LL / del.rel_value);
-      fprintf (stderr,
-               "Download speed of type `%s' was %s/s\n",
-               type,
-               fancy);
-      GNUNET_free (fancy);
-      if (NUM_DAEMONS != ++download_counter)
-        return; /* more downloads to come */
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Finished all downloads, shutting down\n",
-                  (unsigned long long) FILESIZE);
-      sm = GNUNET_malloc (sizeof (struct StatMaster));
-      sm->stat = GNUNET_STATISTICS_create ("<driver>",
-                                           GNUNET_FS_TEST_get_configuration (daemons,
-                                                                             sm->daemon));
-      GNUNET_SCHEDULER_add_now (&stat_run, sm);
-    }
+  {
+    del = GNUNET_TIME_absolute_get_duration (start_time);
+    if (del.rel_value == 0)
+      del.rel_value = 1;
+    fancy =
+        GNUNET_STRINGS_byte_size_fancy (((unsigned long long) FILESIZE) *
+                                        1000LL / del.rel_value);
+    fprintf (stderr, "Download speed of type `%s' was %s/s\n", type, fancy);
+    GNUNET_free (fancy);
+    if (NUM_DAEMONS != ++download_counter)
+      return;                   /* more downloads to come */
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Finished all downloads, shutting down\n",
+                (unsigned long long) FILESIZE);
+    sm = GNUNET_malloc (sizeof (struct StatMaster));
+    sm->stat = GNUNET_STATISTICS_create ("<driver>",
+                                         GNUNET_FS_TEST_get_configuration
+                                         (daemons, sm->daemon));
+    GNUNET_SCHEDULER_add_now (&stat_run, sm);
+  }
   else
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during download for type `%s', shutting down with error\n",
-                  type);
-      ok = 1;
-      GNUNET_SCHEDULER_add_now (&do_stop, NULL);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during download for type `%s', shutting down with error\n",
+                type);
+    ok = 1;
+    GNUNET_SCHEDULER_add_now (&do_stop, NULL);
+  }
 }
 
 
 static void
-do_downloads (void *cls,
-              const struct GNUNET_FS_Uri *u2)
+do_downloads (void *cls, const struct GNUNET_FS_Uri *u2)
 {
   int anonymity;
   unsigned int i;
 
   if (NULL == u2)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   uri2 = GNUNET_FS_uri_dup (u2);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Downloading %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Downloading %llu bytes\n", (unsigned long long) FILESIZE);
   start_time = GNUNET_TIME_absolute_get ();
   if (NULL != strstr (progname, "dht"))
     anonymity = 0;
   else
     anonymity = 1;
   /* (semi) leach-download(s); not true leaches since
-     these peers do participate in sharing, they just
-     don't have to offer anything *initially*.  */
-  for (i=0;i<NUM_DAEMONS-2;i++)
+   * these peers do participate in sharing, they just
+   * don't have to offer anything *initially*.  */
+  for (i = 0; i < NUM_DAEMONS - 2; i++)
     GNUNET_FS_TEST_download (daemons[i],
-                             TIMEOUT,
-                             anonymity, 
-                             0 == (i%2) ? SEED1 : SEED2, 
-                             0 == (i%2) ? uri1  : uri2,  
-                             VERBOSE, 
-                             &do_report, "leach");
+                             TIMEOUT,
+                             anonymity,
+                             0 == (i % 2) ? SEED1 : SEED2,
+                             0 == (i % 2) ? uri1 : uri2,
+                             VERBOSE, &do_report, "leach");
   /* mutual downloads of (primary) sharing peers */
-  GNUNET_FS_TEST_download (daemons[NUM_DAEMONS-2],
-                           TIMEOUT,
-                           anonymity, SEED1, uri1, 
-                           VERBOSE, 
-                           &do_report, "seeder 2");
-  GNUNET_FS_TEST_download (daemons[NUM_DAEMONS-1],
-                           TIMEOUT,
-                           anonymity, SEED2, uri2, 
-                           VERBOSE, 
-                           &do_report, "seeder 1");
+  GNUNET_FS_TEST_download (daemons[NUM_DAEMONS - 2],
+                           TIMEOUT,
+                           anonymity, SEED1, uri1,
+                           VERBOSE, &do_report, "seeder 2");
+  GNUNET_FS_TEST_download (daemons[NUM_DAEMONS - 1],
+                           TIMEOUT,
+                           anonymity, SEED2, uri2,
+                           VERBOSE, &do_report, "seeder 1");
 }
 
 
 static void
-do_publish2 (void *cls,
-             const struct GNUNET_FS_Uri *u1)
+do_publish2 (void *cls, const struct GNUNET_FS_Uri *u1)
 {
   int do_index;
   int anonymity;
 
   if (NULL == u1)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Timeout during upload attempt, shutting down with error\n");
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Timeout during upload attempt, shutting down with error\n");
+    ok = 1;
+    return;
+  }
   uri1 = GNUNET_FS_uri_dup (u1);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
@@ -350,35 +327,29 @@ do_publish2 (void *cls,
     anonymity = 0;
   else
     anonymity = 1;
-  
-  GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS-2],
-                          TIMEOUT,
-                          anonymity, 
-                          do_index, FILESIZE, SEED2, 
-                          VERBOSE, 
-                          &do_downloads, NULL);
+
+  GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 2],
+                          TIMEOUT,
+                          anonymity,
+                          do_index, FILESIZE, SEED2,
+                          VERBOSE, &do_downloads, NULL);
 }
 
 static void
-do_publish1 (void *cls,
-            const char *emsg)
+do_publish1 (void *cls, const char *emsg)
 {
   int do_index;
   int anonymity;
 
   if (NULL != emsg)
-    {
-      GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS,
-                                   daemons);
-      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
-                  "Error trying to connect: %s\n",
-                  emsg);
-      ok = 1;
-      return;
-    }
+  {
+    GNUNET_FS_TEST_daemons_stop (NUM_DAEMONS, daemons);
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Error trying to connect: %s\n", emsg);
+    ok = 1;
+    return;
+  }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Publishing %llu bytes\n",
-              (unsigned long long) FILESIZE);
+              "Publishing %llu bytes\n", (unsigned long long) FILESIZE);
   if (NULL != strstr (progname, "index"))
     do_index = GNUNET_YES;
   else
@@ -387,60 +358,50 @@ do_publish1 (void *cls,
     anonymity = 0;
   else
     anonymity = 1;
-  
-  GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS-1],
-                          TIMEOUT,
-                          anonymity, 
-                          do_index, FILESIZE, SEED1, 
-                          VERBOSE, 
-                          &do_publish2, NULL);
+
+  GNUNET_FS_TEST_publish (daemons[NUM_DAEMONS - 1],
+                          TIMEOUT,
+                          anonymity,
+                          do_index, FILESIZE, SEED1,
+                          VERBOSE, &do_publish2, NULL);
 }
 
 
 static void
-do_connect (void *cls,
-            const struct GNUNET_SCHEDULER_TaskContext *tc)
+do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_TESTING_PeerGroup *pg;
 
   GNUNET_assert (0 != (tc->reason & GNUNET_SCHEDULER_REASON_PREREQ_DONE));
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Daemons started, will now try to connect them\n");
+              "Daemons started, will now try to connect them\n");
   pg = GNUNET_FS_TEST_get_group (daemons);
-  GNUNET_TESTING_create_topology (pg, 
-                                  GNUNET_TESTING_TOPOLOGY_CLIQUE,
-                                  GNUNET_TESTING_TOPOLOGY_NONE,
-                                  NULL);
+  GNUNET_TESTING_create_topology (pg,
+                                  GNUNET_TESTING_TOPOLOGY_CLIQUE,
+                                  GNUNET_TESTING_TOPOLOGY_NONE, NULL);
   GNUNET_TESTING_connect_topology (pg,
-                                   GNUNET_TESTING_TOPOLOGY_CLIQUE,
-                                   GNUNET_TESTING_TOPOLOGY_OPTION_NONE,
-                                   0.0,
-                                   TIMEOUT,
-                                   NUM_DAEMONS,
-                                   &do_publish1,
-                                   NULL);
+                                   GNUNET_TESTING_TOPOLOGY_CLIQUE,
+                                   GNUNET_TESTING_TOPOLOGY_OPTION_NONE,
+                                   0.0,
+                                   TIMEOUT, NUM_DAEMONS, &do_publish1, NULL);
 }
 
 
 static void
 run (void *cls,
      char *const *args,
-     const char *cfgfile,
-     const struct GNUNET_CONFIGURATION_Handle *cfg)
+     const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *cfg)
 {
   GNUNET_FS_TEST_daemons_start ("fs_test_lib_data.conf",
-                                TIMEOUT,
-                                NUM_DAEMONS,
-                                daemons,
-                                &do_connect,
-                                NULL);
+                                TIMEOUT,
+                                NUM_DAEMONS, daemons, &do_connect, NULL);
 }
 
 
 int
 main (int argc, char *argv[])
 {
-  char *const argvx[] = { 
+  char *const argvx[] = {
     "perf-gnunet-service-fs-p2p",
     "-c",
     "fs_test_lib_data.conf",
@@ -454,16 +415,16 @@ main (int argc, char *argv[])
   };
   progname = argv[0];
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
-  GNUNET_log_setup ("perf_gnunet_service_fs_p2p_trust", 
+  GNUNET_log_setup ("perf_gnunet_service_fs_p2p_trust",
 #if VERBOSE
-                    "DEBUG",
+                    "DEBUG",
 #else
-                    "WARNING",
+                    "WARNING",
 #endif
-                    NULL);
+                    NULL);
   GNUNET_PROGRAM_run ((sizeof (argvx) / sizeof (char *)) - 1,
                       argvx, "perf-gnunet-service-fs-p2p-trust",
-                      "nohelp", options, &run, NULL);
+                      "nohelp", options, &run, NULL);
   GNUNET_DISK_directory_remove ("/tmp/gnunet-test-fs-lib/");
   return ok;
 }