1 files changed, 178 insertions, 170 deletions

diff --git a/src/dht/test_dht_twopeer_path_tracking.c b/src/dht/test_dht_twopeer_path_tracking.c
index d4e5a1332..ab0b1edd2 100644
--- a/src/dht/test_dht_twopeer_path_tracking.c
+++ b/src/dht/test_dht_twopeer_path_tracking.c
@@ -115,14 +115,14 @@ static struct GNUNET_DHT_Handle *peer2dht;
 /**
  * Check whether peers successfully shut down.
  */
-void shutdown_callback (void *cls,
-                        const char *emsg)
+void
+shutdown_callback (void *cls, const char *emsg)
 {
   if (emsg != NULL)
-    {
-      if (ok == 0)
-        ok = 2;
-    }
+  {
+    if (ok == 0)
+      ok = 2;
+  }
 }
 
 /**
@@ -130,13 +130,13 @@ void shutdown_callback (void *cls,
  * testcase.  Specifically, called when our get request completes.
  */
 static void
-finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_assert (pg != NULL);
   GNUNET_assert (peer1dht != NULL);
   GNUNET_assert (peer2dht != NULL);
-  GNUNET_DHT_disconnect(peer1dht);
-  GNUNET_DHT_disconnect(peer2dht);
+  GNUNET_DHT_disconnect (peer1dht);
+  GNUNET_DHT_disconnect (peer2dht);
   GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
   ok = 0;
 }
@@ -146,13 +146,13 @@ finish_testing (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
  * down the peers without freeing memory associated with GET request.
  */
 static void
-end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   if (peer1dht != NULL)
-      GNUNET_DHT_disconnect(peer1dht);
+    GNUNET_DHT_disconnect (peer1dht);
 
   if (peer2dht != NULL)
-    GNUNET_DHT_disconnect(peer2dht);
+    GNUNET_DHT_disconnect (peer2dht);
 
   if (pg != NULL)
     GNUNET_TESTING_daemons_stop (pg, TIMEOUT, &shutdown_callback, NULL);
@@ -164,15 +164,16 @@ end_badly_cont (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
  * test.
  */
 static void
-end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failing test with error: `%s'!\n", (char *)cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failing test with error: `%s'!\n",
+              (char *) cls);
   if (global_get_handle != NULL)
-    {
-      GNUNET_DHT_get_stop(global_get_handle);
-      global_get_handle = NULL;
-    }
-  GNUNET_SCHEDULER_add_now(&end_badly_cont, NULL);
+  {
+    GNUNET_DHT_get_stop (global_get_handle);
+    global_get_handle = NULL;
+  }
+  GNUNET_SCHEDULER_add_now (&end_badly_cont, NULL);
   ok = 1;
 }
 
@@ -186,51 +187,54 @@ end_badly (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
  * @param size number of bytes in data
  * @param data pointer to the result data
  */
-void get_result_iterator (void *cls,
-                          struct GNUNET_TIME_Absolute exp,
-                          const GNUNET_HashCode * key,
-                          const struct GNUNET_PeerIdentity * const *get_path,
-                          const struct GNUNET_PeerIdentity * const *put_path,
-                          enum GNUNET_BLOCK_Type type,
-                          size_t size,
-                          const void *data)
+void
+get_result_iterator (void *cls,
+                     struct GNUNET_TIME_Absolute exp,
+                     const GNUNET_HashCode * key,
+                     const struct GNUNET_PeerIdentity *const *get_path,
+                     const struct GNUNET_PeerIdentity *const *put_path,
+                     enum GNUNET_BLOCK_Type type, size_t size, const void *data)
 {
   GNUNET_HashCode original_key; /* Key data was stored data under */
-  char original_data[4]; /* Made up data that was stored */
-  memset(&original_key, 42, sizeof(GNUNET_HashCode)); /* Set the key to what it was set to previously */
-  memset(original_data, 43, sizeof(original_data));
+  char original_data[4];        /* Made up data that was stored */
+
+  memset (&original_key, 42, sizeof (GNUNET_HashCode)); /* Set the key to what it was set to previously */
+  memset (original_data, 43, sizeof (original_data));
 #if VERBOSE
   unsigned int i;
 #endif
 
-  if ((0 != memcmp(&original_key, key, sizeof (GNUNET_HashCode))) || (0 != memcmp(original_data, data, sizeof(original_data))))
+  if ((0 != memcmp (&original_key, key, sizeof (GNUNET_HashCode))) ||
+      (0 != memcmp (original_data, data, sizeof (original_data))))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Key or data is not the same as was inserted!\n");
-    GNUNET_SCHEDULER_cancel(die_task);
-    GNUNET_SCHEDULER_add_now(&end_badly, "key or data mismatch in get response!\n");
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Key or data is not the same as was inserted!\n");
+    GNUNET_SCHEDULER_cancel (die_task);
+    GNUNET_SCHEDULER_add_now (&end_badly,
+                              "key or data mismatch in get response!\n");
     return;
   }
 
 #if VERBOSE
   if (put_path != NULL)
-    {
-      fprintf(stderr, "PUT Path: ");
-      for (i = 0; put_path[i] != NULL; i++)
-        fprintf(stderr, "%s%s", i == 0 ? "" : "->", GNUNET_i2s(put_path[i]));
-      fprintf(stderr, "\n");
-    }
+  {
+    fprintf (stderr, "PUT Path: ");
+    for (i = 0; put_path[i] != NULL; i++)
+      fprintf (stderr, "%s%s", i == 0 ? "" : "->", GNUNET_i2s (put_path[i]));
+    fprintf (stderr, "\n");
+  }
   if (get_path != NULL)
-    {
-      fprintf(stderr, "GET Path: ");
-      for (i = 0; get_path[i] != NULL; i++)
-        fprintf(stderr, "%s%s", i == 0 ? "" : "->", GNUNET_i2s(get_path[i]));
-      fprintf(stderr, "\n");
-    }
+  {
+    fprintf (stderr, "GET Path: ");
+    for (i = 0; get_path[i] != NULL; i++)
+      fprintf (stderr, "%s%s", i == 0 ? "" : "->", GNUNET_i2s (get_path[i]));
+    fprintf (stderr, "\n");
+  }
 #endif
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received correct GET response!\n");
-  GNUNET_SCHEDULER_cancel(die_task);
-  GNUNET_DHT_get_stop(global_get_handle);
+  GNUNET_SCHEDULER_cancel (die_task);
+  GNUNET_DHT_get_stop (global_get_handle);
   GNUNET_SCHEDULER_add_now (&finish_testing, NULL);
 }
 
@@ -238,18 +242,16 @@ void get_result_iterator (void *cls,
  * Start the GET request for the same key/data that was inserted.
  */
 static void
-do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_HashCode key; /* Key for data lookup */
-  memset(&key, 42, sizeof(GNUNET_HashCode)); /* Set the key to the same thing as when data was inserted */
-  global_get_handle = GNUNET_DHT_get_start(peer2dht, GNUNET_TIME_relative_get_forever(),
-                                           GNUNET_BLOCK_TYPE_TEST,
-                                           &key,
-                                           DEFAULT_GET_REPLICATION,
-                                           GNUNET_DHT_RO_RECORD_ROUTE,
-                                           NULL, 0,
-                                           NULL, 0,
-                                           &get_result_iterator, NULL);
+  GNUNET_HashCode key;          /* Key for data lookup */
+
+  memset (&key, 42, sizeof (GNUNET_HashCode));  /* Set the key to the same thing as when data was inserted */
+  global_get_handle =
+      GNUNET_DHT_get_start (peer2dht, GNUNET_TIME_relative_get_forever (),
+                            GNUNET_BLOCK_TYPE_TEST, &key,
+                            DEFAULT_GET_REPLICATION, GNUNET_DHT_RO_RECORD_ROUTE,
+                            NULL, 0, NULL, 0, &get_result_iterator, NULL);
 }
 
 /**
@@ -257,35 +259,37 @@ do_get (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
  * Schedule the GET request for some time in the future.
  */
 static void
-put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   GNUNET_SCHEDULER_cancel (die_task);
   die_task = GNUNET_SCHEDULER_add_delayed (GET_TIMEOUT,
-                                           &end_badly, "waiting for get response (data not found)");
-  GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 10), &do_get, NULL);
+                                           &end_badly,
+                                           "waiting for get response (data not found)");
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                (GNUNET_TIME_UNIT_SECONDS, 10), &do_get, NULL);
 }
 
 /**
  * Set up some data, and call API PUT function
  */
 static void
-do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
+do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
-  GNUNET_HashCode key; /* Made up key to store data under */
-  char data[4]; /* Made up data to store */
-  memset(&key, 42, sizeof(GNUNET_HashCode)); /* Set the key to something simple so we can issue GET request */
-  memset(data, 43, sizeof(data));
+  GNUNET_HashCode key;          /* Made up key to store data under */
+  char data[4];                 /* Made up data to store */
+
+  memset (&key, 42, sizeof (GNUNET_HashCode));  /* Set the key to something simple so we can issue GET request */
+  memset (data, 43, sizeof (data));
 
   /* Insert the data at the first peer */
-  GNUNET_DHT_put(peer1dht,
-                 &key,
-                 DEFAULT_PUT_REPLICATION,
-                 GNUNET_DHT_RO_RECORD_ROUTE,
-                 GNUNET_BLOCK_TYPE_TEST,
-                 sizeof(data), data,
-                 GNUNET_TIME_UNIT_FOREVER_ABS,
-                 GNUNET_TIME_UNIT_FOREVER_REL,
-                 &put_finished, NULL);
+  GNUNET_DHT_put (peer1dht,
+                  &key,
+                  DEFAULT_PUT_REPLICATION,
+                  GNUNET_DHT_RO_RECORD_ROUTE,
+                  GNUNET_BLOCK_TYPE_TEST,
+                  sizeof (data), data,
+                  GNUNET_TIME_UNIT_FOREVER_ABS,
+                  GNUNET_TIME_UNIT_FOREVER_REL, &put_finished, NULL);
 }
 
 /**
@@ -309,43 +313,45 @@ topology_callback (void *cls,
                    const char *emsg)
 {
   if (emsg == NULL)
-    {
-      total_connections++;
+  {
+    total_connections++;
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "connected peer %s to peer %s, distance %u\n",
-                 first_daemon->shortname,
-                 second_daemon->shortname,
-                 distance);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "connected peer %s to peer %s, distance %u\n",
+                first_daemon->shortname, second_daemon->shortname, distance);
 #endif
-    }
+  }
 #if VERBOSE
   else
-    {
-      failed_connections++;
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Failed to connect peer %s to peer %s with error :\n%s\n",
-                  first_daemon->shortname,
-                  second_daemon->shortname, emsg);
-    }
+  {
+    failed_connections++;
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Failed to connect peer %s to peer %s with error :\n%s\n",
+                first_daemon->shortname, second_daemon->shortname, emsg);
+  }
 #endif
 
   if (total_connections == expected_connections)
-    {
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Created %d total connections, which is our target number!  Starting next phase of testing.\n",
-                  total_connections);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "Created %d total connections, which is our target number!  Starting next phase of testing.\n",
+                total_connections);
 #endif
-      GNUNET_SCHEDULER_cancel (die_task);
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly, "from test gets");
+    GNUNET_SCHEDULER_cancel (die_task);
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                             &end_badly, "from test gets");
 
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_SECONDS, 2), &do_put, NULL);
-    }
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
+                                  (GNUNET_TIME_UNIT_SECONDS, 2), &do_put, NULL);
+  }
   else if (total_connections + failed_connections == expected_connections)
-    {
-      GNUNET_SCHEDULER_cancel (die_task);
-      die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from topology_callback (too many failed connections)");
-    }
+  {
+    GNUNET_SCHEDULER_cancel (die_task);
+    die_task =
+        GNUNET_SCHEDULER_add_now (&end_badly,
+                                  "from topology_callback (too many failed connections)");
+  }
 }
 
 
@@ -362,74 +368,74 @@ topology_callback (void *cls,
  */
 static void
 peers_started_callback (void *cls,
-       const struct GNUNET_PeerIdentity *id,
-       const struct GNUNET_CONFIGURATION_Handle *cfg,
-       struct GNUNET_TESTING_Daemon *d, const char *emsg)
+                        const struct GNUNET_PeerIdentity *id,
+                        const struct GNUNET_CONFIGURATION_Handle *cfg,
+                        struct GNUNET_TESTING_Daemon *d, const char *emsg)
 {
   if (emsg != NULL)
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Failed to start daemon with error: `%s'\n",
-                  emsg);
-      return;
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to start daemon with error: `%s'\n", emsg);
+    return;
+  }
   GNUNET_assert (id != NULL);
 
   /* This is the first peer started */
   if (peers_left == num_peers)
   {
-    memcpy(&peer1id, id, sizeof(struct GNUNET_PeerIdentity)); /* Save the peer id */
-    peer1dht = GNUNET_DHT_connect(cfg, 100); /* Connect to the first peers DHT service */
-    if (peer1dht == NULL) /* If DHT connect failed */
+    memcpy (&peer1id, id, sizeof (struct GNUNET_PeerIdentity)); /* Save the peer id */
+    peer1dht = GNUNET_DHT_connect (cfg, 100);   /* Connect to the first peers DHT service */
+    if (peer1dht == NULL)       /* If DHT connect failed */
     {
       GNUNET_SCHEDULER_cancel (die_task);
-      GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
+      GNUNET_SCHEDULER_add_now (&end_badly, "Failed to get dht handle!\n");
     }
   }
-  else /* This is the second peer started */
+  else                          /* This is the second peer started */
   {
-    memcpy(&peer2id, id, sizeof(struct GNUNET_PeerIdentity)); /* Same as for first peer... */
-    peer2dht = GNUNET_DHT_connect(cfg, 100);
+    memcpy (&peer2id, id, sizeof (struct GNUNET_PeerIdentity)); /* Same as for first peer... */
+    peer2dht = GNUNET_DHT_connect (cfg, 100);
     if (peer2dht == NULL)
     {
       GNUNET_SCHEDULER_cancel (die_task);
-      GNUNET_SCHEDULER_add_now(&end_badly, "Failed to get dht handle!\n");
+      GNUNET_SCHEDULER_add_now (&end_badly, "Failed to get dht handle!\n");
     }
   }
 
   /* Decrement number of peers left to start */
   peers_left--;
 
-  if (peers_left == 0) /* Indicates all peers started */
-    {
+  if (peers_left == 0)          /* Indicates all peers started */
+  {
 #if VERBOSE
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "All %d daemons started, now connecting peers!\n",
-                  num_peers);
+    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+                "All %d daemons started, now connecting peers!\n", num_peers);
 #endif
-      expected_connections = -1;
-      if ((pg != NULL)) /* Sanity check */
-        {
-          /* Connect peers in a "straight line" topology, return the number of expected connections */
-          expected_connections = GNUNET_TESTING_connect_topology (pg,
-                                                                  GNUNET_TESTING_TOPOLOGY_LINE,
-                                                                  GNUNET_TESTING_TOPOLOGY_OPTION_ALL,
-                                                                  0.0,
-                                                                  TIMEOUT,
-                                                                  2,
-                                                                  NULL,
-                                                                  NULL);
-        }
-
-      /* Cancel current timeout fail task */
-      GNUNET_SCHEDULER_cancel (die_task);
-      if (expected_connections == GNUNET_SYSERR) /* Some error happened */
-        die_task = GNUNET_SCHEDULER_add_now (&end_badly, "from connect topology (bad return)");
-
-      /* Schedule timeout on failure task */
-      die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                               &end_badly, "from connect topology (timeout)");
-      ok = 0;
+    expected_connections = -1;
+    if ((pg != NULL))           /* Sanity check */
+    {
+      /* Connect peers in a "straight line" topology, return the number of expected connections */
+      expected_connections = GNUNET_TESTING_connect_topology (pg,
+                                                              GNUNET_TESTING_TOPOLOGY_LINE,
+                                                              GNUNET_TESTING_TOPOLOGY_OPTION_ALL,
+                                                              0.0,
+                                                              TIMEOUT,
+                                                              2, NULL, NULL);
     }
+
+    /* Cancel current timeout fail task */
+    GNUNET_SCHEDULER_cancel (die_task);
+    if (expected_connections == GNUNET_SYSERR)  /* Some error happened */
+      die_task =
+          GNUNET_SCHEDULER_add_now (&end_badly,
+                                    "from connect topology (bad return)");
+
+    /* Schedule timeout on failure task */
+    die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
+                                             &end_badly,
+                                             "from connect topology (timeout)");
+    ok = 0;
+  }
 }
 
 static void
@@ -439,11 +445,13 @@ run (void *cls,
 {
 
   /* Get path from configuration file */
-  if (GNUNET_YES != GNUNET_CONFIGURATION_get_value_string(cfg, "paths", "servicehome", &test_directory))
-    {
-      ok = 404;
-      return;
-    }
+  if (GNUNET_YES !=
+      GNUNET_CONFIGURATION_get_value_string (cfg, "paths", "servicehome",
+                                             &test_directory))
+  {
+    ok = 404;
+    return;
+  }
 
   /* Get number of peers to start from configuration (should be two) */
   if (GNUNET_SYSERR ==
@@ -456,22 +464,19 @@ run (void *cls,
 
   /* Set up a task to end testing if peer start fails */
   die_task = GNUNET_SCHEDULER_add_delayed (TIMEOUT,
-                                           &end_badly, "didn't start all daemons in reasonable amount of time!!!");
+                                           &end_badly,
+                                           "didn't start all daemons in reasonable amount of time!!!");
 
   /* Start num_peers peers, call peers_started_callback on peer start, topology_callback on peer connect */
   /* Read the API documentation for other parameters! */
-  pg = GNUNET_TESTING_daemons_start (cfg,
-                                     peers_left, /* Total number of peers */
-                                     peers_left, /* Number of outstanding connections */
-                                     peers_left, /* Number of parallel ssh connections, or peers being started at once */
+  pg = GNUNET_TESTING_daemons_start (cfg, peers_left,   /* Total number of peers */
+                                     peers_left,        /* Number of outstanding connections */
+                                     peers_left,        /* Number of parallel ssh connections, or peers being started at once */
                                      TIMEOUT,
                                      NULL,
                                      NULL,
                                      &peers_started_callback,
-                                     NULL,
-                                     &topology_callback,
-                                     NULL,
-                                     NULL);
+                                     NULL, &topology_callback, NULL, NULL);
 
 }
 
@@ -479,10 +484,11 @@ static int
 check ()
 {
   int ret;
+
   /* Arguments for GNUNET_PROGRAM_run */
-  char *const argv[] = {"test-dht-twopeer-put-get", /* Name to give running binary */
+  char *const argv[] = { "test-dht-twopeer-put-get",    /* Name to give running binary */
     "-c",
-    "test_dht_twopeer_data.conf", /* Config file to use */
+    "test_dht_twopeer_data.conf",       /* Config file to use */
 #if VERBOSE
     "-L", "DEBUG",
 #endif
@@ -493,12 +499,13 @@ check ()
   };
   /* Run the run function as a new program */
   ret = GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1,
-                      argv, "test-dht-twopeer-put-get", "nohelp",
-                      options, &run, &ok);
+                            argv, "test-dht-twopeer-put-get", "nohelp",
+                            options, &run, &ok);
   if (ret != GNUNET_OK)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "`test-dht-twopeer': Failed with error code %d\n", ret);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "`test-dht-twopeer': Failed with error code %d\n", ret);
+  }
   return ok;
 }
 
@@ -520,9 +527,10 @@ main (int argc, char *argv[])
    * of by the testing framework.
    */
   if (GNUNET_DISK_directory_remove (test_directory) != GNUNET_OK)
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "Failed to remove testing directory %s\n", test_directory);
-    }
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "Failed to remove testing directory %s\n", test_directory);
+  }
   return ret;
 }