X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Ftransport%2Ftransport-testing.c;h=dcd95053b176f004a79c5744fc01ce23bd514fe6;hb=6d754e6c89fda8cb0da00c4152ffc6dcc707e6ce;hp=a4eba609d91b9956faff4573e6e1a851bab35c5a;hpb=e79ca91c1884398d2ba205026d168be375e74788;p=oweals%2Fgnunet.git

diff --git a/src/transport/transport-testing.c b/src/transport/transport-testing.c
index a4eba609d..dcd95053b 100644
--- a/src/transport/transport-testing.c
+++ b/src/transport/transport-testing.c
@@ -27,15 +27,37 @@
 
 #include "transport-testing.h"
 
-#define VERBOSE GNUNET_YES
+#define HOSTKEYFILESIZE 914
 
+static const char *
+get_host_key (struct GNUNET_TRANSPORT_TESTING_handle *tth)
+{
+  if (tth->hostkey_data == NULL)
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                     "No precomputed hostkeys available\n");
+    return NULL;
+  }
+  if (tth->hostkeys_total > tth->hostkeys_last)
+  {
+    tth->hostkeys_last++;
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                     "Used hostkey %u of %u available hostkeys\n",
+                     tth->hostkeys_last, tth->hostkeys_total);
+    return &tth->hostkey_data[(tth->hostkeys_last - 1) * HOSTKEYFILESIZE];
+  }
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                   "No hostkey available (%u of %u already used)\n",
+                   tth->hostkeys_last, tth->hostkeys_total);
+  return NULL;
+}
 
 static struct PeerContext *
-find_peer_context ( struct GNUNET_TRANSPORT_TESTING_handle *tth,
-                    const struct GNUNET_PeerIdentity *peer)
+find_peer_context (struct GNUNET_TRANSPORT_TESTING_handle *tth,
+                   const struct GNUNET_PeerIdentity *peer)
 {
   GNUNET_assert (tth != NULL);
-  struct PeerContext * t = tth->p_head;
+  struct PeerContext *t = tth->p_head;
 
   while (t != NULL)
   {
@@ -48,17 +70,16 @@ find_peer_context ( struct GNUNET_TRANSPORT_TESTING_handle *tth,
 }
 
 struct ConnectingContext *
-find_connecting_context ( struct GNUNET_TRANSPORT_TESTING_handle *tth,
-                          struct PeerContext *p1,
-                          struct PeerContext * p2)
+find_connecting_context (struct GNUNET_TRANSPORT_TESTING_handle *tth,
+                         struct PeerContext *p1, struct PeerContext *p2)
 {
   GNUNET_assert (tth != NULL);
-  struct ConnectingContext * cc = tth->cc_head;
+  struct ConnectingContext *cc = tth->cc_head;
 
   while (cc != NULL)
   {
     if ((cc->p1 == p1) && (cc->p2 == p2))
-        break;
+      break;
     if ((cc->p1 == p2) && (cc->p2 == p1))
       break;
     cc = cc->next;
@@ -69,14 +90,14 @@ find_connecting_context ( struct GNUNET_TRANSPORT_TESTING_handle *tth,
 
 static void
 notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_ATS_Information *ats,
-                uint32_t ats_count)
+                const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 {
   struct PeerContext *p = cls;
+
   /* Find PeerContext */
   GNUNET_assert (p != 0);
   GNUNET_assert (p->tth != NULL);
-  struct PeerContext * p2 = find_peer_context (p->tth, peer);
+  struct PeerContext *p2 = find_peer_context (p->tth, peer);
 
   if (p == NULL)
     return;
@@ -84,21 +105,22 @@ notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
     p->nc (p->cb_cls, peer, ats, ats_count);
 
 #if VERBOSE
-  char * p2_s;
+  char *p2_s;
+
   if (p2 != NULL)
-    GNUNET_asprintf(&p2_s, "%u (`%s')", p2->no, GNUNET_i2s (&p2->id));
+    GNUNET_asprintf (&p2_s, "%u (`%s')", p2->no, GNUNET_i2s (&p2->id));
   else
-    GNUNET_asprintf(&p2_s, "`%s'", GNUNET_i2s (peer));
+    GNUNET_asprintf (&p2_s, "`%s'", GNUNET_i2s (peer));
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-      "Peers %s connected to peer %u (`%s')\n",
-      p2_s,
-      p->no, GNUNET_i2s (&p->id));
+                   "Peers %s connected to peer %u (`%s')\n", p2_s, p->no,
+                   GNUNET_i2s (&p->id));
   GNUNET_free (p2_s);
 #endif
 
 
   /* Find ConnectingContext */
-  struct ConnectingContext * cc = find_connecting_context(p->tth, p, p2);
+  struct ConnectingContext *cc = find_connecting_context (p->tth, p, p2);
+
   if (cc == NULL)
     return;
 
@@ -106,12 +128,12 @@ notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
     cc->p1_c = GNUNET_YES;
 
   if (p == cc->p2)
-      cc->p2_c = GNUNET_YES;
+    cc->p2_c = GNUNET_YES;
 
   if ((cc->p1_c == GNUNET_YES) && (cc->p2_c == GNUNET_YES))
   {
     cc->cb (cc->p1, cc->p2, cc->cb_cls);
-    GNUNET_TRANSPORT_TESTING_connect_peers_cancel(p->tth, cc);
+    GNUNET_TRANSPORT_TESTING_connect_peers_cancel (p->tth, cc);
   }
 }
 
@@ -119,9 +141,10 @@ static void
 notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   struct PeerContext *p = cls;
+
   /* Find PeerContext */
   int no = 0;
-  struct PeerContext * p2 = NULL;
+  struct PeerContext *p2 = NULL;
 
   if (p != NULL)
   {
@@ -130,15 +153,15 @@ notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
     no = p->no;
   }
 
-  char * p2_s;
+  char *p2_s;
+
   if (p2 != NULL)
-    GNUNET_asprintf(&p2_s, "%u (`%s')", p2->no, GNUNET_i2s (&p2->id));
+    GNUNET_asprintf (&p2_s, "%u (`%s')", p2->no, GNUNET_i2s (&p2->id));
   else
-    GNUNET_asprintf(&p2_s, "`%s'", GNUNET_i2s (peer));
+    GNUNET_asprintf (&p2_s, "`%s'", GNUNET_i2s (peer));
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-      "Peers %s disconnected from peer %u (`%s')\n",
-      p2_s,
-      no , GNUNET_i2s (&p->id));
+                   "Peers %s disconnected from peer %u (`%s')\n", p2_s, no,
+                   GNUNET_i2s (&p->id));
   GNUNET_free (p2_s);
 
   if (p == NULL)
@@ -150,8 +173,7 @@ notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 static void
 notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
                 const struct GNUNET_MessageHeader *message,
-                const struct GNUNET_ATS_Information *ats,
-                uint32_t ats_count)
+                const struct GNUNET_ATS_Information *ats, uint32_t ats_count)
 {
   struct PeerContext *p = cls;
 
@@ -170,25 +192,27 @@ get_hello (void *cb_cls, const struct GNUNET_MessageHeader *message)
   GNUNET_assert (GNUNET_OK ==
                  GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
                                       message, &p->id));
-  size_t size = GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *) message);
+#if VERBOSE
+  size_t size =
+      GNUNET_HELLO_size ((const struct GNUNET_HELLO_Message *) message);
+#endif
   GNUNET_free_non_null (p->hello);
-  p->hello = (struct GNUNET_HELLO_Message*) GNUNET_copy_message (message);
+  p->hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (message);
 
 #if VERBOSE
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, 
-		   "transport-testing",
-		   "New HELLO for peer %u (`%s') with size %u\n",
-		   p->no, GNUNET_i2s (&p->id), size);
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                   "New HELLO for peer %u (`%s') with size %u\n", p->no,
+                   GNUNET_i2s (&p->id), size);
 #endif
 
   if (p->start_cb != NULL)
   {
 #if VERBOSE
     GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-        "Peer %u (`%s') successfully started\n",
-        p->no, GNUNET_i2s (&p->id));
+                     "Peer %u (`%s') successfully started\n", p->no,
+                     GNUNET_i2s (&p->id));
 #endif
-    p->start_cb(p, p->cb_cls);
+    p->start_cb (p, p->cb_cls);
     p->start_cb = NULL;
   }
 }
@@ -205,15 +229,21 @@ try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
     return;
 
-  char * p2_s = GNUNET_strdup(GNUNET_i2s (&p2->id));
+  GNUNET_assert (cc != NULL);
+  GNUNET_assert (cc->p1 != NULL);
+  GNUNET_assert (cc->p2 != NULL);
+
+  char *p2_s = GNUNET_strdup (GNUNET_i2s (&p2->id));
+
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-      "Asking peer %u (`%s') to connect peer %u (`%s'), providing HELLO with %u bytes\n",
-		   p1->no, GNUNET_i2s (&p1->id), p2->no, p2_s,
-		   GNUNET_HELLO_size (cc->p2->hello));
+                   "Asking peer %u (`%s') to connect peer %u (`%s'), providing HELLO with %u bytes\n",
+                   p1->no, GNUNET_i2s (&p1->id), p2->no, p2_s,
+                   GNUNET_HELLO_size (cc->p2->hello));
   GNUNET_free (p2_s);
 
   GNUNET_TRANSPORT_offer_hello (cc->th_p1,
-      (const struct GNUNET_MessageHeader *) cc->p2->hello, NULL, NULL);
+                                (const struct GNUNET_MessageHeader *) cc->
+                                p2->hello, NULL, NULL);
   GNUNET_TRANSPORT_try_connect (cc->th_p1, &p2->id);
 
   cc->tct =
@@ -223,40 +253,70 @@ try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
 /**
  * Start a peer with the given configuration
+ * @param tth the testing handle
+ * @param cfgname configuration file
+ * @param peer_id the peer_id
  * @param rec receive callback
  * @param nc connect callback
  * @param nd disconnect callback
+ * @param start_cb start callback
  * @param cb_cls closure for callback
  * @return the peer context
  */
 struct PeerContext *
-GNUNET_TRANSPORT_TESTING_start_peer (struct GNUNET_TRANSPORT_TESTING_handle * tth,
-                                     const char *cfgname,
-                                     int peer_id,
+GNUNET_TRANSPORT_TESTING_start_peer (struct GNUNET_TRANSPORT_TESTING_handle
+                                     *tth, const char *cfgname, int peer_id,
                                      GNUNET_TRANSPORT_ReceiveCallback rec,
                                      GNUNET_TRANSPORT_NotifyConnect nc,
                                      GNUNET_TRANSPORT_NotifyDisconnect nd,
                                      GNUNET_TRANSPORT_TESTING_start_cb start_cb,
                                      void *cb_cls)
 {
+  const char *hostkey = NULL;
+  struct GNUNET_DISK_FileHandle *fn;
+
   GNUNET_assert (tth != NULL);
   if (GNUNET_DISK_file_test (cfgname) == GNUNET_NO)
   {
     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
-        "File not found: `%s' \n", cfgname);
+                     "File not found: `%s' \n", cfgname);
     return NULL;
   }
 
   struct PeerContext *p = GNUNET_malloc (sizeof (struct PeerContext));
 
   p->cfg = GNUNET_CONFIGURATION_create ();
-
   GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+
   if (GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
-    GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME",
-                                           &p->servicehome));
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_CONFIGURATION_get_value_string (p->cfg, "PATHS",
+                                                          "SERVICEHOME",
+                                                          &p->servicehome));
+
   if (NULL != p->servicehome)
     GNUNET_DISK_directory_remove (p->servicehome);
+
+  hostkey = get_host_key (tth);
+  if (hostkey != NULL)
+  {
+
+    GNUNET_asprintf (&p->hostkeyfile, "%s/.hostkey", p->servicehome);
+    GNUNET_assert (GNUNET_OK ==
+                   GNUNET_DISK_directory_create_for_file (p->hostkeyfile));
+    fn = GNUNET_DISK_file_open (p->hostkeyfile,
+                                GNUNET_DISK_OPEN_READWRITE |
+                                GNUNET_DISK_OPEN_CREATE,
+                                GNUNET_DISK_PERM_USER_READ |
+                                GNUNET_DISK_PERM_USER_WRITE);
+    GNUNET_assert (fn != NULL);
+    GNUNET_assert (HOSTKEYFILESIZE ==
+                   GNUNET_DISK_file_write (fn, hostkey, HOSTKEYFILESIZE));
+    GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fn));
+    GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                     "Wrote hostkey to file: `%s' \n", p->hostkeyfile);
+  }
+
   p->arm_proc =
       GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
                                "gnunet-service-arm", "-c", cfgname,
@@ -286,17 +346,131 @@ GNUNET_TRANSPORT_TESTING_start_peer (struct GNUNET_TRANSPORT_TESTING_handle * tt
   p->ghh = GNUNET_TRANSPORT_get_hello (p->th, &get_hello, p);
   GNUNET_assert (p->ghh != NULL);
 
-  GNUNET_CONTAINER_DLL_insert(tth->p_head, tth->p_tail, p);
+  GNUNET_CONTAINER_DLL_insert (tth->p_head, tth->p_tail, p);
 
   return p;
 }
 
+/**
+* Restart the given peer
+* @param tth testing handle
+* @param p the peer
+* @param cfgname the cfg file used to restart
+* @param restart_cb callback to call when restarted
+* @param cb_cls callback closure
+* @return GNUNET_OK in success otherwise GNUNET_SYSERR
+*/
+int
+GNUNET_TRANSPORT_TESTING_restart_peer (struct GNUNET_TRANSPORT_TESTING_handle
+                                       *tth, struct PeerContext *p,
+                                       const char *cfgname,
+                                       GNUNET_TRANSPORT_TESTING_start_cb
+                                       restart_cb, void *cb_cls)
+{
+  struct GNUNET_DISK_FileHandle *fn;
+
+  GNUNET_assert (tth != NULL);
+  GNUNET_assert (p != NULL);
+  GNUNET_assert (p->hostkeyfile != NULL);
+  GNUNET_assert (p->servicehome != NULL);
+
+  /* shutdown */
+#if VERBOSE
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                   "Stopping peer %u (`%s')\n", p->no, GNUNET_i2s (&p->id));
+#endif
+  if (p->ghh != NULL)
+    GNUNET_TRANSPORT_get_hello_cancel (p->ghh);
+  p->ghh = NULL;
+
+  if (p->th != NULL)
+    GNUNET_TRANSPORT_disconnect (p->th);
+
+  if (NULL != p->arm_proc)
+  {
+    if (0 != GNUNET_OS_process_kill (p->arm_proc, SIGTERM))
+      GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
+    GNUNET_OS_process_wait (p->arm_proc);
+    GNUNET_OS_process_close (p->arm_proc);
+    p->arm_proc = NULL;
+  }
+  if (p->hello != NULL)
+    GNUNET_free (p->hello);
+  p->hello = NULL;
+
+  if (p->cfg != NULL)
+    GNUNET_CONFIGURATION_destroy (p->cfg);
+  p->cfg = NULL;
+
+
+  /* start */
+#if VERBOSE
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                   "Restarting peer %u (`%s')\n", p->no, GNUNET_i2s (&p->id));
+#endif
+
+  sleep (5);                    // YUCK!
+
+  if (GNUNET_DISK_file_test (cfgname) == GNUNET_NO)
+  {
+    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
+                     "File not found: `%s' \n", cfgname);
+    goto fail;
+  }
+
+  p->cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+
+  if (!GNUNET_CONFIGURATION_have_value (p->cfg, "PATHS", "SERVICEHOME"))
+    goto fail;
+
+  fn = GNUNET_DISK_file_open (p->hostkeyfile,
+                              GNUNET_DISK_OPEN_READWRITE |
+                              GNUNET_DISK_OPEN_CREATE,
+                              GNUNET_DISK_PERM_USER_READ |
+                              GNUNET_DISK_PERM_USER_WRITE);
+  if (fn == NULL)
+    goto fail;
+  if (GNUNET_OK != GNUNET_DISK_file_close (fn))
+    goto fail;
+
+  p->arm_proc =
+      GNUNET_OS_start_process (NULL, NULL, "gnunet-service-arm",
+                               "gnunet-service-arm", "-c", cfgname,
+#if VERBOSE_PEERS
+                               "-L", "DEBUG",
+#else
+                               "-L", "ERROR",
+#endif
+                               NULL);
+
+  p->th =
+      GNUNET_TRANSPORT_connect (p->cfg, NULL, p, &notify_receive,
+                                &notify_connect, &notify_disconnect);
+  GNUNET_assert (p->th != NULL);
+
+  p->start_cb = restart_cb;
+  p->cb_cls = cb_cls;
+
+  p->ghh = GNUNET_TRANSPORT_get_hello (p->th, &get_hello, p);
+  GNUNET_assert (p->ghh != NULL);
+  return GNUNET_OK;
+
+fail:
+  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                   "Restarting peer %u (`%s') failed, removing peer\n", p->no,
+                   GNUNET_i2s (&p->id));
+  GNUNET_TRANSPORT_TESTING_stop_peer (tth, p);
+  return GNUNET_SYSERR;
+}
+
 /**
  * shutdown the given peer
+ * @param tth testing handle
  * @param p the peer
  */
 void
-GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_handle * tth,
+GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_handle *tth,
                                     struct PeerContext *p)
 {
   GNUNET_assert (p != NULL);
@@ -317,6 +491,12 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_handle * tth
     p->arm_proc = NULL;
   }
 
+  if (p->hostkeyfile != NULL)
+  {
+    GNUNET_DISK_directory_remove (p->hostkeyfile);
+    GNUNET_free (p->hostkeyfile);
+  }
+
   if (p->servicehome != NULL)
   {
     GNUNET_DISK_directory_remove (p->servicehome);
@@ -325,9 +505,11 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_handle * tth
 
   if (p->hello != NULL)
     GNUNET_free (p->hello);
+  p->hello = NULL;
 
   if (p->cfg != NULL)
     GNUNET_CONFIGURATION_destroy (p->cfg);
+  p->cfg = NULL;
 
   GNUNET_CONTAINER_DLL_remove (tth->p_head, tth->p_tail, p);
 
@@ -342,16 +524,16 @@ GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_handle * tth
  * @param p1 peer 1
  * @param p2 peer 2
  * @param cb the callback to call when both peers notified that they are connected
- * @param cb_cls callback cls
+ * @param cb_cls callback cls (or a pointer to the
+ *        GNUNET_TRANSPORT_TESTING_ConnectRequest itself if null)
  * @return connect context
  */
 GNUNET_TRANSPORT_TESTING_ConnectRequest
-GNUNET_TRANSPORT_TESTING_connect_peers (struct GNUNET_TRANSPORT_TESTING_handle * tth,
-                                        struct PeerContext *p1,
+GNUNET_TRANSPORT_TESTING_connect_peers (struct GNUNET_TRANSPORT_TESTING_handle
+                                        *tth, struct PeerContext *p1,
                                         struct PeerContext *p2,
                                         GNUNET_TRANSPORT_TESTING_connect_cb cb,
                                         void *cb_cls)
-
 {
   GNUNET_assert (tth != NULL);
 
@@ -365,7 +547,10 @@ GNUNET_TRANSPORT_TESTING_connect_peers (struct GNUNET_TRANSPORT_TESTING_handle *
   cc->p2 = p2;
 
   cc->cb = cb;
-  cc->cb_cls = cb_cls;
+  if (cb_cls != NULL)
+    cc->cb_cls = cb_cls;
+  else
+    cc->cb_cls = cc;
 
   cc->th_p1 = p1->th;
   cc->th_p2 = p2->th;
@@ -377,7 +562,7 @@ GNUNET_TRANSPORT_TESTING_connect_peers (struct GNUNET_TRANSPORT_TESTING_handle *
 
   cc->tct = GNUNET_SCHEDULER_add_now (&try_connect, cc);
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-      "New connect request %X\n", cc);
+                   "New connect request %X\n", cc);
 
   return cc;
 }
@@ -385,21 +570,26 @@ GNUNET_TRANSPORT_TESTING_connect_peers (struct GNUNET_TRANSPORT_TESTING_handle *
 /**
  * Cancel the request to connect two peers
  * Tou MUST cancel the request if you stop the peers before the peers connected succesfully
- * @param cc a connect request handle
+ *
+ * @param tth transport testing handle
+ * @param ccr a connect request handle
  */
-void GNUNET_TRANSPORT_TESTING_connect_peers_cancel
-    (struct GNUNET_TRANSPORT_TESTING_handle * tth,
-        GNUNET_TRANSPORT_TESTING_ConnectRequest ccr)
+void
+GNUNET_TRANSPORT_TESTING_connect_peers_cancel (struct
+                                               GNUNET_TRANSPORT_TESTING_handle
+                                               *tth,
+                                               GNUNET_TRANSPORT_TESTING_ConnectRequest
+                                               ccr)
 {
   struct ConnectingContext *cc = ccr;
 
   GNUNET_assert (tth != NULL);
 
   GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-      "Canceling connect request %X!\n", cc);
+                   "Canceling connect request %X!\n", cc);
+
   if (cc->tct != GNUNET_SCHEDULER_NO_TASK)
     GNUNET_SCHEDULER_cancel (cc->tct);
-
   cc->tct = GNUNET_SCHEDULER_NO_TASK;
 
   GNUNET_CONTAINER_DLL_remove (tth->cc_head, tth->cc_tail, cc);
@@ -412,7 +602,7 @@ void GNUNET_TRANSPORT_TESTING_connect_peers_cancel
  * @param tth transport testing handle
  */
 void
-GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_handle * tth)
+GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_handle *tth)
 {
   struct ConnectingContext *cc = tth->cc_head;
   struct ConnectingContext *ct = NULL;
@@ -425,8 +615,8 @@ GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_handle * tth)
   {
     ct = cc->next;
     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
-        "Developer forgot to cancel connect request %X!\n", cc);
-    GNUNET_TRANSPORT_TESTING_connect_peers_cancel(tth, cc);
+                     "Developer forgot to cancel connect request %X!\n", cc);
+    GNUNET_TRANSPORT_TESTING_connect_peers_cancel (tth, cc);
     cc = ct;
   }
 
@@ -434,11 +624,13 @@ GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_handle * tth)
   {
     t = p->next;
     GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
-        "Developer forgot to stop peer!\n");
+                     "Developer forgot to stop peer!\n");
     GNUNET_TRANSPORT_TESTING_stop_peer (tth, p);
     p = t;
   }
 
+  GNUNET_free_non_null (tth->hostkey_data);
+
   GNUNET_free (tth);
   tth = NULL;
 }
@@ -450,7 +642,52 @@ GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_handle * tth)
 struct GNUNET_TRANSPORT_TESTING_handle *
 GNUNET_TRANSPORT_TESTING_init ()
 {
-  struct GNUNET_TRANSPORT_TESTING_handle * tth = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TESTING_handle));
+  struct GNUNET_TRANSPORT_TESTING_handle *tth;
+  struct GNUNET_DISK_FileHandle *fd;
+  uint64_t fs;
+  uint64_t total_hostkeys;
+
+
+  /* prepare hostkeys */
+  tth = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TESTING_handle));
+  tth->hostkey_data = NULL;
+  const char *hostkeys_file = "../../contrib/testing_hostkeys.dat";
+
+  if (GNUNET_YES != GNUNET_DISK_file_test (hostkeys_file))
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR, _("Could not read hostkeys file!\n"));
+  }
+  else
+  {
+    /* Check hostkey file size, read entire thing into memory */
+    fd = GNUNET_DISK_file_open (hostkeys_file, GNUNET_DISK_OPEN_READ,
+                                GNUNET_DISK_PERM_NONE);
+    if (NULL == fd)
+    {
+      GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "open", hostkeys_file);
+      GNUNET_free (tth);
+      return NULL;
+    }
+
+    if (GNUNET_YES != GNUNET_DISK_file_size (hostkeys_file, &fs, GNUNET_YES))
+      fs = 0;
+
+    if (0 != (fs % HOSTKEYFILESIZE))
+    {
+      GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
+                       "File size %llu seems incorrect for hostkeys...\n", fs);
+    }
+    else
+    {
+      total_hostkeys = fs / HOSTKEYFILESIZE;
+      tth->hostkey_data = GNUNET_malloc_large (fs);
+      GNUNET_assert (fs == GNUNET_DISK_file_read (fd, tth->hostkey_data, fs));
+      GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
+                       "Read %llu hostkeys from file\n", total_hostkeys);
+      tth->hostkeys_total = total_hostkeys;
+    }
+    GNUNET_assert (GNUNET_OK == GNUNET_DISK_file_close (fd));
+  }
 
   return tth;
 }
@@ -601,8 +838,9 @@ suc:
 /**
  * This function takes the filename (e.g. argv[0), removes a "lt-"-prefix and
  * if existing ".exe"-prefix and adds the peer-number
+ *
  * @param file filename of the test, e.g. argv[0]
- * @param cfgname where to write the result
+ * @param dest where to write the filename
  * @param count peer number
  */
 void