1 files changed, 159 insertions, 157 deletions

diff --git a/src/dht/test_dht_monitor.c b/src/dht/test_dht_monitor.c
index f5586e9bc..95fb37bcd 100644
--- a/src/dht/test_dht_monitor.c
+++ b/src/dht/test_dht_monitor.c
@@ -31,18 +31,20 @@
 /**
  * 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.
    */
@@ -93,7 +95,7 @@ static struct GNUNET_SCHEDULER_Task *timeout_task;
 /**
  * Task to do DHT_puts
  */
-static struct GNUNET_SCHEDULER_Task * put_task;
+static struct GNUNET_SCHEDULER_Task *put_task;
 
 static struct GNUNET_DHT_MonitorHandle **monitors;
 
@@ -108,34 +110,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);
-    }
+  {
+    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_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;
+  }
 }
 
 
@@ -147,10 +149,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 ();
 }
 
 
@@ -170,41 +172,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);
+  {
+    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 ();
 }
 
 
@@ -214,28 +216,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);
 }
 
 
@@ -253,22 +255,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++;
 }
 
@@ -290,26 +292,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++;
 }
 
@@ -330,25 +332,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++;
 }
 
@@ -363,56 +365,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);
+    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++)
     {
-      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);
-        }
+      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);
 }
 
 
@@ -420,12 +422,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;
 }