projects / oweals / gnunet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
migrate more tests to new transmission API
[oweals/gnunet.git] / src / transport / transport-testing.c
diff --git a/src/transport/transport-testing.c b/src/transport/transport-testing.c
index 66844de312bbe8f3b932dabe764ff390ff02642c..50c297389126da68b1d3165a796ed25117b8b3e9 100644 (file)
--- a/src/transport/transport-testing.c
+++ b/src/transport/transport-testing.c
@@ -1,10 +1,10 @@
 /*
      This file is part of GNUnet.
 /*
      This file is part of GNUnet.
-     (C) 2006, 2009 Christian Grothoff (and other contributing authors)
+     Copyright (C) 2006, 2009, 2015, 2016 GNUnet e.V.
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
 
      GNUnet is free software; you can redistribute it and/or modify
      it under the terms of the GNU General Public License as published
-     by the Free Software Foundation; either version 2, or (at your
+     by the Free Software Foundation; either version 3, or (at your
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
      option) any later version.
 
      GNUnet is distributed in the hope that it will be useful, but
@@ -14,642 +14,818 @@
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
 
      You should have received a copy of the GNU General Public License
      along with GNUnet; see the file COPYING.  If not, write to the
-     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-     Boston, MA 02111-1307, USA.
+     Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+     Boston, MA 02110-1301, USA.
 */
 */
-
 /**
  * @file transport-testing.c
  * @brief testing lib for transport service
 /**
  * @file transport-testing.c
  * @brief testing lib for transport service
- *
  * @author Matthias Wachs
  * @author Matthias Wachs
+ * @author Christian Grothoff
  */
  */
-
 #include "transport-testing.h"
 
 #include "transport-testing.h"
 
-#define VERBOSE GNUNET_YES
 
 
-struct PeerContext *
-find_peer_context_by_pc ( struct GNUNET_TRANSPORT_TESTING_handle *tth,
-                          struct PeerContext *p)
-{
-  GNUNET_assert (tth != NULL);
-  struct PeerContext * t = tth->p_head;
+#define LOG(kind,...) GNUNET_log_from(kind, "transport-testing", __VA_ARGS__)
 
 
-  while (t != NULL)
-  {
-    if (p == t)
-      break;
-    t = t->next;
-  }
 
 
-  return t;
+static struct GNUNET_TRANSPORT_TESTING_PeerContext *
+find_peer_context (struct GNUNET_TRANSPORT_TESTING_Handle *tth,
+                   const struct GNUNET_PeerIdentity *peer)
+{
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *t;
+
+  for (t = tth->p_head; NULL != t; t = t->next)
+    if (0 == memcmp (&t->id,
+                     peer,
+                     sizeof (struct GNUNET_PeerIdentity)))
+      return t;
+  return NULL;
 }
 
 
 }
 
 
-struct PeerContext *
-find_peer_context ( struct GNUNET_TRANSPORT_TESTING_handle *tth,
-                    const struct GNUNET_PeerIdentity *peer)
+/**
+ * Find any connecting context matching the given pair of peers.
+ *
+ * @param p1 first peer
+ * @param p2 second peer
+ * @param cb function to call 
+ * @param cb_cls closure for @a cb
+ */
+void
+GNUNET_TRANSPORT_TESTING_find_connecting_context (struct GNUNET_TRANSPORT_TESTING_PeerContext *p1,
+                                                 struct GNUNET_TRANSPORT_TESTING_PeerContext *p2,
+                                                 GNUNET_TRANSPORT_TESTING_ConnectContextCallback cb,
+                                                 void *cb_cls)
 {
 {
-  GNUNET_assert (tth != NULL);
-  struct PeerContext * t = tth->p_head;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
 
 
-  while (t != NULL)
+  for (cc = tth->cc_head; NULL != cc; cc = ccn)
   {
   {
-    if (0 == memcmp (&t->id, peer, sizeof (struct GNUNET_PeerIdentity)))
-      break;
-    t = t->next;
+    ccn = cc->next;
+    if ( (cc->p1 == p1) &&
+        (cc->p2 == p2) ) 
+      cb (cb_cls,
+         cc);
   }
   }
+}
 
 
-  return t;
+
+static void
+set_p1c (void *cls,   
+        struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  cx->p1_c = GNUNET_YES;
 }
 
 }
 
-struct ConnectingContext *
-find_connecting_context ( struct GNUNET_TRANSPORT_TESTING_handle *tth,
-                          struct PeerContext *p1,
-                          struct PeerContext * p2)
+
+static void
+set_p2c (void *cls,   
+        struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
 {
 {
-  GNUNET_assert (tth != NULL);
-  struct ConnectingContext * cc = tth->cc_head;
+  cx->p2_c = GNUNET_YES;
+}
 
 
-  while (cc != NULL)
-  {
-    if ((cc->p1 == p1) && (cc->p2 == p2))
-        break;
-    if ((cc->p1 == p2) && (cc->p2 == p1))
-      break;
-    cc = cc->next;
-  }
 
 
-  return cc;
+static void
+clear_p1c (void *cls,   
+          struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
+{
+  cx->p1_c = GNUNET_NO;
 }
 
 }
 
+
 static void
 static void
-notify_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
-                const struct GNUNET_ATS_Information *ats,
-                uint32_t ats_count)
+clear_p2c (void *cls,   
+        struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cx)
 {
 {
-  struct PeerContext *p = cls;
-  /* Find PeerContext */
-  GNUNET_assert (p->tth != NULL);
-  struct PeerContext * p2 = find_peer_context (p->tth, peer);
+  cx->p2_c = GNUNET_NO;
+}
 
 
-  if (p == NULL)
-    return;
-  if (p->nc != NULL)
-    p->nc (p->cb_cls, peer, ats, ats_count);
 
 
-#if VERBOSE
-  char * p2_s;
+static void
+notify_connect (void *cls,
+                const struct GNUNET_PeerIdentity *peer)
+{
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
+  char *p2_s;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+
+  p2 = find_peer_context (p->tth,
+                          peer);
+  if (NULL != p->nc)
+    p->nc (p->cb_cls,
+           peer);
+
   if (p2 != NULL)
   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
   else
-    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));
+    GNUNET_asprintf (&p2_s,
+                     "`%s'",
+                     GNUNET_i2s (peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peers %s connected to peer %u (`%s')\n",
+       p2_s,
+       p->no,
+       GNUNET_i2s (&p->id));
   GNUNET_free (p2_s);
   GNUNET_free (p2_s);
-#endif
-
-
-  /* Find ConnectingContext */
-  struct ConnectingContext * cc = find_connecting_context(p->tth, p, p2);
-  if (cc == NULL)
-    return;
-
-  if (p == cc->p1)
-    cc->p1_c = GNUNET_YES;
-
-  if (p == cc->p2)
-      cc->p2_c = GNUNET_YES;
-
-  if ((cc->p1_c == GNUNET_YES) && (cc->p2_c == GNUNET_YES))
+  /* update flags in connecting contexts */
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
+                                                   p2,
+                                                   &set_p1c,
+                                                   NULL);
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p2,
+                                                   p,
+                                                   &set_p2c,
+                                                   NULL);
+  /* update set connected flag for all requests */
+  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
   {
   {
-    cc->cb (cc->p1, cc->p2, cc->cb_cls);
-    GNUNET_TRANSPORT_TESTING_connect_peers_cancel(p->tth, cc);
+    if (GNUNET_YES == cc->connected)
+      continue;
+    if ( (GNUNET_YES == cc->p1_c) &&
+         (GNUNET_YES == cc->p2_c) )
+    {
+      cc->connected = GNUNET_YES;
+      /* stop trying to connect */
+      if (NULL != cc->tct)
+      {
+       GNUNET_SCHEDULER_cancel (cc->tct);
+       cc->tct = NULL;
+      }
+      if (NULL != cc->oh)
+      {
+       GNUNET_TRANSPORT_offer_hello_cancel (cc->oh);
+       cc->oh = NULL;
+      }
+      if (NULL != cc->ats_sh)
+      {
+       GNUNET_ATS_connectivity_suggest_cancel (cc->ats_sh);
+       cc->ats_sh = NULL;
+      }
+    }
+  }
+  /* then notify application */
+  for (cc = tth->cc_head; NULL != cc; cc = ccn)
+  {
+    ccn = cc->next;
+    if ( (GNUNET_YES == cc->connected) &&
+         (NULL != cc->cb) )
+    {
+      cc->cb (cc->cb_cls);
+      cc->cb = NULL; /* only notify once! */
+    }
   }
 }
 
   }
 }
 
+
+/**
+ * Offer the current HELLO of P2 to P1.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectRequest`
+ */
 static void
 static void
-notify_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
+offer_hello (void *cls);
+
+
+static void
+notify_disconnect (void *cls,
+                   const struct GNUNET_PeerIdentity *peer)
 {
 {
-  struct PeerContext *p = cls;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
+  char *p2_s;
   /* Find PeerContext */
   /* Find PeerContext */
-  GNUNET_assert (p->tth != NULL);
-  struct PeerContext * p2 = find_peer_context (p->tth, peer);
-
-  char * p2_s;
-  if (p2 != NULL)
-    GNUNET_asprintf(&p2_s, "%u (`%s')", p2->no, GNUNET_i2s (&p2->id));
+  int no = 0;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = NULL;
+  struct TRANSPORT_TESTING_SendJob *sj;
+  struct TRANSPORT_TESTING_SendJob *sjn;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  
+  p2 = find_peer_context (p->tth,
+                         peer);
+  no = p->no;
+  if (NULL != p2)
+    GNUNET_asprintf (&p2_s,
+                     "%u (`%s')",
+                     p2->no,
+                     GNUNET_i2s (&p2->id));
   else
   else
-    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,
-      p->no, GNUNET_i2s (&p->id));
+    GNUNET_asprintf (&p2_s,
+                     "`%s'",
+                     GNUNET_i2s (peer));
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peers %s disconnected from peer %u (`%s')\n",
+       p2_s,
+       no,
+       GNUNET_i2s (&p->id));
   GNUNET_free (p2_s);
   GNUNET_free (p2_s);
-
-  if (p == NULL)
+  /* notify about disconnect */
+  if (NULL != p->nd)
+    p->nd (p->cb_cls,
+           peer);
+  if (NULL == p2)
     return;
     return;
-  if (p->nd != NULL)
-    p->nd (p->cb_cls, peer);
+  /* abort all transmissions this disconnected pair is involved in */
+  for (sj = tth->sj_head; NULL != sj; sj = sjn)
+  {
+    sjn = sj->next;
+    if ( ( (sj->sender == p2) &&
+          (sj->receiver == p) ) ||
+        ( (sj->receiver == p2) &&
+          (sj->sender == p) ) )
+    {
+      GNUNET_CONTAINER_DLL_remove (tth->sj_head,
+                                  tth->sj_tail,
+                                  sj);
+      GNUNET_TRANSPORT_notify_transmit_ready_cancel (sj->th);
+      GNUNET_free (sj);
+    }
+  }
+  /* update set connected flags for all requests */
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p,
+                                                   p2,
+                                                   &clear_p1c,
+                                                   NULL);
+  GNUNET_TRANSPORT_TESTING_find_connecting_context (p2,
+                                                   p,
+                                                   &clear_p2c,
+                                                   NULL);
+  /* resume connectivity requests as necessary */
+  for (cc = tth->cc_head; NULL != cc; cc = cc->next)
+  {
+    if (GNUNET_NO == cc->connected)
+      continue;
+    if ( (GNUNET_YES != cc->p1_c) ||
+         (GNUNET_YES != cc->p2_c) )
+    {
+      cc->connected = GNUNET_NO;
+      /* start trying to connect */
+      if ( (NULL == cc->tct) &&
+          (NULL == cc->oh) )
+       cc->tct = GNUNET_SCHEDULER_add_now (&offer_hello,
+                                           cc);
+      if (NULL == cc->ats_sh)
+       cc->ats_sh = GNUNET_ATS_connectivity_suggest (cc->p1->ats,
+                                                     &p2->id,
+                                                     1);
+    }
+  }
 }
 
 }
 
+
 static void
 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)
+notify_receive (void *cls,
+                const struct GNUNET_PeerIdentity *peer,
+                const struct GNUNET_MessageHeader *message)
 {
 {
-  struct PeerContext *p = cls;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cls;
 
 
-  if (p == NULL)
+  if (NULL == p)
     return;
     return;
-  if (p->rec != NULL)
-    p->rec (p->cb_cls, peer, message, ats, ats_count);
+  if (NULL != p->rec)
+    p->rec (p->cb_cls,
+            peer,
+            message);
 }
 
 }
 
+
 static void
 static void
-get_hello (void *cb_cls, const struct GNUNET_MessageHeader *message)
+get_hello (void *cb_cls,
+           const struct GNUNET_MessageHeader *message)
 {
 {
-  struct PeerContext *p = cb_cls;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p = cb_cls;
+  struct GNUNET_PeerIdentity hello_id;
 
 
-  GNUNET_assert (message != NULL);
   GNUNET_assert (GNUNET_OK ==
   GNUNET_assert (GNUNET_OK ==
-                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *)
-                                      message, &p->id));
-
-  if (p->hello != NULL)
-    GNUNET_free (p->hello);
-
-  size_t size = GNUNET_HELLO_size((const struct GNUNET_HELLO_Message *) message);
-  p->hello = GNUNET_malloc (size);
-  memcpy (p->hello,
-        (const struct GNUNET_HELLO_Message *) message,
-        size);
-
-#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);
-#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));
-#endif
-    p->start_cb(p, p->cb_cls);
+                 GNUNET_HELLO_get_id ((const struct GNUNET_HELLO_Message *) message,
+                                      &hello_id));
+  GNUNET_assert (0 == memcmp (&hello_id,
+                              &p->id,
+                              sizeof (hello_id)));
+  GNUNET_free_non_null (p->hello);
+  p->hello = (struct GNUNET_HELLO_Message *) GNUNET_copy_message (message);
+
+  if (NULL != p->start_cb)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "Peer %u (`%s') successfully started\n",
+         p->no,
+         GNUNET_i2s (&p->id));
+    p->start_cb (p,
+                 p->start_cb_cls);
     p->start_cb = NULL;
   }
 }
 
 
     p->start_cb = NULL;
   }
 }
 
 
-static void
-try_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct ConnectingContext *cc = cls;
-  struct PeerContext *p1 = cc->p1;
-  struct PeerContext *p2 = cc->p2;
-
-  cc->tct = GNUNET_SCHEDULER_NO_TASK;
-  if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0)
-    return;
-
-  char * p2_s = GNUNET_strdup(GNUNET_i2s (&p2->id));
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-      "Asking peers %u (`%s') to connect peer %u (`%s')\n",
-      p1->no, GNUNET_i2s (&p1->id), p2->no, p2_s);
-  GNUNET_free (p2_s);
-
-  GNUNET_TRANSPORT_offer_hello (cc->th_p1,
-      (const struct GNUNET_MessageHeader *) cc->p2->hello, NULL, NULL);
-  GNUNET_TRANSPORT_try_connect (cc->th_p1, &p2->id);
-
-  cc->tct =
-      GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &try_connect, cc);
-}
-
-
 /**
  * Start a peer with the given configuration
 /**
  * Start a peer with the given configuration
+ * @param tth the testing handle
+ * @param cfgname configuration file
+ * @param peer_id a unique number to identify the peer
  * @param rec receive callback
  * @param nc connect callback
  * @param nd disconnect callback
  * @param cb_cls closure for callback
  * @param rec receive callback
  * @param nc connect callback
  * @param nd disconnect callback
  * @param cb_cls closure for callback
+ * @param start_cb start callback
+ * @param start_cb_cls closure for callback
  * @return the peer context
  */
  * @return the peer context
  */
-struct PeerContext *
-GNUNET_TRANSPORT_TESTING_start_peer (struct GNUNET_TRANSPORT_TESTING_handle * tth,
+struct GNUNET_TRANSPORT_TESTING_PeerContext *
+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,
                                      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)
+                                    void *cb_cls,
+                                     GNUNET_TRANSPORT_TESTING_StartCallback start_cb,
+                                     void *start_cb_cls)
 {
 {
-  GNUNET_assert (tth != NULL);
-  if (GNUNET_DISK_file_test (cfgname) == GNUNET_NO)
+  char *emsg = NULL;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p;
+  struct GNUNET_PeerIdentity *dummy;
+
+  if (GNUNET_NO == GNUNET_DISK_file_test (cfgname))
   {
   {
-    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
-        "File not found: `%s' \n", cfgname);
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "File not found: `%s'\n",
+         cfgname);
     return NULL;
   }
 
     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_CONFIGURATION_get_value_string (p->cfg, "PATHS", "SERVICEHOME",
-                                           &p->servicehome);
-  if (NULL != p->servicehome)
-    GNUNET_DISK_directory_remove (p->servicehome);
-  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->no = peer_id;
+  p = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_PeerContext);
   p->tth = tth;
   p->nc = nc;
   p->nd = nd;
   p->rec = rec;
   p->tth = tth;
   p->nc = nc;
   p->nd = nd;
   p->rec = rec;
-  p->start_cb = start_cb;
-  if (cb_cls != NULL)
+  if (NULL != cb_cls)
     p->cb_cls = cb_cls;
   else
     p->cb_cls = p;
     p->cb_cls = cb_cls;
   else
     p->cb_cls = p;
+  p->start_cb = start_cb;
+  p->start_cb_cls = start_cb_cls;
+  GNUNET_CONTAINER_DLL_insert (tth->p_head,
+                               tth->p_tail,
+                               p);
 
 
-  p->th =
-      GNUNET_TRANSPORT_connect (p->cfg, NULL, p, &notify_receive,
-                                &notify_connect, &notify_disconnect);
-  GNUNET_assert (p->th != NULL);
-
-  p->ghh = GNUNET_TRANSPORT_get_hello (p->th, &get_hello, p);
-  GNUNET_assert (p->ghh != NULL);
+  /* Create configuration and call testing lib to modify it */
+  p->cfg = GNUNET_CONFIGURATION_create ();
+  GNUNET_assert (GNUNET_OK ==
+                 GNUNET_CONFIGURATION_load (p->cfg, cfgname));
+  if (GNUNET_SYSERR ==
+      GNUNET_TESTING_configuration_create (tth->tl_system,
+                                           p->cfg))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s'\n",
+         cfgname);
+    GNUNET_CONFIGURATION_destroy (p->cfg);
+    GNUNET_free (p);
+    return NULL;
+  }
 
 
-  GNUNET_CONTAINER_DLL_insert(tth->p_head, tth->p_tail, p);
+  p->no = peer_id;
+  /* Configure peer with configuration */
+  p->peer = GNUNET_TESTING_peer_configure (tth->tl_system,
+                                           p->cfg,
+                                           p->no,
+                                           NULL,
+                                           &emsg);
+  if (NULL == p->peer)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s': `%s'\n",
+         cfgname,
+         emsg);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    GNUNET_free_non_null (emsg);
+    return NULL;
+  }
+  GNUNET_free_non_null (emsg);
+  if (GNUNET_OK != GNUNET_TESTING_peer_start (p->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to create unique configuration based on `%s'\n",
+         cfgname);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    return NULL;
+  }
 
 
+  memset (&dummy,
+          '\0',
+          sizeof (dummy));
+  GNUNET_TESTING_peer_get_identity (p->peer,
+                                    &p->id);
+  if (0 == memcmp (&dummy,
+                   &p->id,
+                   sizeof (struct GNUNET_PeerIdentity)))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Testing library failed to obtain peer identity for peer %u\n",
+         p->no);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    return NULL;
+  }
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %u configured with identity `%s'\n",
+       p->no,
+       GNUNET_i2s_full (&p->id));
+
+  p->th = GNUNET_TRANSPORT_connect (p->cfg,
+                                    NULL,
+                                    p,
+                                    &notify_receive,
+                                    &notify_connect,
+                                    &notify_disconnect);
+  if (NULL == p->th)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to connect to transport service for peer `%s': `%s'\n",
+         cfgname,
+         emsg);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    return NULL;
+  }
+  p->ats = GNUNET_ATS_connectivity_init (p->cfg);
+  if (NULL == p->ats)
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to connect to ATS service for peer `%s': `%s'\n",
+         cfgname,
+         emsg);
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    return NULL;
+  }
+  p->ghh = GNUNET_TRANSPORT_get_hello (p->cfg,
+                                       &get_hello,
+                                       p);
+  GNUNET_assert (p->ghh != NULL);
   return p;
 }
 
   return p;
 }
 
+
 /**
 /**
- * shutdown the given peer
+ * Stops and restarts the given peer, sleeping (!) for 5s in between.
+ *
  * @param p the peer
  * @param p the peer
+ * @param restart_cb callback to call when restarted
+ * @param restart_cb_cls callback closure
+ * @return #GNUNET_OK in success otherwise #GNUNET_SYSERR
  */
  */
-void
-GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_handle * tth,
-                                    struct PeerContext *p)
+int
+GNUNET_TRANSPORT_TESTING_restart_peer (struct GNUNET_TRANSPORT_TESTING_PeerContext *p,
+                                       GNUNET_TRANSPORT_TESTING_StartCallback restart_cb,
+                                       void *restart_cb_cls)
 {
 {
-  GNUNET_assert (p != NULL);
-
-  if (p->ghh != NULL)
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
+ 
+  /* shutdown */
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Stopping peer %u (`%s')\n",
+       p->no,
+       GNUNET_i2s (&p->id));
+  if (NULL != p->ghh)
+  {
     GNUNET_TRANSPORT_get_hello_cancel (p->ghh);
     GNUNET_TRANSPORT_get_hello_cancel (p->ghh);
-  p->ghh = NULL;
-
-  if (p->th != NULL)
+    p->ghh = NULL;
+  }
+  if (NULL != p->th)
+  {
     GNUNET_TRANSPORT_disconnect (p->th);
     GNUNET_TRANSPORT_disconnect (p->th);
-
-  if (NULL != p->arm_proc)
+    p->th = NULL;
+  }
+  for (cc = p->tth->cc_head; NULL != cc; cc = ccn)
   {
   {
-    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;
+    ccn = cc->next;
+    if ( (cc->p1 == p) ||
+         (cc->p2 == p) )
+      GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
   }
   }
-
-  if (p->servicehome != NULL)
+  if (NULL != p->ats)
   {
   {
-    GNUNET_DISK_directory_remove (p->servicehome);
-    GNUNET_free (p->servicehome);
+    GNUNET_ATS_connectivity_done (p->ats);
+    p->ats = NULL;
+  }
+  if (GNUNET_SYSERR ==
+      GNUNET_TESTING_peer_stop (p->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to stop peer %u (`%s')\n",
+         p->no,
+         GNUNET_i2s (&p->id));
+    return GNUNET_SYSERR;
   }
 
   }
 
-  if (p->hello != NULL)
-    GNUNET_free (p->hello);
-
-  if (p->cfg != NULL)
-    GNUNET_CONFIGURATION_destroy (p->cfg);
-
-  GNUNET_CONTAINER_DLL_remove (tth->p_head, tth->p_tail, p);
-
-  GNUNET_free (p);
-  p = NULL;
-}
-
-/**
- * Initiate peer p1 to connect to peer p2
- * Get peer p2's HELLO and offer it to p1
- * p1 then tries to connect to p2
- * @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
- * @return connect context
- */
-GNUNET_TRANSPORT_TESTING_ConnectRequest
-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);
-
-  struct ConnectingContext *cc =
-      GNUNET_malloc (sizeof (struct ConnectingContext));
-
-  GNUNET_assert (p1 != NULL);
-  GNUNET_assert (p2 != NULL);
-
-  cc->p1 = p1;
-  cc->p2 = p2;
-
-  cc->cb = cb;
-  cc->cb_cls = cb_cls;
-
-  cc->th_p1 = p1->th;
-  cc->th_p2 = p2->th;
-
-  GNUNET_assert (cc->th_p1 != NULL);
-  GNUNET_assert (cc->th_p2 != NULL);
-
-  GNUNET_CONTAINER_DLL_insert (tth->cc_head, tth->cc_tail, cc);
-
-  cc->tct = GNUNET_SCHEDULER_add_now (&try_connect, cc);
-  GNUNET_log_from (GNUNET_ERROR_TYPE_DEBUG, "transport-testing",
-      "New connect request %X\n", cc);
-
-  return cc;
-}
-
-/**
- * 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
- */
-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);
-  if (cc->tct != GNUNET_SCHEDULER_NO_TASK)
-    GNUNET_SCHEDULER_cancel (cc->tct);
+  sleep (5); // YUCK!
 
 
-  cc->tct = GNUNET_SCHEDULER_NO_TASK;
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Restarting peer %u (`%s')\n",
+       p->no,
+       GNUNET_i2s (&p->id));
+  /* restart */
+  if (GNUNET_SYSERR == GNUNET_TESTING_peer_start (p->peer))
+  {
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Failed to restart peer %u (`%s')\n",
+         p->no,
+         GNUNET_i2s (&p->id));
+    return GNUNET_SYSERR;
+  }
 
 
-  GNUNET_CONTAINER_DLL_remove (tth->cc_head, tth->cc_tail, cc);
-  GNUNET_free (cc);
+  GNUNET_assert (NULL == p->start_cb);
+  p->start_cb = restart_cb;
+  p->start_cb_cls = restart_cb_cls;
+
+  p->th = GNUNET_TRANSPORT_connect (p->cfg,
+                                    NULL,
+                                    p,
+                                    &notify_receive,
+                                    &notify_connect,
+                                    &notify_disconnect);
+  GNUNET_assert (NULL != p->th);
+  p->ats = GNUNET_ATS_connectivity_init (p->cfg);
+  p->ghh = GNUNET_TRANSPORT_get_hello (p->cfg,
+                                       &get_hello,
+                                       p);
+  GNUNET_assert (NULL != p->ghh);
+  return GNUNET_OK;
 }
 
 
 /**
 }
 
 
 /**
- * Clean up the transport testing
- * @param tth transport testing handle
+ * Shutdown the given peer
+ *
+ * @param p the peer
  */
 void
  */
 void
-GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_handle * tth)
+GNUNET_TRANSPORT_TESTING_stop_peer (struct GNUNET_TRANSPORT_TESTING_PeerContext *p)
 {
 {
-  struct ConnectingContext *cc = tth->cc_head;
-  struct ConnectingContext *ct = NULL;
-  struct PeerContext *p = tth->p_head;
-  struct PeerContext *t = NULL;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p->tth;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ccn;
 
 
-  GNUNET_assert (tth != NULL);
-
-  while (cc != tth->cc_tail)
+  for (cc = tth->cc_head; NULL != cc; cc = ccn)
   {
   {
-    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);
-    cc = ct;
+    ccn = cc->next;
+    if ( (cc->p1 == p) ||
+         (cc->p2 == p) )
+      GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
   }
   }
-
-  while (p != NULL)
+  if (NULL != p->ghh)
   {
   {
-    t = p->next;
-    GNUNET_log_from (GNUNET_ERROR_TYPE_ERROR, "transport-testing",
-        "Developer forgot to stop peer!\n");
-    GNUNET_TRANSPORT_TESTING_stop_peer (tth, p);
-    p = t;
+    GNUNET_TRANSPORT_get_hello_cancel (p->ghh);
+    p->ghh = NULL;
   }
   }
-
-  GNUNET_free (tth);
-  tth = NULL;
+  if (NULL != p->th)
+  {
+    GNUNET_TRANSPORT_disconnect (p->th);
+    p->th = NULL;
+  }
+  if (NULL != p->peer)
+  {
+    if (GNUNET_OK !=
+        GNUNET_TESTING_peer_stop (p->peer))
+    {
+      LOG (GNUNET_ERROR_TYPE_DEBUG,
+           "Testing lib failed to stop peer %u (`%s')\n",
+           p->no,
+           GNUNET_i2s (&p->id));
+    }
+    GNUNET_TESTING_peer_destroy (p->peer);
+    p->peer = NULL;
+  }
+  if (NULL != p->ats)
+  {
+    GNUNET_ATS_connectivity_done (p->ats);
+    p->ats = NULL;
+  }
+  if (NULL != p->hello)
+  {
+    GNUNET_free (p->hello);
+    p->hello = NULL;
+  }
+  if (NULL != p->cfg)
+  {
+    GNUNET_CONFIGURATION_destroy (p->cfg);
+    p->cfg = NULL;
+  }
+  GNUNET_CONTAINER_DLL_remove (tth->p_head,
+                               tth->p_tail,
+                               p);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Peer %u (`%s') stopped\n",
+       p->no,
+       GNUNET_i2s (&p->id));
+  GNUNET_free (p);
 }
 
 }
 
+
 /**
 /**
- * Initialize the transport testing
- * @return transport testing handle
+ * Function called after the HELLO was passed to the
+ * transport service.
  */
  */
-struct GNUNET_TRANSPORT_TESTING_handle *
-GNUNET_TRANSPORT_TESTING_init ()
+static void
+hello_offered (void *cls)
 {
 {
-  struct GNUNET_TRANSPORT_TESTING_handle * tth = GNUNET_malloc (sizeof (struct GNUNET_TRANSPORT_TESTING_handle));
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
 
 
-  return tth;
+  cc->oh = NULL;
+  cc->tct = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS,
+                                          &offer_hello,
+                                          cc);
 }
 
 
 }
 
 
-/*
- * Some utility functions
- */
-
 /**
 /**
- * Removes all directory separators from absolute filename
- * @param file the absolute file name, e.g. as found in argv[0]
- * @return extracted file name, has to be freed by caller
+ * Offer the current HELLO of P2 to P1.
+ *
+ * @param cls our `struct GNUNET_TRANSPORT_TESTING_ConnectRequest`
  */
  */
-char *
-extract_filename (const char *file)
+static void
+offer_hello (void *cls)
 {
 {
-  char *pch = GNUNET_strdup (file);
-  char *backup = pch;
-  char *filename = NULL;
-  char *res;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc = cls;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p1 = cc->p1;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p2 = cc->p2;
 
 
-  if (NULL != strstr (pch, "/"))
+  cc->tct = NULL;
   {
   {
-    pch = strtok (pch, "/");
-    while (pch != NULL)
-    {
-      pch = strtok (NULL, "/");
-      if (pch != NULL)
-      {
-        filename = pch;
-      }
-    }
+    char *p2_s = GNUNET_strdup (GNUNET_i2s (&p2->id));
+
+    LOG (GNUNET_ERROR_TYPE_DEBUG,
+         "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);
   }
   }
-  else
-    filename = pch;
 
 
-  res = GNUNET_strdup (filename);
-  GNUNET_free (backup);
-  return res;
+  if (NULL != cc->oh)
+    GNUNET_TRANSPORT_offer_hello_cancel (cc->oh);
+  cc->oh =
+    GNUNET_TRANSPORT_offer_hello (cc->p1->cfg,
+                                  (const struct GNUNET_MessageHeader *) cc->p2->hello,
+                                  &hello_offered,
+                                  cc);
 }
 
 }
 
+
 /**
 /**
- * Extracts the test filename from an absolute file name and removes the extension
- * @param file absolute file name
- * @param dest where to store result
+ * Initiate a connection from p1 to p2 by offering p1 p2's HELLO message
+ *
+ * Remarks: start_peer's notify_connect callback can be called before.
+ *
+ * @param tth transport testing handle
+ * @param p1 peer 1
+ * @param p2 peer 2
+ * @param cb the callback to call when both peers notified that they are connected
+ * @param cls callback cls
+ * @return a connect request handle
  */
  */
-void
-GNUNET_TRANSPORT_TESTING_get_test_name (const char *file, char **dest)
+struct GNUNET_TRANSPORT_TESTING_ConnectRequest *
+GNUNET_TRANSPORT_TESTING_connect_peers (struct GNUNET_TRANSPORT_TESTING_PeerContext *p1,
+                                        struct GNUNET_TRANSPORT_TESTING_PeerContext *p2,
+                                        GNUNET_SCHEDULER_TaskCallback cb,
+                                        void *cls)
 {
 {
-  char *filename = extract_filename (file);
-  char *backup = filename;
-  char *dotexe;
-
-  if (filename == NULL)
-    goto fail;
-
-  /* remove "lt-" */
-  filename = strstr (filename, "tes");
-  if (filename == NULL)
-    goto fail;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = p1->tth;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
 
 
-  /* remove ".exe" */
-  if (NULL != (dotexe = strstr (filename, ".exe")))
-    dotexe[0] = '\0';
-
-  goto suc;
-
-fail:
-  (*dest) = NULL;
-  return;
-
-suc:
-  /* create filename */
-  GNUNET_asprintf (dest, "%s", filename);
-  GNUNET_free (backup);
+  cc = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_ConnectRequest);
+  cc->p1 = p1;
+  cc->p2 = p2;
+  cc->cb = cb;
+  if (NULL != cls)
+    cc->cb_cls = cls;
+  else
+    cc->cb_cls = cc;
+  GNUNET_CONTAINER_DLL_insert (tth->cc_head,
+                               tth->cc_tail,
+                               cc);
+  cc->tct = GNUNET_SCHEDULER_add_now (&offer_hello,
+                                      cc);
+  cc->ats_sh = GNUNET_ATS_connectivity_suggest (cc->p1->ats,
+                                                &p2->id,
+                                                1);
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "New connect request %p\n",
+       cc);
+  return cc;
 }
 
 
 /**
 }
 
 
 /**
- * Extracts the filename from an absolute file name and removes the extension
- * @param file absolute file name
- * @param dest where to store result
+ * Cancel the request to connect two peers
+ * Tou MUST cancel the request if you stop the peers before the peers connected succesfully
+ *
+ * @param tth transport testing handle
+ * @param cc a connect request handle
  */
 void
  */
 void
-GNUNET_TRANSPORT_TESTING_get_test_source_name (const char *file, char **dest)
+GNUNET_TRANSPORT_TESTING_connect_peers_cancel (struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc)
 {
 {
-  char *src = extract_filename (file);
-  char *split;
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth = cc->p1->tth;
 
 
-  split = strstr (src, ".");
-  if (split != NULL)
+  LOG (GNUNET_ERROR_TYPE_DEBUG,
+       "Canceling connect request!\n");
+  if (NULL != cc->tct)
   {
   {
-    split[0] = '\0';
+    GNUNET_SCHEDULER_cancel (cc->tct);
+    cc->tct = NULL;
+  }
+  if (NULL != cc->oh)
+  {
+    GNUNET_TRANSPORT_offer_hello_cancel (cc->oh);
+    cc->oh = NULL;
+  }
+  if (NULL != cc->ats_sh)
+  {
+    GNUNET_ATS_connectivity_suggest_cancel (cc->ats_sh);
+    cc->ats_sh = NULL;
   }
   }
-  GNUNET_asprintf (dest, "%s", src);
-  GNUNET_free (src);
+  GNUNET_CONTAINER_DLL_remove (tth->cc_head,
+                               tth->cc_tail,
+                               cc);
+  GNUNET_free (cc);
 }
 
 
 /**
 }
 
 
 /**
- * Extracts the plugin anme from an absolute file name and the test name
- * @param file absolute file name
- * @param test test name
- * @param dest where to store result
+ * Clean up the transport testing
+ *
+ * @param tth transport testing handle
  */
 void
  */
 void
-GNUNET_TRANSPORT_TESTING_get_test_plugin_name (const char *file,
-                                               const char *test, char **dest)
+GNUNET_TRANSPORT_TESTING_done (struct GNUNET_TRANSPORT_TESTING_Handle *tth)
 {
 {
-  char *e = extract_filename (file);
-  char *t = extract_filename (test);
-
-  char *filename = NULL;
-  char *dotexe;
-
-  if (e == NULL)
-    goto fail;
-
-  /* remove "lt-" */
-  filename = strstr (e, "tes");
-  if (filename == NULL)
-    goto fail;
-
-  /* remove ".exe" */
-  if (NULL != (dotexe = strstr (filename, ".exe")))
-    dotexe[0] = '\0';
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *cc;
+  struct GNUNET_TRANSPORT_TESTING_ConnectRequest *ct;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *p;
+  struct GNUNET_TRANSPORT_TESTING_PeerContext *t;
 
 
-  /* find last _ */
-  filename = strstr (filename, t);
-  if (filename == NULL)
-    goto fail;
-
-  /* copy plugin */
-  filename += strlen (t);
-  filename++;
-  GNUNET_asprintf (dest, "%s", filename);
-  goto suc;
-
-fail:
-  (*dest) = NULL;
-suc:
-  GNUNET_free (t);
-  GNUNET_free (e);
+  if (NULL == tth)
+    return;
+  cc = tth->cc_head;
+  while (NULL != cc)
+  {
+    ct = cc->next;
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Developer forgot to cancel connect request!\n");
+    GNUNET_TRANSPORT_TESTING_connect_peers_cancel (cc);
+    cc = ct;
+  }
+  p = tth->p_head;
+  while (NULL != p)
+  {
+    t = p->next;
+    LOG (GNUNET_ERROR_TYPE_ERROR,
+         "Developer forgot to stop peer!\n");
+    GNUNET_TRANSPORT_TESTING_stop_peer (p);
+    p = t;
+  }
+  GNUNET_TESTING_system_destroy (tth->tl_system,
+                                 GNUNET_YES);
 
 
+  GNUNET_free (tth);
 }
 
 }
 
+
 /**
 /**
- * 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 count peer number
+ * Initialize the transport testing
+ *
+ * @return transport testing handle
  */
  */
-void
-GNUNET_TRANSPORT_TESTING_get_config_name (const char *file, char **dest,
-                                          int count)
+struct GNUNET_TRANSPORT_TESTING_Handle *
+GNUNET_TRANSPORT_TESTING_init ()
 {
 {
-  char *filename = extract_filename (file);
-  char *backup = filename;
-  char *dotexe;
-
-  if (filename == NULL)
-    goto fail;
-
-  /* remove "lt-" */
-  filename = strstr (filename, "tes");
-  if (filename == NULL)
-    goto fail;
-
-  /* remove ".exe" */
-  if (NULL != (dotexe = strstr (filename, ".exe")))
-    dotexe[0] = '\0';
-
-  goto suc;
-
-fail:
-  (*dest) = NULL;
-  return;
-
-suc:
-  /* create cfg filename */
-  GNUNET_asprintf (dest, "%s_peer%u.conf", filename, count);
-  GNUNET_free (backup);
+  struct GNUNET_TRANSPORT_TESTING_Handle *tth;
+
+  tth = GNUNET_new (struct GNUNET_TRANSPORT_TESTING_Handle);
+  tth->tl_system = GNUNET_TESTING_system_create ("transport-testing",
+                                                 NULL,
+                                                 NULL,
+                                                 NULL);
+  if (NULL == tth->tl_system)
+  {
+    GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                "Failed to initialize testing library!\n");
+    GNUNET_free (tth);
+    return NULL;
+  }
+  return tth;
 }
 
 }
 
-
-
-/* end of transport_testing.h */
+/* end of transport-testing.c */
Unnamed repository; edit this file 'description' to name the repository.