X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fmesh%2Fgnunet-service-mesh_peer.c;h=515c4b4f0fdae87e218465702fca5530893d6019;hb=0f6d24a229e9149db26a4e667ed25032d19f533a;hp=a4e17cefca6cd49f57539707067e979c4a9ec62b;hpb=8beabcd96c0cf1e1873c0b5ff96e537f1beb0b34;p=oweals%2Fgnunet.git

diff --git a/src/mesh/gnunet-service-mesh_peer.c b/src/mesh/gnunet-service-mesh_peer.c
index a4e17cefc..515c4b4f0 100644
--- a/src/mesh/gnunet-service-mesh_peer.c
+++ b/src/mesh/gnunet-service-mesh_peer.c
@@ -139,7 +139,7 @@ struct MeshPeer
     /**
      * Tunnel to this peer, if any.
      */
-  struct MeshTunnel2 *tunnel;
+  struct MeshTunnel3 *tunnel;
 
     /**
      * Connections that go through this peer, indexed by tid;
@@ -177,6 +177,16 @@ struct MeshPeer
  */
 extern struct GNUNET_STATISTICS_Handle *stats;
 
+/**
+ * Local peer own ID (full value).
+ */
+extern struct GNUNET_PeerIdentity my_full_id;
+
+/**
+ * Local peer own ID (short)
+ */
+extern GNUNET_PEER_Id myid;
+
 /**
  * Peers known, indexed by PeerIdentity (MeshPeer).
  */
@@ -197,15 +207,6 @@ static unsigned long long drop_percent;
  */
 static struct GNUNET_CORE_Handle *core_handle;
 
-/**
- * Local peer own ID (full value).
- */
-const static struct GNUNET_PeerIdentity *my_full_id;
-
-/**
- * Local peer own ID (short)
- */
-static GNUNET_PEER_Id my_short_id;
 
 /******************************************************************************/
 /***************************** CORE CALLBACKS *********************************/
@@ -231,7 +232,7 @@ notify_broken (void *cls,
   struct MeshPeer *peer = cls;
   struct MeshConnection *c = value;
 
-  GMC_notify_broken (c, peer, my_full_id);
+  GMC_notify_broken (c, peer);
 
   return GNUNET_YES;
 }
@@ -246,30 +247,30 @@ notify_broken (void *cls,
 static void
 core_connect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
-  struct MeshPeer *pi;
+  struct MeshPeer *mp;
   struct MeshPeerPath *path;
 
-  LOG ("Peer connected\n");
-  LOG ("     %s\n", GNUNET_i2s (&my_full_id));
-  pi = peer_get (peer);
-  if (myid == pi->id)
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Peer connected\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "     %s\n", GNUNET_i2s (&my_full_id));
+  mp = GMP_get (peer);
+  if (myid == mp->id)
   {
-    LOG ("     (self)\n");
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "     (self)\n");
     path = path_new (1);
   }
   else
   {
-    LOG ("     %s\n", GNUNET_i2s (peer));
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "     %s\n", GNUNET_i2s (peer));
     path = path_new (2);
-    path->peers[1] = pi->id;
-    GNUNET_PEER_change_rc (pi->id, 1);
+    path->peers[1] = mp->id;
+    GNUNET_PEER_change_rc (mp->id, 1);
     GNUNET_STATISTICS_update (stats, "# peers", 1, GNUNET_NO);
   }
   path->peers[0] = myid;
   GNUNET_PEER_change_rc (myid, 1);
-  peer_add_path (pi, path, GNUNET_YES);
+  GMP_add_path (mp, path, GNUNET_YES);
 
-  pi->connections = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
+  mp->connections = GNUNET_CONTAINER_multihashmap_create (32, GNUNET_YES);
   return;
 }
 
@@ -285,7 +286,7 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
 {
   struct MeshPeer *pi;
 
-  LOG ("Peer disconnected\n");
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "Peer disconnected\n");
   pi = GNUNET_CONTAINER_multipeermap_get (peers, peer);
   if (NULL == pi)
   {
@@ -303,7 +304,7 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
     }
   if (myid == pi->id)
   {
-    LOG ("     (self)\n");
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "     (self)\n");
   }
   GNUNET_STATISTICS_update (stats, "# peers", -1, GNUNET_NO);
 
@@ -331,8 +332,7 @@ static struct GNUNET_CORE_MessageHandler core_handlers[] = {
     sizeof (struct GNUNET_MESH_ACK)},
   {&GMC_handle_poll, GNUNET_MESSAGE_TYPE_MESH_POLL,
     sizeof (struct GNUNET_MESH_Poll)},
-  {&GMC_handle_fwd, GNUNET_MESSAGE_TYPE_MESH_FWD, 0},
-  {&GMC_handle_bck, GNUNET_MESSAGE_TYPE_MESH_BCK, 0},
+  {&GMC_handle_encrypted, GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED, 0},
   {NULL, 0, 0}
 };
 
@@ -416,7 +416,7 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf)
 {
   struct GNUNET_MESH_ConnectionCreate *msg;
   struct GNUNET_PeerIdentity *peer_ptr;
-  struct MeshPeerPath *p = c->path;
+  const struct MeshPeerPath *p = GMC_get_path (c);
   size_t size_needed;
   int i;
 
@@ -433,7 +433,7 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf)
   msg = (struct GNUNET_MESH_ConnectionCreate *) buf;
   msg->header.size = htons (size_needed);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE);
-  msg->cid = c->id;
+  msg->cid = *GMC_get_id (c);
 
   peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
   for (i = 0; i < p->length; i++)
@@ -441,8 +441,9 @@ send_core_connection_create (struct MeshConnection *c, size_t size, void *buf)
     GNUNET_PEER_resolve (p->peers[i], peer_ptr++);
   }
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG,
-              "CONNECTION CREATE (%u bytes long) sent!\n", size_needed);
+  LOG (GNUNET_ERROR_TYPE_DEBUG, 
+       "CONNECTION CREATE (%u bytes long) sent!\n",
+       size_needed);
   return size_needed;
 }
 
@@ -460,10 +461,8 @@ static size_t
 send_core_connection_ack (struct MeshConnection *c, size_t size, void *buf)
 {
   struct GNUNET_MESH_ConnectionACK *msg = buf;
-  struct MeshTunnel2 *t = c->t;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "Sending CONNECTION ACK...\n");
-  GNUNET_assert (NULL != t);
   if (sizeof (struct GNUNET_MESH_ConnectionACK) > size)
   {
     GNUNET_break (0);
@@ -471,7 +470,7 @@ send_core_connection_ack (struct MeshConnection *c, size_t size, void *buf)
   }
   msg->header.size = htons (sizeof (struct GNUNET_MESH_ConnectionACK));
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK);
-  msg->cid = c->id;
+  msg->cid = *GMC_get_id (c);
   msg->reserved = 0;
 
   /* TODO add signature */
@@ -500,7 +499,7 @@ shutdown_tunnel (void *cls,
                  void *value)
 {
   struct MeshPeer *p = value;
-  struct MeshTunnel2 *t = p->tunnel;
+  struct MeshTunnel3 *t = p->tunnel;
 
   if (NULL != t)
     GMT_destroy (t);
@@ -533,21 +532,21 @@ peer_destroy (struct MeshPeer *peer)
     LOG (GNUNET_ERROR_TYPE_WARNING,
                 "removing peer %s, not in peermap\n", GNUNET_i2s (&id));
   }
-    if (NULL != peer->search_h)
-    {
-      GMD_search_stop (peer->search_h);
-    }
-      p = peer->path_head;
-      while (NULL != p)
-      {
-        nextp = p->next;
-        GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p);
-        path_destroy (p);
-        p = nextp;
-      }
-        tunnel_destroy_empty (peer->tunnel);
-        GNUNET_free (peer);
-        return GNUNET_OK;
+  if (NULL != peer->search_h)
+  {
+    GMD_search_stop (peer->search_h);
+  }
+  p = peer->path_head;
+  while (NULL != p)
+  {
+    nextp = p->next;
+    GNUNET_CONTAINER_DLL_remove (peer->path_head, peer->path_tail, p);
+    path_destroy (p);
+    p = nextp;
+  }
+  GMT_destroy_empty (peer->tunnel);
+  GNUNET_free (peer);
+  return GNUNET_OK;
 }
 
 
@@ -646,125 +645,74 @@ peer_delete_oldest (void)
 
 
 /**
- * Retrieve the MeshPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
+ * Choose the best path towards a peer considering the tunnel properties.
  *
- * @param peer Full identity of the peer.
+ * @param peer The destination peer.
  *
- * @return Existing or newly created peer info.
+ * @return Best current known path towards the peer, if any.
  */
-static struct MeshPeer *
-peer_get (const struct GNUNET_PeerIdentity *peer_id)
+static struct MeshPeerPath *
+peer_get_best_path (const struct MeshPeer *peer)
 {
-  struct MeshPeer *peer;
+  struct MeshPeerPath *best_p;
+  struct MeshPeerPath *p;
+  unsigned int best_cost;
+  unsigned int cost;
 
-  peer = GNUNET_CONTAINER_multipeermap_get (peers, peer_id);
-  if (NULL == peer)
+  best_cost = UINT_MAX;
+  best_p = NULL;
+  for (p = peer->path_head; NULL != p; p = p->next)
   {
-    peer = GNUNET_new (struct MeshPeer);
-    if (GNUNET_CONTAINER_multipeermap_size (peers) > max_peers)
+    if (GNUNET_YES == GMT_is_path_used (peer->tunnel, p))
+      continue; /* If path is already in use, skip it. */
+
+    if ((cost = GMT_get_path_cost (peer->tunnel, p)) < best_cost)
     {
-      peer_delete_oldest ();
+      best_cost = cost;
+      best_p = p;
     }
-        GNUNET_CONTAINER_multipeermap_put (peers, peer_id, peer,
-                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
-        peer->id = GNUNET_PEER_intern (peer_id);
   }
-    peer->last_contact = GNUNET_TIME_absolute_get();
-
-    return peer;
-}
-
-
-/**
- * Retrieve the MeshPeer stucture associated with the peer, create one
- * and insert it in the appropriate structures if the peer is not known yet.
- *
- * @param peer Short identity of the peer.
- *
- * @return Existing or newly created peer info.
- */
-static struct MeshPeer *
-peer_get_short (const GNUNET_PEER_Id peer)
-{
-  return peer_get (GNUNET_PEER_resolve2 (peer));
+  return best_p;
 }
 
 
-/**
- * Get a cost of a path for a peer considering existing tunnel connections.
- *
- * @param peer Peer towards which the path is considered.
- * @param path Candidate path.
- *
- * @return Cost of the path (path length + number of overlapping nodes)
- */
-static unsigned int
-peer_get_path_cost (const struct MeshPeer *peer,
-                    const struct MeshPeerPath *path)
+static int
+queue_is_sendable (struct MeshPeerQueue *q)
 {
-  struct MeshConnection *c;
-  unsigned int overlap;
-  unsigned int i;
-  unsigned int j;
-
-  if (NULL == path)
-    return 0;
-
-  overlap = 0;
-  GNUNET_assert (NULL != peer->tunnel);
-
-  for (i = 0; i < path->length; i++)
+  /* Is PID-independent? */
+  switch (q->type)
   {
-    for (c = peer->tunnel->connection_head; NULL != c; c = c->next)
-    {
-      for (j = 0; j < c->path->length; j++)
-      {
-        if (path->peers[i] == c->path->peers[j])
-        {
-          overlap++;
-          break;
-        }
-      }
-    }
+    case GNUNET_MESSAGE_TYPE_MESH_ACK:
+    case GNUNET_MESSAGE_TYPE_MESH_POLL:
+      return GNUNET_YES;
   }
-  return (path->length + overlap) * (path->score * -1);
+
+  if (GMC_is_sendable (q->c, q->fwd))
+    return GNUNET_YES;
+
+  return GNUNET_NO;
 }
 
 
 /**
- * Choose the best path towards a peer considering the tunnel properties.
+ * Get first sendable message.
  *
  * @param peer The destination peer.
  *
  * @return Best current known path towards the peer, if any.
  */
-static struct MeshPeerPath *
-peer_get_best_path (const struct MeshPeer *peer)
+static struct MeshPeerQueue *
+peer_get_first_message (const struct MeshPeer *peer)
 {
-  struct MeshPeerPath *best_p;
-  struct MeshPeerPath *p;
-  struct MeshConnection *c;
-  unsigned int best_cost;
-  unsigned int cost;
+  struct MeshPeerQueue *q;
 
-  best_cost = UINT_MAX;
-  best_p = NULL;
-  for (p = peer->path_head; NULL != p; p = p->next)
+  for (q = peer->queue_head; NULL != q; q = q->next)
   {
-    for (c = peer->tunnel->connection_head; NULL != c; c = c->next)
-      if (c->path == p)
-        break;
-      if (NULL != c)
-        continue; /* If path is in use in a connection, skip it. */
-
-            if ((cost = peer_get_path_cost (peer, p)) < best_cost)
-            {
-              best_cost = cost;
-              best_p = p;
-            }
+    if (queue_is_sendable (q))
+      return q;
   }
-    return best_p;
+
+  return NULL;
 }
 
 
@@ -777,21 +725,21 @@ peer_get_best_path (const struct MeshPeer *peer)
  * @param path
  */
 static void
-search_handler (void *cls, struct MeshPeerPath *path)
+search_handler (void *cls, const struct MeshPeerPath *path)
 {
   struct MeshPeer *peer = cls;
   unsigned int connection_count;
 
-  path_add_to_peers (path, GNUNET_NO);
+  GMP_add_path_to_all (path, GNUNET_NO);
 
   /* Count connections */
-  connection_count = GMC_count (peer->tunnel->connection_head);
+  connection_count = GMT_count_connections (peer->tunnel);
 
   /* If we already have 3 (or more (?!)) connections, it's enough */
   if (3 <= connection_count)
     return;
 
-  if (peer->tunnel->state == MESH_TUNNEL3_SEARCHING)
+  if (MESH_TUNNEL3_SEARCHING == GMT_get_state (peer->tunnel))
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, " ... connect!\n");
     GMP_connect (peer);
@@ -800,6 +748,67 @@ search_handler (void *cls, struct MeshPeerPath *path)
 }
 
 
+/**
+ * Free a transmission that was already queued with all resources
+ * associated to the request.
+ *
+ * @param queue Queue handler to cancel.
+ * @param clear_cls Is it necessary to free associated cls?
+ */
+static void
+queue_destroy (struct MeshPeerQueue *queue, int clear_cls)
+{
+  struct MeshPeer *peer;
+
+  peer = queue->peer;
+  GNUNET_assert (NULL != queue->c);
+
+  if (GNUNET_YES == clear_cls)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "#   queue destroy type %s\n",
+                GNUNET_MESH_DEBUG_M2S (queue->type));
+    switch (queue->type)
+    {
+      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY:
+      case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY:
+        LOG (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n");
+        /* fall through */
+      case GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED:
+      case GNUNET_MESSAGE_TYPE_MESH_ACK:
+      case GNUNET_MESSAGE_TYPE_MESH_POLL:
+      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK:
+      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE:
+      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN:
+        LOG (GNUNET_ERROR_TYPE_DEBUG, "#   prebuilt message\n");;
+        GNUNET_free_non_null (queue->cls);
+        break;
+
+      default:
+        GNUNET_break (0);
+        LOG (GNUNET_ERROR_TYPE_ERROR, "#   type %s unknown!\n",
+                    GNUNET_MESH_DEBUG_M2S (queue->type));
+    }
+  }
+  GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue);
+
+  if (queue->type != GNUNET_MESSAGE_TYPE_MESH_ACK &&
+      queue->type != GNUNET_MESSAGE_TYPE_MESH_POLL)
+  {
+    peer->queue_n--;
+  }
+
+  if (NULL != queue->callback)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "#   Calling callback\n");
+    queue->callback (queue->callback_cls,
+                     queue->c, queue->type,
+                     queue->fwd, queue->size,
+                     GNUNET_TIME_absolute_get_duration (queue->start_waiting));
+  }
+
+  GNUNET_free (queue);
+}
+
 /**
  * Core callback to write a queued packet to core buffer
  *
@@ -813,17 +822,10 @@ static size_t
 queue_send (void *cls, size_t size, void *buf)
 {
   struct MeshPeer *peer = cls;
-  struct MeshFlowControl *fc;
   struct MeshConnection *c;
-  struct GNUNET_MessageHeader *msg;
   struct MeshPeerQueue *queue;
-  struct MeshTunnel2 *t;
-  struct MeshChannel *ch;
   const struct GNUNET_PeerIdentity *dst_id;
   size_t data_size;
-  uint32_t pid;
-  uint16_t type;
-  int fwd;
 
   peer->core_transmit = NULL;
   LOG (GNUNET_ERROR_TYPE_DEBUG, "* Queue send (max %u)\n", size);
@@ -842,8 +844,6 @@ queue_send (void *cls, size_t size, void *buf)
     return 0;
   }
   c = queue->c;
-  fwd = queue->fwd;
-  fc = fwd ? &c->fwd_fc : &c->bck_fc;
 
   dst_id = GNUNET_PEER_resolve2 (peer->id);
   LOG (GNUNET_ERROR_TYPE_DEBUG, "*   towards %s\n", GNUNET_i2s (dst_id));
@@ -864,25 +864,19 @@ queue_send (void *cls, size_t size, void *buf)
   }
   LOG (GNUNET_ERROR_TYPE_DEBUG, "*   size %u ok\n", queue->size);
 
-  t = (NULL != c) ? c->t : NULL;
-  type = 0;
-
   /* Fill buf */
   switch (queue->type)
   {
-    case GNUNET_MESSAGE_TYPE_MESH_TUNNEL3_DESTROY:
+    case GNUNET_MESSAGE_TYPE_MESH_TUNNEL_DESTROY:
     case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY:
     case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN:
-    case GNUNET_MESSAGE_TYPE_MESH_FWD:
-    case GNUNET_MESSAGE_TYPE_MESH_BCK:
+    case GNUNET_MESSAGE_TYPE_MESH_ENCRYPTED:
     case GNUNET_MESSAGE_TYPE_MESH_ACK:
     case GNUNET_MESSAGE_TYPE_MESH_POLL:
       LOG (GNUNET_ERROR_TYPE_DEBUG,
                   "*   raw: %s\n",
                   GNUNET_MESH_DEBUG_M2S (queue->type));
       data_size = send_core_data_raw (queue->cls, size, buf);
-      msg = (struct GNUNET_MessageHeader *) buf;
-      type = ntohs (msg->type);
       break;
     case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE:
       LOG (GNUNET_ERROR_TYPE_DEBUG, "*   path create\n");
@@ -922,38 +916,16 @@ queue_send (void *cls, size_t size, void *buf)
     data_size = 0;
   }
 
-  if (NULL != queue->callback)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "*   Calling callback\n");
-    queue->callback (queue->callback_cls,
-                    queue->c,
-                    GNUNET_TIME_absolute_get_duration (queue->start_waiting));
-  }
-
   /* Free queue, but cls was freed by send_core_* */
-  ch = queue->ch;
-  GMP_queue_destroy (queue, GNUNET_NO);
-
-  /* Send ACK if needed, after accounting for sent ID in fc->queue_n */
-  switch (type)
-  {
-    case GNUNET_MESSAGE_TYPE_MESH_FWD:
-    case GNUNET_MESSAGE_TYPE_MESH_BCK:
-      pid = ntohl ( ((struct GNUNET_MESH_Encrypted *) buf)->pid );
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "*   accounting pid %u\n", pid);
-      fc->last_pid_sent = pid;
-      send_ack (c, ch, fwd);
-      break;
-    default:
-      break;
-  }
+  queue_destroy (queue, GNUNET_NO);
 
   /* If more data in queue, send next */
   queue = peer_get_first_message (peer);
   if (NULL != queue)
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG, "*   more data!\n");
-    if (NULL == peer->core_transmit) {
+    if (NULL == peer->core_transmit)
+    {
       peer->core_transmit =
           GNUNET_CORE_notify_transmit_ready(core_handle,
                                             0,
@@ -970,168 +942,26 @@ queue_send (void *cls, size_t size, void *buf)
       LOG (GNUNET_ERROR_TYPE_DEBUG,
                   "*   tmt rdy called somewhere else\n");
     }
-    if (GNUNET_SCHEDULER_NO_TASK == fc->poll_task)
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "*   starting poll timeout\n");
-      fc->poll_task =
-          GNUNET_SCHEDULER_add_delayed (fc->poll_time, &connection_poll, fc);
-    }
+//     GMC_start_poll (); FIXME needed?
   }
   else
   {
-    if (GNUNET_SCHEDULER_NO_TASK != fc->poll_task)
-    {
-      GNUNET_SCHEDULER_cancel (fc->poll_task);
-      fc->poll_task = GNUNET_SCHEDULER_NO_TASK;
-    }
-  }
-  if (NULL != c)
-  {
-    c->pending_messages--;
-    if (GNUNET_YES == c->destroy && 0 == c->pending_messages)
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG, "*  destroying connection!\n");
-      GMC_destroy (c);
-    }
+//     GMC_stop_poll(); FIXME needed?
   }
 
-  if (NULL != t)
-  {
-    t->pending_messages--;
-    if (GNUNET_YES == t->destroy && 0 == t->pending_messages)
-    {
-//       LOG (GNUNET_ERROR_TYPE_DEBUG, "*  destroying tunnel!\n");
-      tunnel_destroy (t);
-    }
-  }
   LOG (GNUNET_ERROR_TYPE_DEBUG, "*  Return %d\n", data_size);
   return data_size;
 }
 
 
-
-/**
- * Get first sendable message.
- *
- * @param peer The destination peer.
- *
- * @return Best current known path towards the peer, if any.
- */
-static struct MeshPeerQueue *
-peer_get_first_message (const struct MeshPeer *peer)
-{
-  struct MeshPeerQueue *q;
-
-  for (q = peer->queue_head; NULL != q; q = q->next)
-  {
-    if (queue_is_sendable (q))
-      return q;
-  }
-
-  return NULL;
-}
-
-
-static int
-queue_is_sendable (struct MeshPeerQueue *q)
-{
-  struct MeshFlowControl *fc;
-
-  /* Is PID-independent? */
-  switch (q->type)
-  {
-    case GNUNET_MESSAGE_TYPE_MESH_ACK:
-    case GNUNET_MESSAGE_TYPE_MESH_POLL:
-      return GNUNET_YES;
-  }
-
-  /* Is PID allowed? */
-  fc = q->fwd ? &q->c->fwd_fc : &q->c->bck_fc;
-  if (GMC_is_pid_bigger (fc->last_ack_recv, fc->last_pid_sent))
-    return GNUNET_YES;
-
-  return GNUNET_NO;
-}
-
-
 /******************************************************************************/
 /********************************    API    ***********************************/
 /******************************************************************************/
 
-
-/**
- * Free a transmission that was already queued with all resources
- * associated to the request.
- *
- * @param queue Queue handler to cancel.
- * @param clear_cls Is it necessary to free associated cls?
- */
-void
-GMP_queue_destroy (struct MeshPeerQueue *queue, int clear_cls)
-{
-  struct MeshPeer *peer;
-  struct MeshFlowControl *fc;
-  int fwd;
-
-  fwd = queue->fwd;
-  peer = queue->peer;
-  GNUNET_assert (NULL != queue->c);
-  fc = fwd ? &queue->c->fwd_fc : &queue->c->bck_fc;
-
-  if (GNUNET_YES == clear_cls)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "   queue destroy type %s\n",
-                GNUNET_MESH_DEBUG_M2S (queue->type));
-    switch (queue->type)
-    {
-      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_DESTROY:
-      case GNUNET_MESSAGE_TYPE_MESH_TUNNEL3_DESTROY:
-        LOG (GNUNET_ERROR_TYPE_INFO, "destroying a DESTROY message\n");
-        GNUNET_break (GNUNET_YES == queue->c->destroy);
-        /* fall through */
-      case GNUNET_MESSAGE_TYPE_MESH_FWD:
-      case GNUNET_MESSAGE_TYPE_MESH_BCK:
-      case GNUNET_MESSAGE_TYPE_MESH_ACK:
-      case GNUNET_MESSAGE_TYPE_MESH_POLL:
-      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_ACK:
-      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_CREATE:
-      case GNUNET_MESSAGE_TYPE_MESH_CONNECTION_BROKEN:
-        LOG (GNUNET_ERROR_TYPE_DEBUG, "   prebuilt message\n");;
-        GNUNET_free_non_null (queue->cls);
-        break;
-
-      default:
-        GNUNET_break (0);
-        LOG (GNUNET_ERROR_TYPE_ERROR, "   type %s unknown!\n",
-                    GNUNET_MESH_DEBUG_M2S (queue->type));
-    }
-
-  }
-  GNUNET_CONTAINER_DLL_remove (peer->queue_head, peer->queue_tail, queue);
-
-  if (queue->type != GNUNET_MESSAGE_TYPE_MESH_ACK &&
-      queue->type != GNUNET_MESSAGE_TYPE_MESH_POLL)
-  {
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  Q_N- %p %u\n", fc, fc->queue_n);
-    fc->queue_n--;
-    peer->queue_n--;
-  }
-  if (NULL != queue->c)
-  {
-    queue->c->pending_messages--;
-    if (NULL != queue->c->t)
-    {
-      queue->c->t->pending_messages--;
-    }
-  }
-
-  GNUNET_free (queue);
-}
-
-
 /**
  * @brief Queue and pass message to core when possible.
  *
+ * @param peer Peer towards which to queue the message.
  * @param cls Closure (@c type dependant). It will be used by queue_send to
  *            build the message to be sent if not already prebuilt.
  * @param type Type of the message, 0 for a raw message.
@@ -1139,19 +969,15 @@ GMP_queue_destroy (struct MeshPeerQueue *queue, int clear_cls)
  * @param c Connection this message belongs to (cannot be NULL).
  * @param ch Channel this message belongs to, if applicable (otherwise NULL).
  * @param fwd Is this a message going root->dest? (FWD ACK are NOT FWD!)
- * @param callback Function to be called once CORE has taken the message.
- * @param callback_cls Closure for @c callback.
+ * @param cont Continuation to be called once CORE has taken the message.
+ * @param cont_cls Closure for @c cont.
  */
 void
-GMP_queue_add (void *cls, uint16_t type, size_t size,
-               struct MeshConnection *c,
-               struct MeshChannel *ch,
-               int fwd,
-               GMP_sent callback, void *callback_cls)
+GMP_queue_add (struct MeshPeer *peer, void *cls, uint16_t type, size_t size,
+               struct MeshConnection *c, struct MeshChannel *ch, int fwd,
+               GMP_sent cont, void *cont_cls)
 {
   struct MeshPeerQueue *queue;
-  struct MeshFlowControl *fc;
-  struct MeshPeer *peer;
   int priority;
   int call_core;
 
@@ -1160,15 +986,6 @@ GMP_queue_add (void *cls, uint16_t type, size_t size,
               fwd ? "FWD" : "BCK",  GNUNET_MESH_DEBUG_M2S (type), size, c, ch);
   GNUNET_assert (NULL != c);
 
-  fc   = fwd ? &c->fwd_fc : &c->bck_fc;
-  peer = fwd ? connection_get_next_hop (c) : connection_get_prev_hop (c);
-
-  if (NULL == fc)
-  {
-    GNUNET_break (0);
-    return;
-  }
-
   if (NULL == peer->connections)
   {
     /* We are not connected to this peer, ignore request. */
@@ -1185,36 +1002,8 @@ GMP_queue_add (void *cls, uint16_t type, size_t size,
   }
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "priority %d\n", priority);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "fc %p\n", fc);
-  if (fc->queue_n >= fc->queue_max && 0 == priority)
-  {
-    GNUNET_STATISTICS_update (stats, "# messages dropped (buffer full)",
-                              1, GNUNET_NO);
-    GNUNET_break (0);
-    LOG (GNUNET_ERROR_TYPE_DEBUG,
-                "queue full: %u/%u\n",
-                fc->queue_n, fc->queue_max);
-    return; /* Drop this message */
-  }
 
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "last pid %u\n", fc->last_pid_sent);
-  LOG (GNUNET_ERROR_TYPE_DEBUG, "     ack %u\n", fc->last_ack_recv);
-  if (GMC_is_pid_bigger (fc->last_pid_sent + 1, fc->last_ack_recv))
-  {
-    call_core = GNUNET_NO;
-    if (GNUNET_SCHEDULER_NO_TASK == fc->poll_task &&
-        GNUNET_MESSAGE_TYPE_MESH_POLL != type)
-    {
-      LOG (GNUNET_ERROR_TYPE_DEBUG,
-                  "no buffer space (%u > %u): starting poll\n",
-                  fc->last_pid_sent + 1, fc->last_ack_recv);
-      fc->poll_task = GNUNET_SCHEDULER_add_delayed (fc->poll_time,
-                                                    &connection_poll,
-                                                    fc);
-    }
-  }
-  else
-    call_core = GNUNET_YES;
+  call_core = GMC_is_sendable (c, fwd);
   queue = GNUNET_malloc (sizeof (struct MeshPeerQueue));
   queue->cls = cls;
   queue->type = type;
@@ -1223,8 +1012,8 @@ GMP_queue_add (void *cls, uint16_t type, size_t size,
   queue->c = c;
   queue->ch = ch;
   queue->fwd = fwd;
-  queue->callback = callback;
-  queue->callback_cls = callback_cls;
+  queue->callback = cont;
+  queue->callback_cls = cont_cls;
   if (100 <= priority)
   {
     struct MeshPeerQueue *copy;
@@ -1236,7 +1025,7 @@ GMP_queue_add (void *cls, uint16_t type, size_t size,
       if (copy->type == type && copy->c == c && copy->fwd == fwd)
       {
         /* Example: also a FWD ACK for connection XYZ */
-        GMP_queue_destroy (copy, GNUNET_YES);
+        queue_destroy (copy, GNUNET_YES);
       }
     }
     GNUNET_CONTAINER_DLL_insert (peer->queue_head, peer->queue_tail, queue);
@@ -1244,8 +1033,6 @@ GMP_queue_add (void *cls, uint16_t type, size_t size,
   else
   {
     GNUNET_CONTAINER_DLL_insert_tail (peer->queue_head, peer->queue_tail, queue);
-    LOG (GNUNET_ERROR_TYPE_DEBUG, "  Q_N+ %p %u\n", fc, fc->queue_n);
-    fc->queue_n++;
     peer->queue_n++;
   }
 
@@ -1253,7 +1040,7 @@ GMP_queue_add (void *cls, uint16_t type, size_t size,
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
                 "calling core tmt rdy towards %s for %u bytes\n",
-                peer2s (peer), size);
+                GMP_2s (peer), size);
     peer->core_transmit =
         GNUNET_CORE_notify_transmit_ready (core_handle,
                                            0,
@@ -1269,12 +1056,9 @@ GMP_queue_add (void *cls, uint16_t type, size_t size,
   {
     LOG (GNUNET_ERROR_TYPE_DEBUG,
                 "core tmt rdy towards %s already called\n",
-                peer2s (peer));
+                GMP_2s (peer));
 
   }
-  c->pending_messages++;
-  if (NULL != c->t)
-    c->t->pending_messages++;
 }
 
 
@@ -1298,7 +1082,7 @@ GMP_queue_cancel (struct MeshPeer *peer, struct MeshConnection *c)
       LOG (GNUNET_ERROR_TYPE_DEBUG,
                   "connection_cancel_queue %s\n",
                   GNUNET_MESH_DEBUG_M2S (q->type));
-      GMP_queue_destroy (q, GNUNET_YES);
+      queue_destroy (q, GNUNET_YES);
     }
   }
   if (NULL == peer->queue_head)
@@ -1312,6 +1096,62 @@ GMP_queue_cancel (struct MeshPeer *peer, struct MeshConnection *c)
 }
 
 
+/**
+ * Get the first transmittable message for a connection.
+ *
+ * @param peer Neighboring peer.
+ * @param c Connection.
+ *
+ * @return First transmittable message.
+ */
+static struct MeshPeerQueue *
+connection_get_first_message (struct MeshPeer *peer, struct MeshConnection *c)
+{
+  struct MeshPeerQueue *q;
+
+  for (q = peer->queue_head; NULL != q; q = q->next)
+  {
+    if (q->c != c)
+      continue;
+    if (queue_is_sendable (q))
+      return q;
+  }
+
+  return NULL;
+}
+
+void
+GMP_queue_unlock (struct MeshPeer *peer, struct MeshConnection *c)
+{
+  struct MeshPeerQueue *q;
+  size_t size;
+
+  if (NULL != peer->core_transmit)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "  already unlocked!\n");
+    return; /* Already unlocked */
+  }
+
+  q = connection_get_first_message (peer, c);
+  if (NULL == q)
+  {
+    LOG (GNUNET_ERROR_TYPE_DEBUG, "  queue empty!\n");
+    return; /* Nothing to transmit */
+  }
+
+  size = q->size;
+  peer->core_transmit =
+      GNUNET_CORE_notify_transmit_ready (core_handle,
+                                         GNUNET_NO,
+                                         0,
+                                         GNUNET_TIME_UNIT_FOREVER_REL,
+                                         GNUNET_PEER_resolve2 (peer->id),
+                                         size,
+                                         &queue_send,
+                                         peer);
+}
+
+
 /**
  * Initialize the peer subsystem.
  *
@@ -1319,18 +1159,15 @@ GMP_queue_cancel (struct MeshPeer *peer, struct MeshConnection *c)
  * @param id Peer identity
  */
 void
-GMP_init (const struct GNUNET_CONFIGURATION_Handle *c,
-          const struct GNUNET_PeerIdentity *id)
+GMP_init (const struct GNUNET_CONFIGURATION_Handle *c)
 {
-  my_full_id = id;
-  my_short_id = GNUNET_PEER_intern (id);
-
+  LOG (GNUNET_ERROR_TYPE_DEBUG, "init\n");
   peers = GNUNET_CONTAINER_multipeermap_create (128, GNUNET_NO);
   if (GNUNET_OK !=
       GNUNET_CONFIGURATION_get_value_number (c, "MESH", "MAX_PEERS",
                                              &max_peers))
   {
-    LOG_config_invalid (GNUNET_ERROR_TYPE_WARNING,
+    GNUNET_log_config_invalid (GNUNET_ERROR_TYPE_WARNING,
                                "MESH", "MAX_PEERS", "USING DEFAULT");
     max_peers = 1000;
   }
@@ -1382,28 +1219,73 @@ GMP_shutdown (void)
     GNUNET_CORE_disconnect (core_handle);
     core_handle = NULL;
   }
-  GNUNET_PEER_change_rc (my_short_id, -1);
+  GNUNET_PEER_change_rc (myid, -1);
+}
+
+/**
+ * Retrieve the MeshPeer stucture associated with the peer, create one
+ * and insert it in the appropriate structures if the peer is not known yet.
+ *
+ * @param peer Full identity of the peer.
+ *
+ * @return Existing or newly created peer structure.
+ */
+struct MeshPeer *
+GMP_get (const struct GNUNET_PeerIdentity *peer_id)
+{
+  struct MeshPeer *peer;
+
+  peer = GNUNET_CONTAINER_multipeermap_get (peers, peer_id);
+  if (NULL == peer)
+  {
+    peer = GNUNET_new (struct MeshPeer);
+    if (GNUNET_CONTAINER_multipeermap_size (peers) > max_peers)
+    {
+      peer_delete_oldest ();
+    }
+        GNUNET_CONTAINER_multipeermap_put (peers, peer_id, peer,
+                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+        peer->id = GNUNET_PEER_intern (peer_id);
+  }
+    peer->last_contact = GNUNET_TIME_absolute_get();
+
+    return peer;
+}
+
+
+/**
+ * Retrieve the MeshPeer stucture associated with the peer, create one
+ * and insert it in the appropriate structures if the peer is not known yet.
+ *
+ * @param peer Short identity of the peer.
+ *
+ * @return Existing or newly created peer structure.
+ */
+struct MeshPeer *
+GMP_get_short (const GNUNET_PEER_Id peer)
+{
+  return GMP_get (GNUNET_PEER_resolve2 (peer));
 }
 
 
 /**
- * Try to establish a new connection to this peer in the given tunnel.
+ * Try to establish a new connection to this peer (in its tunnel).
  * If the peer doesn't have any path to it yet, try to get one.
  * If the peer already has some path, send a CREATE CONNECTION towards it.
  *
- * @param peer PeerInfo of the peer.
+ * @param peer Peer to connect to.
  */
 void
 GMP_connect (struct MeshPeer *peer)
 {
-  struct MeshTunnel2 *t;
+  struct MeshTunnel3 *t;
   struct MeshPeerPath *p;
   struct MeshConnection *c;
   int rerun_search;
 
   LOG (GNUNET_ERROR_TYPE_DEBUG,
               "peer_connect towards %s\n",
-              peer2s (peer));
+              GMP_2s (peer));
   t = peer->tunnel;
   c = NULL;
   rerun_search = GNUNET_NO;
@@ -1415,7 +1297,7 @@ GMP_connect (struct MeshPeer *peer)
     if (NULL != p)
     {
       LOG (GNUNET_ERROR_TYPE_DEBUG, "  %u hops\n", p->length);
-      c = tunnel_use_path (t, p);
+      c = GMT_use_path (t, p);
       if (NULL == c)
       {
         /* This case can happen when the path includes a first hop that is
@@ -1435,7 +1317,7 @@ GMP_connect (struct MeshPeer *peer)
       }
       else
       {
-        send_connection_create (c);
+        GMC_send_create (c);
         return;
       }
     }
@@ -1456,9 +1338,9 @@ GMP_connect (struct MeshPeer *peer)
 
     id = GNUNET_PEER_resolve2 (peer->id);
     LOG (GNUNET_ERROR_TYPE_DEBUG,
-                "  Starting DHT GET for peer %s\n", peer2s (peer));
+                "  Starting DHT GET for peer %s\n", GMP_2s (peer));
     peer->search_h = GMD_search (id, &search_handler, peer);
-    if (MESH_TUNNEL3_NEW == t->state)
+    if (MESH_TUNNEL3_NEW == GMT_get_state (t))
       GMT_change_state (t, MESH_TUNNEL3_SEARCHING);
   }
 }
@@ -1471,7 +1353,7 @@ GMP_connect (struct MeshPeer *peer)
  * @param t Tunnel.
  */
 void
-GMP_set_tunnel (struct MeshPeer *peer, struct MeshTunnel2 *t)
+GMP_set_tunnel (struct MeshPeer *peer, struct MeshTunnel3 *t)
 {
   peer->tunnel = t;
 }
@@ -1503,6 +1385,23 @@ GMP_is_neighbor (const struct MeshPeer *peer)
 }
 
 
+/**
+ * Create and initialize a new tunnel towards a peer, in case it has none.
+ * In case the peer already has a tunnel, nothing is done.
+ *
+ * Does not generate any traffic, just creates the local data structures.
+ *
+ * @param peer Peer towards which to create the tunnel.
+ */
+void
+GMP_add_tunnel (struct MeshPeer *peer)
+{
+  if (NULL != peer->tunnel)
+    return;
+  peer->tunnel = GMT_new (peer);
+}
+
+
 /**
  * Add a connection to a neighboring peer.
  *
@@ -1517,7 +1416,7 @@ GMP_is_neighbor (const struct MeshPeer *peer)
  */
 int
 GMP_add_connection (struct MeshPeer *peer,
-                    const struct MeshConnection *c)
+                    struct MeshConnection *c)
 {
   if (NULL == peer->connections)
   {
@@ -1583,7 +1482,7 @@ GMP_add_path (struct MeshPeer *peer_info, struct MeshPeerPath *path,
   }
 
   LOG (GNUNET_ERROR_TYPE_DEBUG, "adding path [%u] to peer %s\n",
-              path->length, peer2s (peer_info));
+              path->length, GMP_2s (peer_info));
 
   l = path_get_length (path);
   if (0 == l)
@@ -1647,18 +1546,18 @@ GMP_add_path_to_origin (struct MeshPeer *peer,
  * @param confirmed Whether we know if the path works or not.
  */
 void
-GMP_add_path_to_all (struct MeshPeerPath *p, int confirmed)
+GMP_add_path_to_all (const struct MeshPeerPath *p, int confirmed)
 {
   unsigned int i;
 
   /* TODO: invert and add */
-  for (i = 0; i < p->length && p->peers[i] != my_short_id; i++) /* skip'em */ ;
+  for (i = 0; i < p->length && p->peers[i] != myid; i++) /* skip'em */ ;
   for (i++; i < p->length; i++)
   {
     struct MeshPeer *aux;
     struct MeshPeerPath *copy;
 
-    aux = peer_get_short (p->peers[i]);
+    aux = GMP_get_short (p->peers[i]);
     copy = path_duplicate (p);
     copy->length = i + 1;
     GMP_add_path (aux, copy, p->length < 3 ? GNUNET_NO : confirmed);
@@ -1688,6 +1587,45 @@ GMP_remove_connection (struct MeshPeer *peer,
                                                c);
 }
 
+/**
+ * Start the DHT search for new paths towards the peer: we don't have
+ * enough good connections.
+ *
+ * @param peer Destination peer.
+ */
+void
+GMP_start_search (struct MeshPeer *peer)
+{
+  if (NULL != peer->search_h)
+  {
+    GNUNET_break (0);
+    return;
+  }
+
+  peer->search_h = GMD_search (GMP_get_id (peer), &search_handler, peer);
+}
+
+
+/**
+ * Stop the DHT search for new paths towards the peer: we already have
+ * enough good connections.
+ *
+ * @param peer Destination peer.
+ */
+void
+GMP_stop_search (struct MeshPeer *peer)
+{
+  if (NULL == peer->search_h)
+  {
+    GNUNET_break (0);
+    return;
+  }
+
+  GMD_search_stop (peer->search_h);
+  peer->search_h = NULL;
+}
+
+
 /**
  * Get the Full ID of a peer.
  *
@@ -1695,7 +1633,7 @@ GMP_remove_connection (struct MeshPeer *peer,
  *
  * @return Full ID of peer.
  */
-struct GNUNET_PeerIdentity *
+const struct GNUNET_PeerIdentity *
 GMP_get_id (const struct MeshPeer *peer)
 {
   return GNUNET_PEER_resolve2 (peer->id);
@@ -1716,6 +1654,20 @@ GMP_get_short_id (const struct MeshPeer *peer)
 }
 
 
+/**
+ * Get the tunnel towards a peer.
+ *
+ * @param peer Peer to get from.
+ *
+ * @return Tunnel towards peer.
+ */
+struct MeshTunnel3 *
+GMP_get_tunnel (const struct MeshPeer *peer)
+{
+  return peer->tunnel;
+}
+
+
 /**
  * Get the static string for a peer ID.
  *