1 files changed, 211 insertions, 206 deletions

diff --git a/src/dht/test_dht_topo.c b/src/dht/test_dht_topo.c
index 32d99152d..d92095cc6 100644
--- a/src/dht/test_dht_topo.c
+++ b/src/dht/test_dht_topo.c
@@ -32,18 +32,21 @@
 /**
  * How long until we give up on fetching the data?
  */
-#define GET_TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 120)
+#define GET_TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \
+                                                   120)
 
 /**
  * How frequently do we execute the PUTs?
  */
-#define PUT_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 5)
+#define PUT_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, \
+                                                     5)
 
 
 /**
  * Information we keep for each GET operation.
  */
-struct GetOperation {
+struct GetOperation
+{
   /**
    * DLL.
    */
@@ -105,7 +108,8 @@ static unsigned int NUM_PEERS;
 /**
  * Statistics we print out.
  */
-static struct {
+static struct
+{
   const char *subsystem;
   const char *name;
   unsigned long long total;
@@ -150,34 +154,34 @@ static struct {
 
 
 static struct GNUNET_DHT_TEST_Context *
-stop_ops()
+stop_ops ()
 {
   struct GetOperation *get_op;
   struct GNUNET_DHT_TEST_Context *ctx = NULL;
 
   if (NULL != timeout_task)
-    {
-      ctx = GNUNET_SCHEDULER_cancel(timeout_task);
-      timeout_task = NULL;
-    }
+  {
+    ctx = GNUNET_SCHEDULER_cancel (timeout_task);
+    timeout_task = NULL;
+  }
   if (NULL != put_task)
-    {
-      GNUNET_SCHEDULER_cancel(put_task);
-      put_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (put_task);
+    put_task = NULL;
+  }
   if (NULL != get_task)
-    {
-      GNUNET_SCHEDULER_cancel(get_task);
-      get_task = NULL;
-    }
+  {
+    GNUNET_SCHEDULER_cancel (get_task);
+    get_task = NULL;
+  }
   while (NULL != (get_op = get_tail))
-    {
-      GNUNET_DHT_get_stop(get_op->get);
-      GNUNET_CONTAINER_DLL_remove(get_head,
-                                  get_tail,
-                                  get_op);
-      GNUNET_free(get_op);
-    }
+  {
+    GNUNET_DHT_get_stop (get_op->get);
+    GNUNET_CONTAINER_DLL_remove (get_head,
+                                 get_tail,
+                                 get_op);
+    GNUNET_free (get_op);
+  }
   return ctx;
 }
 
@@ -190,32 +194,32 @@ stop_ops()
  * @param emsg error message on failure
  */
 static void
-stats_finished(void *cls,
-               struct GNUNET_TESTBED_Operation *op,
-               const char *emsg)
+stats_finished (void *cls,
+                struct GNUNET_TESTBED_Operation *op,
+                const char *emsg)
 {
   struct GNUNET_DHT_TEST_Context *ctx = cls;
   unsigned int i;
 
   if (NULL != op)
-    GNUNET_TESTBED_operation_done(op);
+    GNUNET_TESTBED_operation_done (op);
   if (NULL != emsg)
-    {
-      fprintf(stderr,
-              _("Gathering statistics failed: %s\n"),
-              emsg);
-      GNUNET_SCHEDULER_cancel(put_task);
-      GNUNET_DHT_TEST_cleanup(ctx);
-      return;
-    }
+  {
+    fprintf (stderr,
+             _ ("Gathering statistics failed: %s\n"),
+             emsg);
+    GNUNET_SCHEDULER_cancel (put_task);
+    GNUNET_DHT_TEST_cleanup (ctx);
+    return;
+  }
   for (i = 0; NULL != stats[i].name; i++)
-    fprintf(stderr,
-            "%6s/%60s = %12llu\n",
-            stats[i].subsystem,
-            stats[i].name,
-            stats[i].total);
-  GNUNET_DHT_TEST_cleanup(ctx);
-  GNUNET_SCHEDULER_shutdown();
+    fprintf (stderr,
+             "%6s/%60s = %12llu\n",
+             stats[i].subsystem,
+             stats[i].name,
+             stats[i].total);
+  GNUNET_DHT_TEST_cleanup (ctx);
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -231,20 +235,20 @@ stats_finished(void *cls,
  * @return #GNUNET_OK to continue, #GNUNET_SYSERR to abort iteration
  */
 static int
-handle_stats(void *cls,
-             const struct GNUNET_TESTBED_Peer *peer,
-             const char *subsystem,
-             const char *name,
-             uint64_t value,
-             int is_persistent)
+handle_stats (void *cls,
+              const struct GNUNET_TESTBED_Peer *peer,
+              const char *subsystem,
+              const char *name,
+              uint64_t value,
+              int is_persistent)
 {
   unsigned int i;
 
   for (i = 0; NULL != stats[i].name; i++)
-    if ((0 == strcasecmp(subsystem,
-                         stats[i].subsystem)) &&
-        (0 == strcasecmp(name,
-                         stats[i].name)))
+    if ((0 == strcasecmp (subsystem,
+                          stats[i].subsystem)) &&
+        (0 == strcasecmp (name,
+                          stats[i].name)))
       stats[i].total += value;
   return GNUNET_OK;
 }
@@ -257,9 +261,9 @@ handle_stats(void *cls,
  * @param cls the 'struct GNUNET_DHT_TestContext'
  */
 static void
-shutdown_task(void *cls)
+shutdown_task (void *cls)
 {
-  (void)stop_ops();
+  (void) stop_ops ();
 }
 
 
@@ -270,12 +274,12 @@ shutdown_task(void *cls)
  * @param cls the `struct GNUNET_DHT_TestContext`
  */
 static void
-timeout_cb(void *cls)
+timeout_cb (void *cls)
 {
   timeout_task = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
-             "Timeout\n");
-  GNUNET_SCHEDULER_shutdown();
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+              "Timeout\n");
+  GNUNET_SCHEDULER_shutdown ();
 }
 
 
@@ -295,75 +299,75 @@ timeout_cb(void *cls)
  * @param data pointer to the result data
  */
 static void
-dht_get_handler(void *cls,
-                struct GNUNET_TIME_Absolute exp,
-                const struct GNUNET_HashCode *key,
-                const struct GNUNET_PeerIdentity *get_path,
-                unsigned int get_path_length,
-                const struct GNUNET_PeerIdentity *put_path,
-                unsigned int put_path_length,
-                enum GNUNET_BLOCK_Type type,
-                size_t size,
-                const void *data)
+dht_get_handler (void *cls,
+                 struct GNUNET_TIME_Absolute exp,
+                 const struct GNUNET_HashCode *key,
+                 const struct GNUNET_PeerIdentity *get_path,
+                 unsigned int get_path_length,
+                 const struct GNUNET_PeerIdentity *put_path,
+                 unsigned int put_path_length,
+                 enum GNUNET_BLOCK_Type type,
+                 size_t size,
+                 const void *data)
 {
   struct GetOperation *get_op = cls;
   struct GNUNET_HashCode want;
   struct GNUNET_DHT_TEST_Context *ctx;
 
   if (sizeof(struct GNUNET_HashCode) != size)
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_CRYPTO_hash(key,
-                     sizeof(*key),
-                     &want);
-  if (0 != memcmp(&want,
-                  data,
-                  sizeof(want)))
-    {
-      GNUNET_break(0);
-      return;
-    }
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Get successful\n");
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_CRYPTO_hash (key,
+                      sizeof(*key),
+                      &want);
+  if (0 != memcmp (&want,
+                   data,
+                   sizeof(want)))
+  {
+    GNUNET_break (0);
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Get successful\n");
 #if 0
   {
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "PATH: (get %u, put %u)\n",
-               get_path_length,
-               put_path_length);
-    GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-               "  LOCAL\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "PATH: (get %u, put %u)\n",
+                get_path_length,
+                put_path_length);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "  LOCAL\n");
     for (int i = get_path_length - 1; i >= 0; i--)
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "  %s\n",
-                 GNUNET_i2s(&get_path[i]));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "  %s\n",
+                  GNUNET_i2s (&get_path[i]));
     for (int i = put_path_length - 1; i >= 0; i--)
-      GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-                 "  %s\n",
-                 GNUNET_i2s(&put_path[i]));
+      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                  "  %s\n",
+                  GNUNET_i2s (&put_path[i]));
   }
 #endif
-  GNUNET_DHT_get_stop(get_op->get);
-  GNUNET_CONTAINER_DLL_remove(get_head,
-                              get_tail,
-                              get_op);
-  GNUNET_free(get_op);
+  GNUNET_DHT_get_stop (get_op->get);
+  GNUNET_CONTAINER_DLL_remove (get_head,
+                               get_tail,
+                               get_op);
+  GNUNET_free (get_op);
   if (NULL != get_head)
     return;
   /* all DHT GET operations successful; get stats! */
-  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
-             "All DHT operations successful. Obtaining stats!\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
+              "All DHT operations successful. Obtaining stats!\n");
   ok = 0;
-  ctx = stop_ops();
-  GNUNET_assert(NULL != ctx);
-  (void)GNUNET_TESTBED_get_statistics(NUM_PEERS,
-                                      my_peers,
-                                      NULL, NULL,
-                                      &handle_stats,
-                                      &stats_finished,
-                                      ctx);
+  ctx = stop_ops ();
+  GNUNET_assert (NULL != ctx);
+  (void) GNUNET_TESTBED_get_statistics (NUM_PEERS,
+                                        my_peers,
+                                        NULL, NULL,
+                                        &handle_stats,
+                                        &stats_finished,
+                                        ctx);
 }
 
 
@@ -374,38 +378,38 @@ dht_get_handler(void *cls,
  * @param tc Task context
  */
 static void
-do_puts(void *cls)
+do_puts (void *cls)
 {
   struct GNUNET_DHT_Handle **hs = cls;
   struct GNUNET_HashCode key;
   struct GNUNET_HashCode value;
 
   put_task = NULL;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Putting values into DHT\n");
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Putting values into DHT\n");
   for (unsigned int i = 0; i < NUM_PEERS; i++)
-    {
-      GNUNET_CRYPTO_hash(&i,
-                         sizeof(i),
-                         &key);
-      GNUNET_CRYPTO_hash(&key,
-                         sizeof(key),
-                         &value);
-      GNUNET_DHT_put(hs[i],
-                     &key,
-                     10U,
-                     GNUNET_DHT_RO_RECORD_ROUTE |
-                     GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                     GNUNET_BLOCK_TYPE_TEST,
-                     sizeof(value),
-                     &value,
-                     GNUNET_TIME_UNIT_FOREVER_ABS,
-                     NULL,
-                     NULL);
-    }
-  put_task = GNUNET_SCHEDULER_add_delayed(PUT_FREQUENCY,
-                                          &do_puts,
-                                          hs);
+  {
+    GNUNET_CRYPTO_hash (&i,
+                        sizeof(i),
+                        &key);
+    GNUNET_CRYPTO_hash (&key,
+                        sizeof(key),
+                        &value);
+    GNUNET_DHT_put (hs[i],
+                    &key,
+                    10U,
+                    GNUNET_DHT_RO_RECORD_ROUTE
+                    | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                    GNUNET_BLOCK_TYPE_TEST,
+                    sizeof(value),
+                    &value,
+                    GNUNET_TIME_UNIT_FOREVER_ABS,
+                    NULL,
+                    NULL);
+  }
+  put_task = GNUNET_SCHEDULER_add_delayed (PUT_FREQUENCY,
+                                           &do_puts,
+                                           hs);
 }
 
 
@@ -413,7 +417,7 @@ do_puts(void *cls)
  * Start GET operations.
  */
 static void
-start_get(void *cls)
+start_get (void *cls)
 {
   struct GNUNET_DHT_Handle **dhts = cls;
   unsigned int i;
@@ -423,25 +427,26 @@ start_get(void *cls)
 
   get_task = NULL;
   for (i = 0; i < NUM_PEERS; i++)
+  {
+    GNUNET_CRYPTO_hash (&i, sizeof(i), &key);
+    for (j = 0; j < NUM_PEERS; j++)
     {
-      GNUNET_CRYPTO_hash(&i, sizeof(i), &key);
-      for (j = 0; j < NUM_PEERS; j++)
-        {
-          get_op = GNUNET_new(struct GetOperation);
-          GNUNET_CONTAINER_DLL_insert(get_head,
-                                      get_tail,
-                                      get_op);
-          get_op->get = GNUNET_DHT_get_start(dhts[j],
-                                             GNUNET_BLOCK_TYPE_TEST, /* type */
-                                             &key,   /*key to search */
-                                             4U,  /* replication level */
-                                             GNUNET_DHT_RO_RECORD_ROUTE | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
-                                             NULL,     /* xquery */
-                                             0,   /* xquery bits */
-                                             &dht_get_handler,
-                                             get_op);
-        }
+      get_op = GNUNET_new (struct GetOperation);
+      GNUNET_CONTAINER_DLL_insert (get_head,
+                                   get_tail,
+                                   get_op);
+      get_op->get = GNUNET_DHT_get_start (dhts[j],
+                                          GNUNET_BLOCK_TYPE_TEST,    /* type */
+                                          &key,      /*key to search */
+                                          4U,     /* replication level */
+                                          GNUNET_DHT_RO_RECORD_ROUTE
+                                          | GNUNET_DHT_RO_DEMULTIPLEX_EVERYWHERE,
+                                          NULL,        /* xquery */
+                                          0,      /* xquery bits */
+                                          &dht_get_handler,
+                                          get_op);
     }
+  }
 }
 
 
@@ -455,26 +460,26 @@ start_get(void *cls)
  * @param dhts handle to each of the DHTs of the peers
  */
 static void
-run(void *cls,
-    struct GNUNET_DHT_TEST_Context *ctx,
-    unsigned int num_peers,
-    struct GNUNET_TESTBED_Peer **peers,
-    struct GNUNET_DHT_Handle **dhts)
+run (void *cls,
+     struct GNUNET_DHT_TEST_Context *ctx,
+     unsigned int num_peers,
+     struct GNUNET_TESTBED_Peer **peers,
+     struct GNUNET_DHT_Handle **dhts)
 {
-  GNUNET_assert(NUM_PEERS == num_peers);
+  GNUNET_assert (NUM_PEERS == num_peers);
   my_peers = peers;
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Peers setup, starting test\n");
-  put_task = GNUNET_SCHEDULER_add_now(&do_puts,
-                                      dhts);
-  get_task = GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_UNIT_SECONDS,
-                                          &start_get,
-                                          dhts);
-  timeout_task = GNUNET_SCHEDULER_add_delayed(GET_TIMEOUT,
-                                              &timeout_cb,
-                                              ctx);
-  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
-                                ctx);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Peers setup, starting test\n");
+  put_task = GNUNET_SCHEDULER_add_now (&do_puts,
+                                       dhts);
+  get_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                           &start_get,
+                                           dhts);
+  timeout_task = GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT,
+                                               &timeout_cb,
+                                               ctx);
+  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
+                                 ctx);
 }
 
 
@@ -482,44 +487,44 @@ run(void *cls,
  * Main: start test
  */
 int
-main(int xargc, char *xargv[])
+main (int xargc, char *xargv[])
 {
   const char *cfg_filename;
   const char *test_name;
 
-  if (NULL != strstr(xargv[0], "test_dht_2dtorus"))
-    {
-      cfg_filename = "test_dht_2dtorus.conf";
-      test_name = "test-dht-2dtorus";
-      NUM_PEERS = 16;
-    }
-  else if (NULL != strstr(xargv[0], "test_dht_line"))
-    {
-      cfg_filename = "test_dht_line.conf";
-      test_name = "test-dht-line";
-      NUM_PEERS = 5;
-    }
-  else if (NULL != strstr(xargv[0], "test_dht_twopeer"))
-    {
-      cfg_filename = "test_dht_line.conf";
-      test_name = "test-dht-twopeer";
-      NUM_PEERS = 2;
-    }
-  else if (NULL != strstr(xargv[0], "test_dht_multipeer"))
-    {
-      cfg_filename = "test_dht_multipeer.conf";
-      test_name = "test-dht-multipeer";
-      NUM_PEERS = 10;
-    }
+  if (NULL != strstr (xargv[0], "test_dht_2dtorus"))
+  {
+    cfg_filename = "test_dht_2dtorus.conf";
+    test_name = "test-dht-2dtorus";
+    NUM_PEERS = 16;
+  }
+  else if (NULL != strstr (xargv[0], "test_dht_line"))
+  {
+    cfg_filename = "test_dht_line.conf";
+    test_name = "test-dht-line";
+    NUM_PEERS = 5;
+  }
+  else if (NULL != strstr (xargv[0], "test_dht_twopeer"))
+  {
+    cfg_filename = "test_dht_line.conf";
+    test_name = "test-dht-twopeer";
+    NUM_PEERS = 2;
+  }
+  else if (NULL != strstr (xargv[0], "test_dht_multipeer"))
+  {
+    cfg_filename = "test_dht_multipeer.conf";
+    test_name = "test-dht-multipeer";
+    NUM_PEERS = 10;
+  }
   else
-    {
-      GNUNET_break(0);
-      return 1;
-    }
-  GNUNET_DHT_TEST_run(test_name,
-                      cfg_filename,
-                      NUM_PEERS,
-                      &run, NULL);
+  {
+    GNUNET_break (0);
+    return 1;
+  }
+  GNUNET_DHT_TEST_run (test_name,
+                       cfg_filename,
+                       NUM_PEERS,
+                       &run, NULL);
   return ok;
 }