1 files changed, 161 insertions, 163 deletions

diff --git a/src/dht/test_dht_monitor.c b/src/dht/test_dht_monitor.c
index 9d0462c87..f5586e9bc 100644
--- a/src/dht/test_dht_monitor.c
+++ b/src/dht/test_dht_monitor.c
@@ -11,12 +11,12 @@
      WITHOUT ANY WARRANTY; without even the implied warranty of
      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      Affero General Public License for more details.
-    
+
      You should have received a copy of the GNU Affero General Public License
      along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
      SPDX-License-Identifier: AGPL3.0-or-later
-*/
+ */
 /**
  * @file dht/test_dht_monitor.c
  * @brief Test for the dht monitoring API; checks that we receive "some" monitor events
@@ -31,19 +31,18 @@
 /**
  * How long do we run the test at most?
  */
-#define TIMEOUT GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 300)
+#define TIMEOUT GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 300)
 
 /**
  * How often do we run the PUTs?
  */
-#define PUT_FREQUENCY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, 10)
+#define PUT_FREQUENCY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10)
 
 
 /**
  * Information we keep for each GET operation.
  */
-struct GetOperation
-{
+struct GetOperation {
   /**
    * DLL.
    */
@@ -58,7 +57,6 @@ struct GetOperation
    * Handle for the operation.
    */
   struct GNUNET_DHT_GetHandle *get;
-
 };
 
 
@@ -110,34 +108,34 @@ static unsigned int monitor_counter;
  * @param cls the `struct GNUNET_DHT_TEST_Context`
  */
 static void
-shutdown_task (void *cls)
+shutdown_task(void *cls)
 {
   struct GNUNET_DHT_TEST_Context *ctx = cls;
   unsigned int i;
   struct GetOperation *get_op;
 
   ok = (monitor_counter > NUM_PEERS) ? 0 : 2;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Received %u monitor events\n",
-              monitor_counter);
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "Received %u monitor events\n",
+             monitor_counter);
   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);
-  }
-  for (i=0;i<NUM_PEERS;i++)
-    GNUNET_DHT_monitor_stop (monitors[i]);
-  GNUNET_free (monitors);
-  GNUNET_SCHEDULER_cancel (put_task);
-  GNUNET_DHT_TEST_cleanup (ctx);
+    {
+      GNUNET_DHT_get_stop(get_op->get);
+      GNUNET_CONTAINER_DLL_remove(get_head,
+                                  get_tail,
+                                  get_op);
+      GNUNET_free(get_op);
+    }
+  for (i = 0; i < NUM_PEERS; i++)
+    GNUNET_DHT_monitor_stop(monitors[i]);
+  GNUNET_free(monitors);
+  GNUNET_SCHEDULER_cancel(put_task);
+  GNUNET_DHT_TEST_cleanup(ctx);
   if (NULL != timeout_task)
-  {
-    GNUNET_SCHEDULER_cancel (timeout_task);
-    timeout_task = NULL;
-  }
+    {
+      GNUNET_SCHEDULER_cancel(timeout_task);
+      timeout_task = NULL;
+    }
 }
 
 
@@ -149,10 +147,10 @@ shutdown_task (void *cls)
  * @param cls NULL
  */
 static void
-timeout_task_cb (void *cls)
+timeout_task_cb(void *cls)
 {
   timeout_task = NULL;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -172,41 +170,41 @@ timeout_task_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;
 
-  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_DHT_get_stop (get_op->get);
-  GNUNET_CONTAINER_DLL_remove (get_head,
-                               get_tail,
-                               get_op);
-  GNUNET_free (get_op);
+  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_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; terminate! */
   ok = 0;
-  GNUNET_SCHEDULER_shutdown ();
+  GNUNET_SCHEDULER_shutdown();
 }
 
 
@@ -216,28 +214,28 @@ dht_get_handler (void *cls, struct GNUNET_TIME_Absolute exp,
  * @param cls array with NUM_PEERS DHT handles
  */
 static void
-do_puts (void *cls)
+do_puts(void *cls)
 {
   struct GNUNET_DHT_Handle **hs = cls;
   struct GNUNET_HashCode key;
   struct GNUNET_HashCode value;
 
-  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);
 }
 
 
@@ -255,22 +253,22 @@ do_puts (void *cls)
  * @param key Key of the requested data.
  */
 static void
-monitor_get_cb (void *cls,
-                enum GNUNET_DHT_RouteOption options,
-                enum GNUNET_BLOCK_Type type,
-                uint32_t hop_count,
-                uint32_t desired_replication_level,
-                unsigned int path_length,
-                const struct GNUNET_PeerIdentity *path,
-                const struct GNUNET_HashCode * key)
+monitor_get_cb(void *cls,
+               enum GNUNET_DHT_RouteOption options,
+               enum GNUNET_BLOCK_Type type,
+               uint32_t hop_count,
+               uint32_t desired_replication_level,
+               unsigned int path_length,
+               const struct GNUNET_PeerIdentity *path,
+               const struct GNUNET_HashCode * key)
 {
   unsigned int i;
 
-  i = (unsigned int) (long) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "%u got a GET message for key %s\n",
-              i,
-              GNUNET_h2s (key));
+  i = (unsigned int)(long)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "%u got a GET message for key %s\n",
+             i,
+             GNUNET_h2s(key));
   monitor_counter++;
 }
 
@@ -292,26 +290,26 @@ monitor_get_cb (void *cls,
  * @param size Number of bytes in data.
  */
 static void
-monitor_put_cb (void *cls,
-                enum GNUNET_DHT_RouteOption options,
-                enum GNUNET_BLOCK_Type type,
-                uint32_t hop_count,
-                uint32_t desired_replication_level,
-                unsigned int path_length,
-                const struct GNUNET_PeerIdentity *path,
-                struct GNUNET_TIME_Absolute exp,
-                const struct GNUNET_HashCode * key,
-                const void *data,
-                size_t size)
+monitor_put_cb(void *cls,
+               enum GNUNET_DHT_RouteOption options,
+               enum GNUNET_BLOCK_Type type,
+               uint32_t hop_count,
+               uint32_t desired_replication_level,
+               unsigned int path_length,
+               const struct GNUNET_PeerIdentity *path,
+               struct GNUNET_TIME_Absolute exp,
+               const struct GNUNET_HashCode * key,
+               const void *data,
+               size_t size)
 {
   unsigned int i;
 
-  i = (unsigned int) (long) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "%u got a PUT message for key %s with %u bytes\n",
-              i,
-              GNUNET_h2s (key),
-              (unsigned int) size);
+  i = (unsigned int)(long)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "%u got a PUT message for key %s with %u bytes\n",
+             i,
+             GNUNET_h2s(key),
+             (unsigned int)size);
   monitor_counter++;
 }
 
@@ -332,25 +330,25 @@ monitor_put_cb (void *cls,
  * @param size Number of bytes in data.
  */
 static void
-monitor_res_cb (void *cls,
-                enum GNUNET_BLOCK_Type type,
-                const struct GNUNET_PeerIdentity *get_path,
-                unsigned int get_path_length,
-                const struct GNUNET_PeerIdentity *put_path,
-                unsigned int put_path_length,
-                struct GNUNET_TIME_Absolute exp,
-                const struct GNUNET_HashCode * key,
-                const void *data,
-                size_t size)
+monitor_res_cb(void *cls,
+               enum GNUNET_BLOCK_Type type,
+               const struct GNUNET_PeerIdentity *get_path,
+               unsigned int get_path_length,
+               const struct GNUNET_PeerIdentity *put_path,
+               unsigned int put_path_length,
+               struct GNUNET_TIME_Absolute exp,
+               const struct GNUNET_HashCode * key,
+               const void *data,
+               size_t size)
 {
   unsigned int i;
 
-  i = (unsigned int) (long) cls;
-  GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "%u got a REPLY message for key %s with %u bytes\n",
-              i,
-              GNUNET_h2s (key),
-              (unsigned int) size);
+  i = (unsigned int)(long)cls;
+  GNUNET_log(GNUNET_ERROR_TYPE_INFO,
+             "%u got a REPLY message for key %s with %u bytes\n",
+             i,
+             GNUNET_h2s(key),
+             (unsigned int)size);
   monitor_counter++;
 }
 
@@ -365,56 +363,56 @@ monitor_res_cb (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)
 {
   unsigned int i;
   unsigned int j;
   struct GNUNET_HashCode key;
   struct GetOperation *get_op;
 
-  GNUNET_assert (NUM_PEERS == num_peers);
+  GNUNET_assert(NUM_PEERS == num_peers);
   my_peers = peers;
-  monitors = GNUNET_new_array (num_peers,
-                               struct GNUNET_DHT_MonitorHandle *);
+  monitors = GNUNET_new_array(num_peers,
+                              struct GNUNET_DHT_MonitorHandle *);
+  for (i = 0; i < num_peers; i++)
+    monitors[i] = GNUNET_DHT_monitor_start(dhts[i],
+                                           GNUNET_BLOCK_TYPE_ANY,
+                                           NULL,
+                                           &monitor_get_cb,
+                                           &monitor_res_cb,
+                                           &monitor_put_cb,
+                                           (void *)(long)i);
+  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
+             "Peers setup, starting test\n");
+  put_task = GNUNET_SCHEDULER_add_now(&do_puts, dhts);
   for (i = 0; i < num_peers; i++)
-    monitors[i] = GNUNET_DHT_monitor_start (dhts[i],
-                                            GNUNET_BLOCK_TYPE_ANY,
-                                            NULL,
-                                            &monitor_get_cb,
-                                            &monitor_res_cb,
-                                            &monitor_put_cb,
-                                            (void *)(long)i);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "Peers setup, starting test\n");
-  put_task = GNUNET_SCHEDULER_add_now (&do_puts, dhts);
-  for (i=0;i<num_peers;i++)
-  {
-    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_DEMULTIPLEX_EVERYWHERE,
-                                          NULL,        /* xquery */
-                                          0,      /* xquery bits */
-                                          &dht_get_handler, get_op);
+      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_DEMULTIPLEX_EVERYWHERE,
+                                             NULL,     /* xquery */
+                                             0,   /* xquery bits */
+                                             &dht_get_handler, get_op);
+        }
     }
-  }
-  timeout_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &timeout_task_cb,
-                                               NULL);
-  GNUNET_SCHEDULER_add_shutdown (&shutdown_task,
-                                 ctx);
+  timeout_task = GNUNET_SCHEDULER_add_delayed(TIMEOUT,
+                                              &timeout_task_cb,
+                                              NULL);
+  GNUNET_SCHEDULER_add_shutdown(&shutdown_task,
+                                ctx);
 }
 
 
@@ -422,12 +420,12 @@ run (void *cls,
  * Main: start test
  */
 int
-main (int xargc, char *xargv[])
+main(int xargc, char *xargv[])
 {
-  GNUNET_DHT_TEST_run ("test-dht-monitor",
-                       "test_dht_monitor.conf",
-                       NUM_PEERS,
-                       &run, NULL);
+  GNUNET_DHT_TEST_run("test-dht-monitor",
+                      "test_dht_monitor.conf",
+                      NUM_PEERS,
+                      &run, NULL);
   return ok;
 }