traffic manipulation: receive delay

8 files changed, 489 insertions, 26 deletions

diff --git a/src/transport/Makefile.am b/src/transport/Makefile.am
index d02117437..3586d29f1 100644
--- a/src/transport/Makefile.am
+++ b/src/transport/Makefile.am
@@ -343,7 +343,8 @@ check_PROGRAMS = \
  $(HTTPS_API_TIMEOUT_TEST) \
  $(WLAN_API_TEST) \
  test_transport_api_multi \
- test_transport_api_manipulation_tcp \
+ test_transport_api_manipulation_send_tcp \
+ test_transport_api_manipulation_recv_tcp \
  test_transport_api_reliability_tcp \
  test_transport_api_reliability_tcp_nat \
  test_transport_api_unreliability_udp \
@@ -391,7 +392,8 @@ TESTS = \
  $(HTTPS_API_TIMEOUT_TEST) \
  $(WLAN_API_TEST) \
  test_transport_api_multi \
- test_transport_api_manipulation_tcp \
+ test_transport_api_manipulation_send_tcp \
+ test_transport_api_manipulation_recv_tcp \
  test_transport_api_reliability_tcp \
  test_transport_api_reliability_tcp_nat \
  test_transport_api_unreliability_udp \
@@ -592,9 +594,17 @@ test_transport_api_tcp_nat_LDADD = \
  $(top_builddir)/src/util/libgnunetutil.la \
  $(top_builddir)/src/transport/libgnunettransporttesting.la 
 
-test_transport_api_manipulation_tcp_SOURCES = \
- test_transport_api_manipulation.c
-test_transport_api_manipulation_tcp_LDADD = \
+test_transport_api_manipulation_send_tcp_SOURCES = \
+ test_transport_api_manipulation_send_tcp.c
+test_transport_api_manipulation_send_tcp_LDADD = \
+ $(top_builddir)/src/transport/libgnunettransport.la \
+ $(top_builddir)/src/hello/libgnunethello.la \
+ $(top_builddir)/src/util/libgnunetutil.la \
+ $(top_builddir)/src/transport/libgnunettransporttesting.la 
+
+test_transport_api_manipulation_recv_tcp_SOURCES = \
+ test_transport_api_manipulation_recv_tcp.c
+test_transport_api_manipulation_recv_tcp_LDADD = \
  $(top_builddir)/src/transport/libgnunettransport.la \
  $(top_builddir)/src/hello/libgnunethello.la \
  $(top_builddir)/src/util/libgnunetutil.la \
diff --git a/src/transport/gnunet-service-transport_manipulation.c b/src/transport/gnunet-service-transport_manipulation.c
new file mode 100644
index 000000000..74f903c98
--- /dev/null
+++ b/src/transport/gnunet-service-transport_manipulation.c
@@ -0,0 +1,335 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010,2011 Christian Grothoff (and other contributing authors)
+
+     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 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     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.
+*/
+
+/**
+ * @file transport/gnunet-service-transport_manipulation.c
+ * @brief transport component manipulation traffic for simulation
+ * @author Christian Grothoff
+ * @author
+ */
+#include "platform.h"
+#include "gnunet-service-transport_blacklist.h"
+#include "gnunet-service-transport_clients.h"
+#include "gnunet-service-transport_hello.h"
+#include "gnunet-service-transport_neighbours.h"
+#include "gnunet-service-transport_plugins.h"
+#include "gnunet-service-transport_validation.h"
+#include "gnunet-service-transport.h"
+#include "transport.h"
+
+static struct GNUNET_CONTAINER_MultiHashMap *peers;
+
+#define DELAY 0
+#define DISTANCE 1
+
+struct TM_Peer;
+
+struct DelayQueueEntry
+{
+        struct DelayQueueEntry *prev;
+        struct DelayQueueEntry *next;
+        struct TM_Peer *tmp;
+        struct GNUNET_TIME_Absolute sent_at;
+        void *msg;
+        size_t msg_size;
+        struct GNUNET_TIME_Relative timeout;
+        GST_NeighbourSendContinuation cont;
+        void *cont_cls;
+};
+
+struct TM_Peer
+{
+        struct GNUNET_PeerIdentity peer;
+        uint32_t metrics [TM_BOTH][GNUNET_ATS_QualityPropertiesCount];
+        GNUNET_SCHEDULER_TaskIdentifier send_delay_task;
+        struct DelayQueueEntry *send_head;
+        struct DelayQueueEntry *send_tail;
+};
+
+
+
+static void
+set_delay(struct TM_Peer *tmp, struct GNUNET_PeerIdentity *peer, int direction, uint32_t value)
+{
+        uint32_t val;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set traffic metrics %s for peer `%s' in direction %s to %u\n",
+                        "DELAY", GNUNET_i2s(peer),
+                        (TM_BOTH == direction) ? "BOTH" : (TM_SEND == direction) ? "SEND": "RECEIVE", value);
+
+        if (UINT32_MAX == value)
+                val = UINT32_MAX - 1; /* prevent overflow */
+        else if (0 == value)
+                val = UINT32_MAX; /* disable */
+        else
+                val = value;
+
+        switch (direction) {
+                case TM_BOTH:
+                        tmp->metrics[TM_SEND][DELAY] = val;
+                        tmp->metrics[TM_RECEIVE][DELAY] = val;
+                        break;
+                case TM_SEND:
+                        tmp->metrics[TM_SEND][DELAY] = val;
+                        break;
+                case TM_RECEIVE:
+                        tmp->metrics[TM_RECEIVE][DELAY] = val;
+                        break;
+                default:
+                        break;
+        }
+
+}
+
+static void
+set_distance (struct TM_Peer *tmp, struct GNUNET_PeerIdentity *peer, int direction, uint32_t value)
+{
+        uint32_t val;
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Set traffic metrics %s for peer `%s' in direction %s to %u\n",
+                        "DISTANCE", GNUNET_i2s(peer),
+                        (TM_BOTH == direction) ? "BOTH" : (TM_SEND == direction) ? "SEND": "RECEIVE", value);
+
+        if (UINT32_MAX == value)
+                val = UINT32_MAX - 1; /* prevent overflow */
+        else if (0 == value)
+                val = UINT32_MAX; /* disable */
+        else
+                val = value;
+
+        switch (direction) {
+        case TM_BOTH:
+                tmp->metrics[TM_SEND][DISTANCE] = val;
+                tmp->metrics[TM_RECEIVE][DISTANCE] = val;
+                break;
+        case TM_SEND:
+                tmp->metrics[TM_SEND][DISTANCE] = val;
+                break;
+        case TM_RECEIVE:
+                tmp->metrics[TM_RECEIVE][DISTANCE] = val;
+                break;
+        default:
+                break;
+        }
+}
+
+void
+GST_manipulation_set_metric (void *cls, struct GNUNET_SERVER_Client *client,
+    const struct GNUNET_MessageHeader *message)
+{
+        struct TrafficMetricMessage *tm = (struct TrafficMetricMessage *) message;
+        struct GNUNET_ATS_Information *ats;
+        struct TM_Peer *tmp;
+        uint32_t type;
+        uint32_t value;
+        int c;
+        int c2;
+
+        if (0 == ntohs (tm->ats_count))
+          GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
+
+        GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Received traffic metrics for peer `%s'\n",
+                        GNUNET_i2s(&tm->peer));
+
+        if (NULL == (tmp = GNUNET_CONTAINER_multihashmap_get (peers, &tm->peer.hashPubKey)))
+        {
+                        tmp = GNUNET_malloc (sizeof (struct TM_Peer));
+                        tmp->peer = (tm->peer);
+                        for (c = 0; c < TM_BOTH; c++)
+                        {
+                                        for (c2 = 0; c2 < GNUNET_ATS_QualityPropertiesCount; c2++)
+                                        {
+                                                        tmp->metrics[c][c2] = UINT32_MAX;
+                                        }
+                        }
+                        GNUNET_CONTAINER_multihashmap_put (peers, &tm->peer.hashPubKey, tmp, GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+        }
+
+        ats = (struct GNUNET_ATS_Information *) &tm[1];
+        for (c = 0; c < ntohs (tm->ats_count); c++)
+        {
+                        type = htonl (ats[c].type);
+                        value = htonl (ats[c].value);
+                        switch (type) {
+                                case GNUNET_ATS_QUALITY_NET_DELAY:
+                                        set_delay (tmp, &tm->peer, ntohs (tm->direction), value);
+                                        break;
+                                case GNUNET_ATS_QUALITY_NET_DISTANCE:
+                                        set_distance (tmp, &tm->peer, ntohs (tm->direction), value);
+                                        break;
+                                default:
+                                        break;
+                        }
+        }
+
+  GNUNET_SERVER_receive_done (client, GNUNET_OK);
+}
+
+static void
+send_delayed (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+        struct DelayQueueEntry *dqe = cls;
+        struct DelayQueueEntry *next;
+        struct TM_Peer *tmp = dqe->tmp;
+        struct GNUNET_TIME_Relative delay;
+        tmp->send_delay_task = GNUNET_SCHEDULER_NO_TASK;
+        GNUNET_CONTAINER_DLL_remove (tmp->send_head, tmp->send_tail, dqe);
+        GST_neighbours_send (&tmp->peer, dqe->msg, dqe->msg_size, dqe->timeout, dqe->cont, dqe->cont_cls);
+
+        next = tmp->send_head;
+        if (NULL != next)
+        {
+                        /* More delayed messages */
+                        delay = GNUNET_TIME_absolute_get_remaining (next->sent_at);
+                        tmp->send_delay_task = GNUNET_SCHEDULER_add_delayed (delay, &send_delayed, dqe);
+        }
+
+        GNUNET_free (dqe);
+}
+
+void
+GST_manipulation_send (const struct GNUNET_PeerIdentity *target, const void *msg,
+    size_t msg_size, struct GNUNET_TIME_Relative timeout,
+    GST_NeighbourSendContinuation cont, void *cont_cls)
+{
+        struct TM_Peer *tmp;
+        struct DelayQueueEntry *dqe;
+        struct GNUNET_TIME_Relative delay;
+
+        if (NULL != (tmp = GNUNET_CONTAINER_multihashmap_get (peers, &target->hashPubKey)))
+        {
+                        /* Manipulate here */
+                        /* Delay */
+                        if (UINT32_MAX != tmp->metrics[TM_SEND][DELAY])
+                        {
+                                        /* We have a delay */
+                                        delay.rel_value = tmp->metrics[TM_SEND][DELAY];
+                                        dqe = GNUNET_malloc (sizeof (struct DelayQueueEntry) + msg_size);
+                                        dqe->tmp = tmp;
+                                        dqe->sent_at = GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get(), delay);
+                                        dqe->cont = cont;
+                                        dqe->cont_cls = cont_cls;
+                                        dqe->msg = &dqe[1];
+                                        dqe->msg_size = msg_size;
+                                        dqe->timeout = timeout;
+                                        memcpy (dqe->msg, msg, msg_size);
+                                        GNUNET_CONTAINER_DLL_insert_tail (tmp->send_head, tmp->send_tail, dqe);
+                                        if (GNUNET_SCHEDULER_NO_TASK == tmp->send_delay_task)
+                                                tmp->send_delay_task =GNUNET_SCHEDULER_add_delayed (delay, &send_delayed, dqe);
+                                        return;
+                        }
+        }
+        /* Normal sending */
+        GST_neighbours_send (target, msg, msg_size, timeout, cont, cont_cls);
+}
+
+struct GNUNET_TIME_Relative
+GST_manipulation_recv (void *cls, const struct GNUNET_PeerIdentity *peer,
+    const struct GNUNET_MessageHeader *message,
+    const struct GNUNET_ATS_Information *ats,
+    uint32_t ats_count, struct Session *session,
+    const char *sender_address,
+    uint16_t sender_address_len)
+{
+        struct TM_Peer *tmp;
+        int d;
+        struct GNUNET_ATS_Information ats_new[ats_count];
+        struct GNUNET_TIME_Relative q_delay;
+        struct GNUNET_TIME_Relative m_delay;
+
+        for (d = 0; d < ats_count; d++)
+
+        if (NULL != (tmp = GNUNET_CONTAINER_multihashmap_get (peers, &peer->hashPubKey)))
+        {
+                        /* Manipulate distance */
+                        for (d = 0; d < ats_count; d++)
+                        {
+                                        ats_new[d] = ats[d];
+                                        /* Set distance */
+                                        if ((ntohl(ats[d].type) == GNUNET_ATS_QUALITY_NET_DISTANCE) &&
+                                                 (UINT32_MAX != tmp->metrics[TM_RECEIVE][DISTANCE]))
+                                        {
+                                                        ats_new[d].value = htonl(tmp->metrics[TM_RECEIVE][DISTANCE]);
+                                        }
+                        }
+                        /* Manipulate receive delay */
+                        if (UINT32_MAX != tmp->metrics[TM_RECEIVE][DELAY])
+                        {
+                                        m_delay.rel_value = tmp->metrics[TM_RECEIVE][DELAY];
+                                        q_delay = GST_receive_callback (cls, peer, message, &ats_new[0], ats_count,
+                                                        session, sender_address, sender_address_len);
+
+                                        if (q_delay.rel_value >= m_delay.rel_value)
+                                        {
+                                                        return q_delay;
+                                        }
+                                        else
+                                        {
+                                                        return m_delay;
+                                        }
+                        }
+        }
+
+        return GST_receive_callback (cls, peer, message, ats, ats_count,
+                        session, sender_address, sender_address_len);
+}
+
+void
+GST_manipulation_init ()
+{
+        peers = GNUNET_CONTAINER_multihashmap_create (10, GNUNET_NO);
+}
+
+int free_tmps (void *cls,
+                                                         const struct GNUNET_HashCode * key,
+                                                         void *value)
+{
+        struct DelayQueueEntry *dqe;
+        struct DelayQueueEntry *next;
+        if (NULL != value)
+        {
+                        struct TM_Peer *tmp = (struct TM_Peer *) value;
+                        GNUNET_CONTAINER_multihashmap_remove (peers, key, value);
+                        next = tmp->send_head;
+                        while (NULL != (dqe = next))
+                        {
+                                        next = dqe->next;
+                                        GNUNET_CONTAINER_DLL_remove (tmp->send_head, tmp->send_tail, dqe);
+                                        GNUNET_free (dqe);
+                        }
+                        if (GNUNET_SCHEDULER_NO_TASK != tmp->send_delay_task)
+                        {
+                                        GNUNET_SCHEDULER_cancel (tmp->send_delay_task);
+                                        tmp->send_delay_task = GNUNET_SCHEDULER_NO_TASK;
+                        }
+                        GNUNET_free (tmp);
+        }
+        return GNUNET_OK;
+}
+
+void
+GST_manipulation_stop ()
+{
+        GNUNET_CONTAINER_multihashmap_iterate (peers, &free_tmps,NULL);
+
+        GNUNET_CONTAINER_multihashmap_destroy (peers);
+        peers = NULL;
+}
+
+
+/* end of file gnunet-service-transport_manipulation.c */
diff --git a/src/transport/gnunet-service-transport_manipulation.h b/src/transport/gnunet-service-transport_manipulation.h
new file mode 100644
index 000000000..f8faa85dd
--- /dev/null
+++ b/src/transport/gnunet-service-transport_manipulation.h
@@ -0,0 +1,63 @@
+/*
+     This file is part of GNUnet.
+     (C) 2010,2011 Christian Grothoff (and other contributing authors)
+
+     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 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     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.
+*/
+
+/**
+ * @file transport/gnunet-service-transport_neighbours.h
+ * @brief neighbour management API
+ * @author Christian Grothoff
+ */
+#ifndef GNUNET_SERVICE_TRANSPORT_MANIPULATION_H
+#define GNUNET_SERVICE_TRANSPORT_MANIPULATION_H
+
+#include "platform.h"
+#include "gnunet-service-transport_blacklist.h"
+#include "gnunet-service-transport_clients.h"
+#include "gnunet-service-transport_hello.h"
+#include "gnunet-service-transport_neighbours.h"
+#include "gnunet-service-transport_plugins.h"
+#include "gnunet-service-transport_validation.h"
+#include "gnunet-service-transport.h"
+#include "transport.h"
+
+void
+GST_manipulation_set_metric (void *cls, struct GNUNET_SERVER_Client *client,
+    const struct GNUNET_MessageHeader *message);
+
+void
+GST_manipulation_send (const struct GNUNET_PeerIdentity *target, const void *msg,
+    size_t msg_size, struct GNUNET_TIME_Relative timeout,
+    GST_NeighbourSendContinuation cont, void *cont_cls);
+
+struct GNUNET_TIME_Relative
+GST_manipulation_recv (void *cls, const struct GNUNET_PeerIdentity *peer,
+    const struct GNUNET_MessageHeader *message,
+    const struct GNUNET_ATS_Information *ats,
+    uint32_t ats_count, struct Session *session,
+    const char *sender_address,
+    uint16_t sender_address_len);
+
+void
+GST_manipulation_init ();
+
+void
+GST_manipulation_stop ();
+
+#endif
+/* end of file gnunet-service-transport_neighbours.h */
diff --git a/src/transport/test_transport_api_manipulation_tcp_peer1.conf b/src/transport/test_transport_api_manipulation_recv_tcp_peer1.conf
index db662826b..db662826b 100644
--- a/src/transport/test_transport_api_manipulation_tcp_peer1.conf
+++ b/src/transport/test_transport_api_manipulation_recv_tcp_peer1.conf
diff --git a/src/transport/test_transport_api_manipulation_tcp_peer2.conf b/src/transport/test_transport_api_manipulation_recv_tcp_peer2.conf
index 67f171ec9..67f171ec9 100644
--- a/src/transport/test_transport_api_manipulation_tcp_peer2.conf
+++ b/src/transport/test_transport_api_manipulation_recv_tcp_peer2.conf
diff --git a/src/transport/test_transport_api_manipulation.c b/src/transport/test_transport_api_manipulation_send_tcp.c
index 21bed3a65..cdef9921b 100644
--- a/src/transport/test_transport_api_manipulation.c
+++ b/src/transport/test_transport_api_manipulation_send_tcp.c
@@ -176,7 +176,7 @@ notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
 
   char *ps = GNUNET_strdup (GNUNET_i2s (&p->id));
 
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
+  GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
               "Peer %u (`%4s') received message of type %d and size %u size from peer %u (`%4s')!\n",
               p->no, ps, ntohs (message->type), ntohs (message->size), t->no,
               GNUNET_i2s (&t->id));
@@ -196,13 +196,13 @@ notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
     return;
   }
 
-
   if (0 == messages_recv)
   {
         /* Received non-delayed message */
         dur_normal = GNUNET_TIME_absolute_get_duration(start_normal);
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                "Received non-delayed message after %llu\n",
+                "Received non-delayed message %u after %llu\n",
+                messages_recv,
                 (long long unsigned int) dur_normal.rel_value);
     send_task = GNUNET_SCHEDULER_add_now (&sendtask, NULL);
   }
@@ -210,8 +210,9 @@ notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
   {
         /* Received manipulated message */
         dur_delayed = GNUNET_TIME_absolute_get_duration(start_delayed);
-      GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-                  "Received delayed message after %llu\n",
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  "Received delayed message %u after %llu\n",
+                  messages_recv,
                   (long long unsigned int) dur_delayed.rel_value);
       if (dur_delayed.rel_value < 1000)
       {
@@ -221,15 +222,12 @@ notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
                     "Delayed message was not delayed correctly: took only %llu\n",
                     (long long unsigned int) dur_delayed.rel_value);
       }
-
       for (c = 0; c < ats_count; c++)
       {
         if (ntohl (ats[c].type) == GNUNET_ATS_QUALITY_NET_DISTANCE)
         {
                         if (ntohl (ats[c].value) == 10)
-                        {
                                 ok += 0;
-                        }
                         else
                         {
                                         GNUNET_break (0);
@@ -237,20 +235,10 @@ notify_receive (void *cls, const struct GNUNET_PeerIdentity *peer,
                         }
         }
       }
-
       /* shutdown */
       end ();
   }
   messages_recv ++;
-
-
-
-/*
-
-
-  //
-   *
-   */
 }
 
 
@@ -320,8 +308,7 @@ sendtask (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                 ats[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
                 ats[1].value = htonl (10);
 
-          GNUNET_TRANSPORT_set_traffic_metric (p1->th, &p2->id, TM_BOTH, ats, 2);
-          GNUNET_TRANSPORT_set_traffic_metric (p2->th, &p1->id, TM_BOTH, ats, 2);
+          GNUNET_TRANSPORT_set_traffic_metric (p2->th, &p1->id, TM_SEND, ats, 2);
 
                 start_delayed = GNUNET_TIME_absolute_get();
   }
@@ -410,7 +397,15 @@ start_cb (struct PeerContext *p, void *cls)
               "Test tries to connect peer %u (`%s') -> peer %u (`%s')\n",
               p1->no, sender_c, p2->no, GNUNET_i2s (&p2->id));
   GNUNET_free (sender_c);
+  /*
+  struct GNUNET_ATS_Information ats[2];
+        ats[0].type = htonl (GNUNET_ATS_QUALITY_NET_DELAY);
+        ats[0].value = htonl (1000);
+        ats[1].type = htonl (GNUNET_ATS_QUALITY_NET_DISTANCE);
+        ats[1].value = htonl (10);
 
+  GNUNET_TRANSPORT_set_traffic_metric (p1->th, &p2->id, TM_RECEIVE, ats, 2);
+*/
   cc = GNUNET_TRANSPORT_TESTING_connect_peers (tth, p1, p2, &testing_connect_cb,
                                                NULL);
 
@@ -451,7 +446,7 @@ run (void *cls, char *const *args, const char *cfgfile,
 static int
 check ()
 {
-  static char *const argv[] = { "test-transport-api",
+  static char *const argv[] = { "test-transport-api-manipulation",
     "-c",
     "test_transport_api_data.conf",
     NULL
diff --git a/src/transport/test_transport_api_manipulation_send_tcp_peer1.conf b/src/transport/test_transport_api_manipulation_send_tcp_peer1.conf
new file mode 100644
index 000000000..db662826b
--- /dev/null
+++ b/src/transport/test_transport_api_manipulation_send_tcp_peer1.conf
@@ -0,0 +1,30 @@
+@INLINE@ template_cfg_peer1.conf
+[PATHS]
+SERVICEHOME = /tmp/test-transport/api-tcp-p1/
+
+[transport-tcp]
+PORT = 12000
+TIMEOUT = 5 s
+
+[arm]
+PORT = 12005
+DEFAULTSERVICES = transport
+UNIXPATH = /tmp/gnunet-p1-service-arm.sock
+
+[statistics]
+PORT = 12004
+UNIXPATH = /tmp/gnunet-p1-service-statistics.sock
+
+[resolver]
+PORT = 12003
+UNIXPATH = /tmp/gnunet-p1-service-resolver.sock
+
+[peerinfo]
+PORT = 12002
+UNIXPATH = /tmp/gnunet-p1-service-peerinfo.sock
+
+[transport]
+PORT = 12001
+UNIXPATH = /tmp/gnunet-p1-service-transport.sock
+PLUGINS = tcp
+
diff --git a/src/transport/test_transport_api_manipulation_send_tcp_peer2.conf b/src/transport/test_transport_api_manipulation_send_tcp_peer2.conf
new file mode 100644
index 000000000..67f171ec9
--- /dev/null
+++ b/src/transport/test_transport_api_manipulation_send_tcp_peer2.conf
@@ -0,0 +1,30 @@
+@INLINE@ template_cfg_peer2.conf
+[PATHS]
+SERVICEHOME = /tmp/test-transport/api-tcp-p2/
+
+[transport-tcp]
+PORT = 12015
+TIMEOUT = 5 s
+
+[arm]
+PORT = 12014
+DEFAULTSERVICES = transport
+UNIXPATH = /tmp/gnunet-p2-service-arm.sock
+
+[statistics]
+PORT = 12013
+UNIXPATH = /tmp/gnunet-p2-service-statistics.sock
+
+[resolver]
+PORT = 12012
+UNIXPATH = /tmp/gnunet-p2-service-resolver.sock
+
+[peerinfo]
+PORT = 12011
+UNIXPATH = /tmp/gnunet-p2-service-peerinfo.sock
+
+[transport]
+PORT = 12010
+PLUGINS = tcp
+UNIXPATH = /tmp/gnunet-p2-service-transport.sock
+