1 files changed, 218 insertions, 201 deletions

diff --git a/src/dht/test_dht_twopeer_put_get.c b/src/dht/test_dht_twopeer_put_get.c
index 40a165236..9db0ca385 100644
--- a/src/dht/test_dht_twopeer_put_get.c
+++ b/src/dht/test_dht_twopeer_put_get.c
@@ -137,14 +137,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;
+  }
 }
 
 /**
@@ -152,13 +152,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;
 }
@@ -168,13 +168,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);
@@ -186,15 +186,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;
 }
 
@@ -208,40 +209,47 @@ 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 *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 *result_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 DNS
-  if ((0 != memcmp(&data.service_descriptor, key, sizeof (GNUNET_HashCode))) || (0 != memcmp((char *)&data, result_data, sizeof(original_data))))
-    {
-      GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "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 ((0 != memcmp (&data.service_descriptor, key, sizeof (GNUNET_HashCode))) ||
+      (0 != memcmp ((char *) &data, result_data, sizeof (original_data))))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+                "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;
+  }
 #else
-  if ((0 != memcmp(&original_key, key, sizeof (GNUNET_HashCode))) || (0 != memcmp(original_data, result_data, sizeof(original_data))))
+  if ((0 != memcmp (&original_key, key, sizeof (GNUNET_HashCode))) ||
+      (0 != memcmp (original_data, result_data, sizeof (original_data))))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "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_WARNING,
+                "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;
   }
 #endif
 
-  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);
 }
 
@@ -249,26 +257,26 @@ 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 */
+  GNUNET_HashCode key;          /* Key for data lookup */
+
 #if DNS
-  memcpy(&key, &data.service_descriptor, sizeof(GNUNET_HashCode));
+  memcpy (&key, &data.service_descriptor, sizeof (GNUNET_HashCode));
 #else
-  memset(&key, 42, sizeof(GNUNET_HashCode)); /* Set the key to the same thing as when data was inserted */
+  memset (&key, 42, sizeof (GNUNET_HashCode));  /* Set the key to the same thing as when data was inserted */
 #endif
-  global_get_handle = GNUNET_DHT_get_start(peer2dht, GNUNET_TIME_relative_get_forever(),
+  global_get_handle =
+      GNUNET_DHT_get_start (peer2dht, GNUNET_TIME_relative_get_forever (),
 #if DNS
-                                           GNUNET_BLOCK_TYPE_DNS,
+                            GNUNET_BLOCK_TYPE_DNS,
 #else
-                                           GNUNET_BLOCK_TYPE_TEST,
+                            GNUNET_BLOCK_TYPE_TEST,
 #endif
-                                           &key,
-                                           DEFAULT_GET_REPLICATION,
-                                           GNUNET_DHT_RO_NONE,
-                                           NULL, 0,
-                                           NULL, 0,
-                                           &get_result_iterator, NULL);
+                            &key,
+                            DEFAULT_GET_REPLICATION,
+                            GNUNET_DHT_RO_NONE,
+                            NULL, 0, NULL, 0, &get_result_iterator, NULL);
 }
 
 /**
@@ -276,12 +284,14 @@ 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);
 }
 
 
@@ -290,23 +300,23 @@ put_finished (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
  * 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_NONE,
-                 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_NONE,
+                  GNUNET_BLOCK_TYPE_TEST,
+                  sizeof (data), data,
+                  GNUNET_TIME_UNIT_FOREVER_ABS,
+                  GNUNET_TIME_UNIT_FOREVER_REL, &put_finished, NULL);
 }
 #else
 
@@ -314,55 +324,56 @@ do_put (void *cls, const struct GNUNET_SCHEDULER_TaskContext * tc)
  * 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)
 {
-  char* name = "philipptoelke.gnunet.";
-  size_t size = sizeof(struct GNUNET_DNS_Record);
-  memset(&data, 0, size);
+  char *name = "philipptoelke.gnunet.";
+  size_t size = sizeof (struct GNUNET_DNS_Record);
+
+  memset (&data, 0, size);
 
-  data.purpose.size = htonl(size - sizeof(struct GNUNET_CRYPTO_RsaSignature));
+  data.purpose.size = htonl (size - sizeof (struct GNUNET_CRYPTO_RsaSignature));
   data.purpose.purpose = GNUNET_SIGNATURE_PURPOSE_DNS_RECORD;
 
-  GNUNET_CRYPTO_hash(name, strlen(name)+1, &data.service_descriptor);
+  GNUNET_CRYPTO_hash (name, strlen (name) + 1, &data.service_descriptor);
+
+  data.service_type = htonl (GNUNET_DNS_SERVICE_TYPE_UDP);
+  data.ports = htons (69);
 
-  data.service_type = htonl(GNUNET_DNS_SERVICE_TYPE_UDP);
-  data.ports = htons(69);
+  char *keyfile;
 
-  char* keyfile;
-  GNUNET_asprintf(&keyfile, "/tmp/test_dns_data_key");
-  struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file(keyfile);
-  GNUNET_free(keyfile);
-  GNUNET_assert(my_private_key != NULL);
+  GNUNET_asprintf (&keyfile, "/tmp/test_dns_data_key");
+  struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key =
+      GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  GNUNET_free (keyfile);
+  GNUNET_assert (my_private_key != NULL);
 
-  GNUNET_CRYPTO_rsa_key_get_public(my_private_key, &data.peer);
+  GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &data.peer);
 
-  data.expiration_time = GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS);
+  data.expiration_time =
+      GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS);
 
   /* Sign the block */
-  if (GNUNET_OK != GNUNET_CRYPTO_rsa_sign(my_private_key,
-                                          &data.purpose,
-                                          &data.signature))
-    {
-      GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "could not sign DNS_Record\n");
-      return;
-    }
-  GNUNET_CRYPTO_rsa_key_free(my_private_key);
-
-  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
-             "Putting with key %08x\n",
-             *((unsigned int*)&data.service_descriptor));
-
-  GNUNET_DHT_put(peer1dht,
-                 &data.service_descriptor,
-                 DEFAULT_PUT_REPLICATION,
-                 GNUNET_DHT_RO_NONE,
-                 GNUNET_BLOCK_TYPE_DNS,
-                 size,
-                 (char*)&data,
-                 GNUNET_TIME_relative_to_absolute(GNUNET_TIME_UNIT_HOURS),
-                 GNUNET_TIME_UNIT_MINUTES,
-                 &put_finished,
-                 NULL);
+  if (GNUNET_OK != GNUNET_CRYPTO_rsa_sign (my_private_key,
+                                           &data.purpose, &data.signature))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "could not sign DNS_Record\n");
+    return;
+  }
+  GNUNET_CRYPTO_rsa_key_free (my_private_key);
+
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+              "Putting with key %08x\n",
+              *((unsigned int *) &data.service_descriptor));
+
+  GNUNET_DHT_put (peer1dht,
+                  &data.service_descriptor,
+                  DEFAULT_PUT_REPLICATION,
+                  GNUNET_DHT_RO_NONE,
+                  GNUNET_BLOCK_TYPE_DNS,
+                  size,
+                  (char *) &data,
+                  GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_HOURS),
+                  GNUNET_TIME_UNIT_MINUTES, &put_finished, NULL);
 }
 #endif
 
@@ -387,43 +398,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)");
+  }
 }
 
 
@@ -440,73 +453,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,
-                                                                  12,
-                                                                  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,
+                                                              12, 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
@@ -516,11 +530,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 ==
@@ -533,7 +549,8 @@ 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! */
@@ -545,10 +562,7 @@ run (void *cls,
                                      NULL,
                                      NULL,
                                      &peers_started_callback,
-                                     NULL,
-                                     &topology_callback,
-                                     NULL,
-                                     NULL);
+                                     NULL, &topology_callback, NULL, NULL);
 
 }
 
@@ -556,10 +570,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
@@ -570,12 +585,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;
 }
 
@@ -597,9 +613,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;
 }