8 files changed, 106 insertions, 105 deletions

diff --git a/src/mesh/Makefile.am b/src/mesh/Makefile.am
index c76b1e640..72ce932a5 100644
--- a/src/mesh/Makefile.am
+++ b/src/mesh/Makefile.am
@@ -159,7 +159,6 @@ ld_mesh_test_lib = \
   $(top_builddir)/src/testing/libgnunettesting.la \
   $(top_builddir)/src/mesh/libgnunetmeshtest.a \
   $(top_builddir)/src/mesh/libgnunetmeshenc.la \
-  $(top_builddir)/src/mesh/libgnunetmesh.la \
   $(top_builddir)/src/testbed/libgnunettestbed.la
 
 dep_mesh_test_lib = \
diff --git a/src/mesh/gnunet-service-mesh-enc.c b/src/mesh/gnunet-service-mesh-enc.c
index 566988253..0ef1f9cdd 100644
--- a/src/mesh/gnunet-service-mesh-enc.c
+++ b/src/mesh/gnunet-service-mesh-enc.c
@@ -1675,7 +1675,7 @@ send_prebuilt_message_connection (const struct GNUNET_MessageHeader *message,
   type = ntohs (message->type);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Send %s[%u] on connection %s\n",
               GNUNET_MESH_DEBUG_M2S (type), size, GNUNET_h2s (&c->id));
-  
+
   switch (type)
   {
     struct GNUNET_MESH_Encrypted *emsg;
diff --git a/src/mesh/mesh_test_lib.c b/src/mesh/mesh_test_lib.c
index e9ccb631f..a6a7c2114 100644
--- a/src/mesh/mesh_test_lib.c
+++ b/src/mesh/mesh_test_lib.c
@@ -25,7 +25,7 @@
 #include "platform.h"
 #include "gnunet_util_lib.h"
 #include "mesh_test_lib.h"
-#include "gnunet_mesh_service.h"
+#include "gnunet_mesh_service_enc.h"
 
 /**
  * Test context for a MESH Test.
@@ -65,12 +65,12 @@ struct GNUNET_MESH_TEST_Context
   /**
    * Handler for incoming tunnels.
    */
-  GNUNET_MESH_InboundTunnelNotificationHandler *new_tunnel;
+  GNUNET_MESH_InboundChannelNotificationHandler *new_channel;
 
   /**
    * Cleaner for destroyed incoming tunnels.
    */
-  GNUNET_MESH_TunnelEndHandler *cleaner;
+  GNUNET_MESH_ChannelEndHandler *cleaner;
 
   /**
    * Message handlers.
@@ -122,7 +122,7 @@ mesh_connect_adapter (void *cls,
 
   h = GNUNET_MESH_connect (cfg,
                            (void *) (long) actx->peer,
-                           ctx->new_tunnel,
+                           ctx->new_channel,
                            ctx->cleaner,
                            ctx->handlers,
                            ctx->ports);
@@ -256,8 +256,8 @@ GNUNET_MESH_TEST_run (const char *testname,
                       unsigned int num_peers,
                       GNUNET_MESH_TEST_AppMain tmain,
                       void *tmain_cls,
-                      GNUNET_MESH_InboundTunnelNotificationHandler new_tunnel,
-                      GNUNET_MESH_TunnelEndHandler cleaner,
+                      GNUNET_MESH_InboundChannelNotificationHandler new_channel,
+                      GNUNET_MESH_ChannelEndHandler cleaner,
                       struct GNUNET_MESH_MessageHandler* handlers,
                       const uint32_t *ports)
 {
@@ -269,7 +269,7 @@ GNUNET_MESH_TEST_run (const char *testname,
   ctx->meshes = GNUNET_malloc (num_peers * sizeof (struct GNUNET_MESH_Handle *));
   ctx->app_main = tmain;
   ctx->app_main_cls = tmain_cls;
-  ctx->new_tunnel = new_tunnel;
+  ctx->new_channel = new_channel;
   ctx->cleaner = cleaner;
   ctx->handlers = handlers;
   ctx->ports = ports;
diff --git a/src/mesh/mesh_test_lib.h b/src/mesh/mesh_test_lib.h
index 4dd2151b8..c560d50c0 100644
--- a/src/mesh/mesh_test_lib.h
+++ b/src/mesh/mesh_test_lib.h
@@ -34,7 +34,7 @@ extern "C"
 #endif
 
 #include "gnunet_testbed_service.h"
-#include "gnunet_mesh_service.h"
+#include "gnunet_mesh_service_enc.h"
 
 /**
  * Test context for a MESH Test.
@@ -79,8 +79,8 @@ GNUNET_MESH_TEST_run (const char *testname,
                       unsigned int num_peers,
                       GNUNET_MESH_TEST_AppMain tmain,
                       void *tmain_cls,
-                      GNUNET_MESH_InboundTunnelNotificationHandler new_tunnel,
-                      GNUNET_MESH_TunnelEndHandler cleaner,
+                      GNUNET_MESH_InboundChannelNotificationHandler new_channel,
+                      GNUNET_MESH_ChannelEndHandler cleaner,
                       struct GNUNET_MESH_MessageHandler* handlers,
                       const uint32_t* ports);
 
diff --git a/src/mesh/test_mesh.conf b/src/mesh/test_mesh.conf
index 2c577ab84..2ae07e30f 100644
--- a/src/mesh/test_mesh.conf
+++ b/src/mesh/test_mesh.conf
@@ -2,12 +2,12 @@
 SERVICEHOME = /tmp/test-mesh/
 
 [mesh]
-# BINARY = gnunet-service-mesh-enc
+BINARY = gnunet-service-mesh-enc
 AUTOSTART = NO
 ACCEPT_FROM = 127.0.0.1;
 HOSTNAME = localhost
 PORT = 10511
-# PREFIX = valgrind --leak-check=full
+PREFIX = valgrind --leak-check=full
 #PREFIX = xterm -geometry 100x85 -T peer1 -e gdb --args
 REFRESH_PATH_TIME = 2 s
 ID_ANNOUNCE_TIME = 5 s
diff --git a/src/mesh/test_mesh_local.c b/src/mesh/test_mesh_local.c
index 25ccf7b2e..5bf3e0ce4 100644
--- a/src/mesh/test_mesh_local.c
+++ b/src/mesh/test_mesh_local.c
@@ -20,7 +20,7 @@
 
 /**
  * @file mesh/test_mesh_local.c
- * @brief test mesh local: test of mesh tunnels with just one peer
+ * @brief test mesh local: test of mesh channels with just one peer
  * @author Bartlomiej Polot
  */
 
@@ -130,14 +130,14 @@ data_callback (void *cls, struct GNUNET_MESH_Channel *channel,
  *         (can be NULL -- that's not an error)
  */
 static void *
-inbound_tunnel (void *cls, struct GNUNET_MESH_Channel *channel,
+inbound_channel (void *cls, struct GNUNET_MESH_Channel *channel,
                 const struct GNUNET_PeerIdentity *initiator,
                 uint32_t port)
 {
   long id = (long) cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "received incoming tunnel on peer %d, port %u\n",
+              "received incoming channel on peer %d, port %u\n",
               id, port);
   if (id != 2L)
   {
@@ -257,14 +257,14 @@ run (void *cls,
                                     NULL);
   mesh_peer_1 = GNUNET_MESH_connect (cfg,       /* configuration */
                                      (void *) 1L,     /* cls */
-                                     &inbound_tunnel,   /* inbound new hndlr */
+                                     &inbound_channel,   /* inbound new hndlr */
                                      &inbound_end,      /* inbound end hndlr */
                                      handlers1, /* traffic handlers */
                                      NULL);     /* ports offered */
 
   mesh_peer_2 = GNUNET_MESH_connect (cfg,       /* configuration */
                                      (void *) 2L,     /* cls */
-                                     &inbound_tunnel,   /* inbound new hndlr */
+                                     &inbound_channel,   /* inbound new hndlr */
                                      &inbound_end,      /* inbound end hndlr */
                                      handlers2, /* traffic handlers */
                                      ports);     /* ports offered */
diff --git a/src/mesh/test_mesh_single.c b/src/mesh/test_mesh_single.c
index 4c5d0a659..2179b1f1d 100644
--- a/src/mesh/test_mesh_single.c
+++ b/src/mesh/test_mesh_single.c
@@ -20,7 +20,7 @@
 
 /**
  * @file mesh/test_mesh_local.c
- * @brief test mesh local: test of mesh tunnels with just one peer
+ * @brief test mesh local: test of mesh channels with just one peer
  * @author Bartlomiej Polot
  */
 
@@ -28,7 +28,7 @@
 #include "gnunet_util_lib.h"
 #include "gnunet_dht_service.h"
 #include "gnunet_testing_lib.h"
-#include "gnunet_mesh_service.h"
+#include "gnunet_mesh_service_enc.h"
 
 #define REPETITIONS 5
 #define DATA_SIZE 35000
@@ -37,9 +37,9 @@ struct GNUNET_TESTING_Peer *me;
 
 static struct GNUNET_MESH_Handle *mesh;
 
-static struct GNUNET_MESH_Tunnel *t1;
+static struct GNUNET_MESH_Channel *ch1;
 
-static struct GNUNET_MESH_Tunnel *t2;
+static struct GNUNET_MESH_Channel *ch2;
 
 static int result = GNUNET_OK;
 
@@ -66,9 +66,9 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   {
     GNUNET_SCHEDULER_cancel (abort_task);
   }
-  if (NULL != t1)
+  if (NULL != ch1)
   {
-    GNUNET_MESH_tunnel_destroy (t1);
+    GNUNET_MESH_channel_destroy (ch1);
   }
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect client 1\n");
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Disconnect client 2\n");
@@ -101,15 +101,16 @@ do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * Function is called whenever a message is received.
  *
  * @param cls closure (set from GNUNET_MESH_connect)
- * @param tunnel connection to the other end
- * @param tunnel_ctx place to store local state associated with the tunnel
+ * @param channel connection to the other end
+ * @param channel_ctx place to store local state associated with the channel
  * @param message the actual message
  * 
  * @return GNUNET_OK to keep the connection open,
  *         GNUNET_SYSERR to close it (signal serious error)
  */
 static int
-data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
+data_callback (void *cls, struct GNUNET_MESH_Channel *channel,
+               void **channel_ctx,
                const struct GNUNET_MessageHeader *message)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Data callback! Repetition %u\n", repetition);
@@ -117,16 +118,16 @@ data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
   repetition = repetition + 1;
   if (repetition < REPETITIONS)
   {
-    struct GNUNET_MESH_Tunnel *my_tunnel;
+    struct GNUNET_MESH_Channel *my_channel;
     if (repetition % 2 == 0)
-      my_tunnel = t1;
+      my_channel = ch1;
     else
-      my_tunnel = t2;
-    GNUNET_MESH_notify_transmit_ready (my_tunnel, GNUNET_NO,
+      my_channel = ch2;
+    GNUNET_MESH_notify_transmit_ready (my_channel, GNUNET_NO,
                                        GNUNET_TIME_UNIT_FOREVER_REL,
                                        sizeof (struct GNUNET_MessageHeader) + DATA_SIZE,
                                        &do_send, NULL);
-    GNUNET_MESH_receive_done (tunnel);
+    GNUNET_MESH_receive_done (channel);
     return GNUNET_OK;
   }
   if (GNUNET_SCHEDULER_NO_TASK != shutdown_task)
@@ -134,51 +135,51 @@ data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
   shutdown_task =
     GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_SECONDS, &do_shutdown,
                                   NULL);
-  GNUNET_MESH_receive_done (tunnel);
+  GNUNET_MESH_receive_done (channel);
   return GNUNET_OK;
 }
 
 
 /**
- * Method called whenever another peer has added us to a tunnel
+ * Method called whenever another peer has added us to a channel
  * the other peer initiated.
  *
  * @param cls closure
- * @param tunnel new handle to the tunnel
- * @param initiator peer that started the tunnel
+ * @param channel new handle to the channel
+ * @param initiator peer that started the channel
  * @param port port number
- * @return initial tunnel context for the tunnel (can be NULL -- that's not an error)
+ * @return initial channel context for the channel (can be NULL -- that's not an error)
  */
 static void *
-inbound_tunnel (void *cls, struct GNUNET_MESH_Tunnel *tunnel,
+inbound_channel (void *cls, struct GNUNET_MESH_Channel *channel,
                 const struct GNUNET_PeerIdentity *initiator,
                 uint32_t port)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "received incoming tunnel on port %u\n",
+              "received incoming channel on port %u\n",
               port);
-  t2 = tunnel;
+    ch2 = channel;
   return NULL;
 }
 
 
 /**
- * Function called whenever an inbound tunnel is destroyed.  Should clean up
+ * Function called whenever an inbound channel is destroyed.  Should clean up
  * any associated state.
  *
  * @param cls closure (set from GNUNET_MESH_connect)
- * @param tunnel connection to the other end (henceforth invalid)
- * @param tunnel_ctx place where local state associated
- *                   with the tunnel is stored
+ * @param channel connection to the other end (henceforth invalid)
+ * @param channel_ctx place where local state associated
+ *                   with the channel is stored
  */
 static void
-inbound_end (void *cls, const struct GNUNET_MESH_Tunnel *tunnel,
-             void *tunnel_ctx)
+inbound_end (void *cls, const struct GNUNET_MESH_Channel *channel,
+             void *channel_ctx)
 {
   long id = (long) cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
-              "incoming tunnel closed at peer %ld\n",
+              "incoming channel closed at peer %ld\n",
               id);
 }
 
@@ -232,8 +233,8 @@ do_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 
   GNUNET_TESTING_peer_get_identity (me, &id);
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "CONNECT BY PORT\n");
-  t1 = GNUNET_MESH_tunnel_create (mesh, NULL, &id, 1, GNUNET_YES, GNUNET_NO);
-  GNUNET_MESH_notify_transmit_ready (t1, GNUNET_NO,
+    ch1 = GNUNET_MESH_channel_create (mesh, NULL, &id, 1, GNUNET_YES, GNUNET_NO);
+  GNUNET_MESH_notify_transmit_ready (ch1, GNUNET_NO,
                                      GNUNET_TIME_UNIT_FOREVER_REL,
                                      sizeof (struct GNUNET_MessageHeader) + DATA_SIZE,
                                      &do_send, NULL);
@@ -261,7 +262,7 @@ run (void *cls,
                                     NULL);
   mesh = GNUNET_MESH_connect (cfg,       /* configuration */
                               (void *) 1L,     /* cls */
-                              &inbound_tunnel,   /* inbound new hndlr */
+                              &inbound_channel,   /* inbound new hndlr */
                               &inbound_end,      /* inbound end hndlr */
                               handlers1, /* traffic handlers */
                               ports);     /* ports offered */
diff --git a/src/mesh/test_mesh_small.c b/src/mesh/test_mesh_small.c
index dc9f9461c..edd55a593 100644
--- a/src/mesh/test_mesh_small.c
+++ b/src/mesh/test_mesh_small.c
@@ -25,7 +25,7 @@
 #include <stdio.h>
 #include "platform.h"
 #include "mesh_test_lib.h"
-#include "gnunet_mesh_service.h"
+#include "gnunet_mesh_service_enc.h"
 #include <gauger.h>
 
 
@@ -77,11 +77,11 @@ static int ok;
 
  /**
   * Each peer is supposed to generate the following callbacks:
-  * 1 incoming tunnel (@dest)
+  * 1 incoming channel (@dest)
   * 1 connected peer (@orig)
   * 1 received data packet (@dest)
   * 1 received data packet (@orig)
-  * 1 received tunnel destroy (@dest)
+  * 1 received channel destroy (@dest)
   * _________________________________
   * 5 x ok expected per peer
   */
@@ -164,17 +164,17 @@ static struct GNUNET_MESH_Handle *h1;
 static struct GNUNET_MESH_Handle *h2;
 
 /**
- * Tunnel handle for the root peer
+ * Channel handle for the root peer
  */
-static struct GNUNET_MESH_Tunnel *t;
+static struct GNUNET_MESH_Channel *ch;
 
 /**
- * Tunnel handle for the first leaf peer
+ * Channel handle for the dest peer
  */
-static struct GNUNET_MESH_Tunnel *incoming_t;
+static struct GNUNET_MESH_Channel *incoming_ch;
 
 /**
- * Time we started the data transmission (after tunnel has been established
+ * Time we started the data transmission (after channel has been established
  * and initilized).
  */
 static struct GNUNET_TIME_Absolute start_time;
@@ -239,15 +239,15 @@ disconnect_mesh_peers (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   {
     GNUNET_TESTBED_operation_done (t_op[i]);
   }
-  if (NULL != t)
+  if (NULL != ch)
   {
-    GNUNET_MESH_tunnel_destroy (t);
-    t = NULL;
+    GNUNET_MESH_channel_destroy (ch);
+    ch = NULL;
   }
-  if (NULL != incoming_t)
+  if (NULL != incoming_ch)
   {
-    GNUNET_MESH_tunnel_destroy (incoming_t);
-    incoming_t = NULL;
+    GNUNET_MESH_channel_destroy (incoming_ch);
+    incoming_ch = NULL;
   }
   GNUNET_MESH_TEST_cleanup (test_ctx);
   if (GNUNET_SCHEDULER_NO_TASK != shutdown_handle)
@@ -297,7 +297,7 @@ static void
 data_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
 {
   struct GNUNET_MESH_TransmitHandle *th;
-  struct GNUNET_MESH_Tunnel *tunnel;
+  struct GNUNET_MESH_Channel *channel;
 
   if ((GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason) != 0)
     return;
@@ -305,13 +305,13 @@ data_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Data task\n");
   if (GNUNET_YES == test_backwards)
   {
-    tunnel = incoming_t;
+    channel = incoming_ch;
   }
   else
   {
-    tunnel = t;
+    channel = ch;
   }
-  th = GNUNET_MESH_notify_transmit_ready (tunnel, GNUNET_NO,
+  th = GNUNET_MESH_notify_transmit_ready (channel, GNUNET_NO,
                                           GNUNET_TIME_UNIT_FOREVER_REL,
                                           size_payload, &tmt_rdy, (void *) 1L);
   if (NULL == th)
@@ -388,14 +388,15 @@ tmt_rdy (void *cls, size_t size, void *buf)
  * Function is called whenever a message is received.
  *
  * @param cls closure (set from GNUNET_MESH_connect)
- * @param tunnel connection to the other end
- * @param tunnel_ctx place to store local state associated with the tunnel
+ * @param channel connection to the other end
+ * @param channel_ctx place to store local state associated with the channel
  * @param message the actual message
  * @return GNUNET_OK to keep the connection open,
  *         GNUNET_SYSERR to close it (signal serious error)
  */
 int
-data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
+data_callback (void *cls, struct GNUNET_MESH_Channel *channel,
+               void **channel_ctx,
                const struct GNUNET_MessageHeader *message)
 {
   long client = (long) cls;
@@ -404,7 +405,7 @@ data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
 
   ok++;
 
-  GNUNET_MESH_receive_done (tunnel);
+  GNUNET_MESH_receive_done (channel);
 
   if ((ok % 20) == 0)
   {
@@ -462,7 +463,7 @@ data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
                 " received data %u\n", data_received);
     if (SPEED != test || (ok_goal - 2) == ok)
     {
-      GNUNET_MESH_notify_transmit_ready (tunnel, GNUNET_NO,
+      GNUNET_MESH_notify_transmit_ready (channel, GNUNET_NO,
                                          GNUNET_TIME_UNIT_FOREVER_REL,
                                          size_payload, &tmt_rdy, (void *) 1L);
       return GNUNET_OK;
@@ -480,7 +481,7 @@ data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
       data_ack++;
       GNUNET_log (GNUNET_ERROR_TYPE_INFO,
               " received ack %u\n", data_ack);
-      GNUNET_MESH_notify_transmit_ready (tunnel, GNUNET_NO,
+      GNUNET_MESH_notify_transmit_ready (channel, GNUNET_NO,
                                          GNUNET_TIME_UNIT_FOREVER_REL,
                                          size_payload, &tmt_rdy, (void *) 1L);
       if (data_ack < TOTAL_PACKETS && SPEED != test)
@@ -491,13 +492,13 @@ data_callback (void *cls, struct GNUNET_MESH_Tunnel *tunnel, void **tunnel_ctx,
     }
     if (test == P2P_SIGNAL)
     {
-      GNUNET_MESH_tunnel_destroy (incoming_t);
-      incoming_t = NULL;
+      GNUNET_MESH_channel_destroy (incoming_ch);
+      incoming_ch = NULL;
     }
     else
     {
-      GNUNET_MESH_tunnel_destroy (t);
-      t = NULL;
+      GNUNET_MESH_channel_destroy (ch);
+      ch = NULL;
     }
   }
 
@@ -523,32 +524,32 @@ static struct GNUNET_MESH_MessageHandler handlers[] = {
 
 
 /**
- * Method called whenever another peer has added us to a tunnel
+ * Method called whenever another peer has added us to a channel
  * the other peer initiated.
  *
  * @param cls Closure.
- * @param tunnel New handle to the tunnel.
- * @param initiator Peer that started the tunnel.
- * @param port Port this tunnels is connected to.
- * @return Initial tunnel context for the tunnel
+ * @param channel New handle to the channel.
+ * @param initiator Peer that started the channel.
+ * @param port Port this channel is connected to.
+ * @return Initial channel context for the channel
  *         (can be NULL -- that's not an error).
  */
 static void *
-incoming_tunnel (void *cls, struct GNUNET_MESH_Tunnel *tunnel,
+incoming_channel (void *cls, struct GNUNET_MESH_Channel *channel,
                  const struct GNUNET_PeerIdentity *initiator,
                  uint32_t port)
 {
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Incoming tunnel from %s to peer %d\n",
+              "Incoming channel from %s to peer %d\n",
               GNUNET_i2s (initiator), (long) cls);
   ok++;
   GNUNET_log (GNUNET_ERROR_TYPE_INFO, " ok: %d\n", ok);
   if ((long) cls == 4L)
-    incoming_t = tunnel;
+    incoming_ch = channel;
   else
   {
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "Incoming tunnel for unknown client %lu\n", (long) cls);
+                "Incoming channel for unknown client %lu\n", (long) cls);
     GNUNET_break(0);
   }
   if (GNUNET_SCHEDULER_NO_TASK != disconnect_task)
@@ -563,32 +564,32 @@ incoming_tunnel (void *cls, struct GNUNET_MESH_Tunnel *tunnel,
 }
 
 /**
- * Function called whenever an inbound tunnel is destroyed.  Should clean up
+ * Function called whenever an inbound channel is destroyed.  Should clean up
  * any associated state.
  *
  * @param cls closure (set from GNUNET_MESH_connect)
- * @param tunnel connection to the other end (henceforth invalid)
- * @param tunnel_ctx place where local state associated
- *                   with the tunnel is stored
+ * @param channel connection to the other end (henceforth invalid)
+ * @param channel_ctx place where local state associated
+ *                   with the channel is stored
  */
 static void
-tunnel_cleaner (void *cls, const struct GNUNET_MESH_Tunnel *tunnel,
-                void *tunnel_ctx)
+channel_cleaner (void *cls, const struct GNUNET_MESH_Channel *channel,
+                 void *channel_ctx)
 {
   long i = (long) cls;
 
   GNUNET_log (GNUNET_ERROR_TYPE_INFO,
-              "Incoming tunnel disconnected at peer %d\n",
+              "Incoming channel disconnected at peer %d\n",
               i);
   if (4L == i)
   {
     ok++;
-    incoming_t = NULL;
+    incoming_ch = NULL;
   }
   else if (0L == i && P2P_SIGNAL == test)
   {
     ok ++;
-    t = NULL;
+    ch = NULL;
   }
   else
     GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
@@ -645,7 +646,7 @@ do_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   }
   else
     rel = GNUNET_NO;
-  t = GNUNET_MESH_tunnel_create (h1, NULL, p_id[1], 1, nobuf, rel);
+  ch = GNUNET_MESH_channel_create (h1, NULL, p_id[1], 1, nobuf, rel);
 
   disconnect_task = GNUNET_SCHEDULER_add_delayed (SHORT_TIME,
                                                   &disconnect_mesh_peers,
@@ -655,7 +656,7 @@ do_test (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
   data_ack = 0;
   data_received = 0;
   data_sent = 0;
-  GNUNET_MESH_notify_transmit_ready (t, GNUNET_NO,
+  GNUNET_MESH_notify_transmit_ready (ch, GNUNET_NO,
                                      GNUNET_TIME_UNIT_FOREVER_REL, 
                                      size_payload, &tmt_rdy, (void *) 1L);
 }
@@ -763,10 +764,10 @@ main (int argc, char *argv[])
   else if (strstr (argv[0], "_small_speed_ack") != NULL)
   {
    /* Each peer is supposed to generate the following callbacks:
-    * 1 incoming tunnel (@dest)
+    * 1 incoming channel (@dest)
     * TOTAL_PACKETS received data packet (@dest)
     * TOTAL_PACKETS received data packet (@orig)
-    * 1 received tunnel destroy (@dest)
+    * 1 received channel destroy (@dest)
     * _________________________________
     * 5 x ok expected per peer
     */
@@ -778,11 +779,11 @@ main (int argc, char *argv[])
   else if (strstr (argv[0], "_small_speed") != NULL)
   {
    /* Each peer is supposed to generate the following callbacks:
-    * 1 incoming tunnel (@dest)
+    * 1 incoming channel (@dest)
     * 1 initial packet (@dest)
     * TOTAL_PACKETS received data packet (@dest)
     * 1 received data packet (@orig)
-    * 1 received tunnel destroy (@dest)
+    * 1 received channel destroy (@dest)
     * _________________________________
     */
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "SPEED\n");
@@ -830,8 +831,8 @@ main (int argc, char *argv[])
                         5,
                         &tmain,
                         NULL, /* tmain cls */
-                        &incoming_tunnel,
-                        &tunnel_cleaner,
+                        &incoming_channel,
+                        &channel_cleaner,
                         handlers,
                         ports);