Changed path management

- Peers now have a set of individual paths to reach them
- Tunnels have a tree of the paths in the tunnel to reach all peers in the tunnel in an efficent way, allowing to add peers efficiently taking in account existing paths and having each tunnel reach a peer on a different path.
- Adapted helper functions, periodic announcements, etc to new structure
Added initial support for link disconnection notification and readjustment

1 files changed, 792 insertions, 467 deletions

diff --git a/src/mesh/gnunet-service-mesh.c b/src/mesh/gnunet-service-mesh.c
index d903e7584..edbad550a 100644
--- a/src/mesh/gnunet-service-mesh.c
+++ b/src/mesh/gnunet-service-mesh.c
@@ -90,65 +90,134 @@ mesh_debug (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
                                     GNUNET_TIME_UNIT_SECONDS,\
                                     5)
 
-
-
 /******************************************************************************/
-/************************      DATA STRUCTURES     ****************************/
+/************************        ENUMERATIONS      ****************************/
 /******************************************************************************/
 
 /**
- * Information regarding a path
+ * All the states a peer participating in a tunnel can be in.
  */
-struct MeshPath
+enum MeshPeerState
 {
+    /**
+     * Peer only retransmits traffic, is not a final destination
+     */
+  MESH_PEER_RELAY,
 
     /**
-     * Linked list
+     * Path to the peer not known yet
      */
-  struct MeshPath *next;
-  struct MeshPath *prev;
+  MESH_PEER_SEARCHING,
 
     /**
-     * Whether the path is serving traffic in a tunnel or is a backup
+     * Request sent, not yet answered.
      */
-  int in_use;
+  MESH_PEER_WAITING,
 
     /**
-     * List of all the peers that form the path from origin to target
+     * Peer connected and ready to accept data
      */
-  GNUNET_PEER_Id *peers;
+  MESH_PEER_READY,
 
     /**
-     * Number of peers (hops) in the path
+     * Peer connected previosly but not responding
      */
-  unsigned int length;
+  MESH_PEER_RECONNECTING
 };
 
 
+/******************************************************************************/
+/************************      DATA STRUCTURES     ****************************/
+/******************************************************************************/
+
 /**
- * All the states a peer participating in a tunnel can be in.
+ * Information regarding a possible path to reach a single peer
  */
-enum MeshPeerState
+struct MeshPeerPath
 {
+
     /**
-     * Path to the peer not known yet
+     * Linked list
      */
-  MESH_PEER_SEARCHING,
+  struct MeshPeerPath *next;
+  struct MeshPeerPath *prev;
 
     /**
-     * Request sent, not yet answered.
+     * List of all the peers that form the path from origin to target.
      */
-  MESH_PEER_WAITING,
+  GNUNET_PEER_Id *peers;
 
     /**
-     * Peer connected and ready to accept data
+     * Number of peers (hops) in the path
      */
-  MESH_PEER_READY,
+  unsigned int length;
+
+};
+
+
+/**
+ * Node of path tree for a tunnel
+ */
+struct MeshTunnelPathNode
+{
+  /**
+   * Tunnel this node belongs to (and therefore tree)
+   */
+  struct MeshTunnel *t;
+
+  /**
+   * Peer this node describes
+   */
+  struct MeshPeerInfo *peer;
+
+  /**
+   * Parent node in the tree
+   */
+  struct MeshTunnelPathNode *parent;
+
+  /**
+   * Array of children
+   */
+  struct MeshTunnelPathNode *children;
+
+  /**
+   * Number of children
+   */
+  unsigned int nchildren;
 
     /**
-     * Peer connected previosly but not responding
+     * Status of the peer in the tunnel
      */
-  MESH_PEER_RECONNECTING
+  enum MeshPeerState status;
+};
+
+
+/**
+ * Tree to reach all peers in the tunnel
+ */
+struct MeshTunnelPath
+{
+  /**
+   * Tunnel this path belongs to
+   */
+  struct MeshTunnel *t;
+
+  /**
+   * Root node of peer tree
+   */
+  struct MeshTunnelPathNode *root;
+
+  /**
+   * Node that represents our position in the tree (for non local tunnels)
+   */
+  struct MeshTunnelPathNode *me;
+
+  /**
+   * Cache of all peers and the first hop to them.
+   * Indexed by Peer_Identity, contains a pointer to the PeerInfo of 1st hop.
+   */
+  struct GNUNET_CONTAINER_MultiHashMap *first_hops;
+
 };
 
 
@@ -197,11 +266,6 @@ struct MeshPeerInfo
   GNUNET_PEER_Id id;
 
     /**
-     * Is the peer reachable? Is the peer even connected?
-     */
-  enum MeshPeerState state;
-
-    /**
      * Last time we heard from this peer
      */
   struct GNUNET_TIME_Absolute last_contact;
@@ -212,10 +276,14 @@ struct MeshPeerInfo
   int n_reconnect_attempts;
 
     /**
-     * Paths to reach the peer
+     * Paths to reach the peer, ordered by ascending hop count
      */
-  struct MeshPath *path;
-  struct MeshPath *path_tail;
+  struct MeshPeerPath *path_head;
+
+    /**
+     * Paths to reach the peer, ordered by ascending hop count
+     */
+  struct MeshPeerPath *path_tail;
 
     /**
      * Handle to stop the DHT search for a path to this peer
@@ -233,9 +301,17 @@ struct MeshPeerInfo
   struct MeshDataDescriptor *infos[CORE_QUEUE_SIZE];
 
     /**
-     * Task to send keepalive packets over the current active path
+     * Array of tunnels this peer participates in
+     * (most probably a small amount, therefore not a hashmap)
+     * When the path to the peer changes, notify these tunnels to let them
+     * re-adjust their path trees.
      */
-  GNUNET_SCHEDULER_TaskIdentifier path_refresh_task;
+  struct MeshTunnel **tunnels;
+
+    /**
+     * Number of tunnels above
+     */
+  unsigned int ntunnels;
 };
 
 
@@ -336,7 +412,6 @@ struct MeshTunnel
      */
   unsigned int peers_total;
 
-
     /**
      * Client owner of the tunnel, if any
      */
@@ -348,8 +423,40 @@ struct MeshTunnel
   struct MeshQueue *queue_head;
   struct MeshQueue *queue_tail;
 
+  /**
+   * Tunnel paths
+   */
+  struct MeshTunnelPath *paths;
+
+  /**
+   * Task to keep the used paths alive
+   */
+  GNUNET_SCHEDULER_TaskIdentifier path_refresh_task;
+};
+
+
+/**
+ * Info needed to work with tunnel paths and peers
+ */
+struct MeshPathInfo
+{
+  /**
+   * Tunnel
+   */
+  struct MeshTunnel *t;
+
+  /**
+   * Destination peer
+   */
+  struct MeshPeerInfo *peer;
+
+  /**
+   * Path itself
+   */
+  struct MeshPeerPath *path;
 };
 
+
 /**
  * Struct containing information about a client of the service
  */
@@ -382,7 +489,7 @@ struct MeshClient
   struct GNUNET_CONTAINER_MultiHashMap *types;
 
     /**
-     * Used for seachching peers offering a service
+     * Used to search peers offering a service
      */
   struct GNUNET_DHT_GetHandle *dht_get_type;
 
@@ -465,17 +572,151 @@ GNUNET_SCHEDULER_TaskIdentifier announce_id_task;
 
 
 /******************************************************************************/
+/************************    PERIODIC FUNCTIONS    ****************************/
+/******************************************************************************/
+
+/**
+ * Announce iterator over for each application provided by the peer
+ *
+ * @param cls closure
+ * @param key current key code
+ * @param value value in the hash map
+ * @return GNUNET_YES if we should continue to
+ *         iterate,
+ *         GNUNET_NO if not.
+ */
+static int
+announce_application (void *cls, const GNUNET_HashCode * key, void *value)
+{
+  /* FIXME are hashes in multihash map equal on all aquitectures? */
+  GNUNET_DHT_put (dht_handle, key, 10U, GNUNET_DHT_RO_RECORD_ROUTE,
+                  GNUNET_BLOCK_TYPE_TEST, sizeof (struct GNUNET_PeerIdentity),
+                  (const char *) &my_full_id,
+#if MESH_DEBUG
+                  GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL,
+                  &mesh_debug, "DHT_put for app completed");
+#else
+                  GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
+                                            APP_ANNOUNCE_TIME),
+                  APP_ANNOUNCE_TIME,
+                  NULL, NULL);
+#endif
+  return GNUNET_OK;
+}
+
+
+/**
+ * Periodically announce what applications are provided by local clients
+ *
+ * @param cls closure
+ * @param tc task context
+ */
+static void
+announce_applications (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+  {
+    announce_applications_task = GNUNET_SCHEDULER_NO_TASK;
+    return;
+  }
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Starting PUT for apps\n");
+  GNUNET_CONTAINER_multihashmap_iterate (applications, &announce_application,
+                                         NULL);
+  announce_applications_task =
+      GNUNET_SCHEDULER_add_delayed (APP_ANNOUNCE_TIME, &announce_applications,
+                                    cls);
+  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Finished PUT for apps\n");
+  return;
+}
+
+
+/**
+ * Periodically announce self id in the DHT
+ *
+ * @param cls closure
+ * @param tc task context
+ */
+static void
+announce_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+  {
+    announce_id_task = GNUNET_SCHEDULER_NO_TASK;
+    return;
+  }
+  /* TODO
+   * - Set data expiration in function of X
+   * - Adapt X to churn
+   */
+  GNUNET_DHT_put (dht_handle,   /* DHT handle */
+                  &my_full_id.hashPubKey,       /* Key to use */
+                  10U,          /* Replication level */
+                  GNUNET_DHT_RO_RECORD_ROUTE,   /* DHT options */
+                  GNUNET_BLOCK_TYPE_TEST,       /* Block type */
+                  0,            /* Size of the data */
+                  NULL,         /* Data itself */
+                  GNUNET_TIME_absolute_get_forever (),  /* Data expiration */
+                  GNUNET_TIME_UNIT_FOREVER_REL, /* Retry time */
+#if MESH_DEBUG
+                  &mesh_debug, "DHT_put for id completed");
+#else
+                  NULL,         /* Continuation */
+                  NULL);        /* Continuation closure */
+#endif
+  announce_id_task =
+      GNUNET_SCHEDULER_add_delayed (ID_ANNOUNCE_TIME, &announce_id, cls);
+}
+
+
+/**
+ * Send keepalive packets for a peer
+ *
+ * @param cls unused
+ * @param tc unused
+ *
+ * FIXME path
+ */
+static void
+path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  struct MeshTunnel *t = cls;
+//   struct GNUNET_PeerIdentity id;
+
+  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
+  {
+    return;
+  }
+  /* FIXME implement multicast keepalive. Just an empty multicast packet? */
+//   GNUNET_PEER_resolve (path_get_first_hop (path->t, path->peer)->id, &id);
+//   GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
+//                                      GNUNET_TIME_UNIT_FOREVER_REL, &id,
+//                                      sizeof (struct GNUNET_MESH_ManipulatePath)
+//                                      +
+//                                      (path->path->length *
+//                                       sizeof (struct GNUNET_PeerIdentity)),
+//                                      &send_core_create_path,
+//                                      t);
+  t->path_refresh_task =
+      GNUNET_SCHEDULER_add_delayed (REFRESH_PATH_TIME, &path_refresh,
+                                    t);
+  return;
+}
+
+
+/******************************************************************************/
 /******************      GENERAL HELPER FUNCTIONS      ************************/
 /******************************************************************************/
 
 /**
  * Retrieve the MeshPeerInfo stucture associated with the peer, create one
  * and insert it in the appropiate structures if the peer is not known yet.
+ * 
  * @param peer Identity of the peer
+ * 
  * @return Existing or newly created peer info
  */
 static struct MeshPeerInfo *
-get_peer_info (const struct GNUNET_PeerIdentity *peer)
+peer_info_get (const struct GNUNET_PeerIdentity *peer)
 {
   struct MeshPeerInfo *peer_info;
 
@@ -487,62 +728,84 @@ get_peer_info (const struct GNUNET_PeerIdentity *peer)
     GNUNET_CONTAINER_multihashmap_put (peers, &peer->hashPubKey, peer_info,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
     peer_info->id = GNUNET_PEER_intern (peer);
-    peer_info->state = MESH_PEER_SEARCHING;
   }
 
   return peer_info;
 }
 
+
+#if LATER
 /**
- * Find the first peer whom to send a packet to go down this path
- * @param path The path to use
- * @return short id of the next peer, myid in case of local delivery,
- * or 0 in case of error
+ * Destroy the peer_info and free any allocated resources linked to it
+ * @param t tunnel the path belongs to
+ * @param pi the peer_info to destroy
+ * @return GNUNET_OK on success
  */
-static GNUNET_PEER_Id
-get_first_hop (struct MeshPath *path)
+static int
+peer_info_destroy (struct MeshPeerInfo *pi)
 {
-  unsigned int i;
+  GNUNET_HashCode hash;
+  struct GNUNET_PeerIdentity id;
 
-  while (NULL != path)
-  {
-    if (path->in_use)
-      break;
-    path = path->next;
-  }
-  if (NULL == path)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "tried to get the next hop from an invalid path\n");
-    return 0;
-  }
+  GNUNET_PEER_resolve (pi->id, &id);
+  GNUNET_PEER_change_rc (pi->id, -1);
+  GNUNET_CRYPTO_hash (&id, sizeof (struct GNUNET_PeerIdentity), &hash);
 
-  for (i = 0; i < path->length; i++)
-  {
-    if (path->peers[i] == myid)
-    {
-      if (i < path->length - 1)
-      {
-        return path->peers[i + 1];
-      }
-      else
-      {
-        return myid;
-      }
-    }
-  }
-  return 0;
+  GNUNET_CONTAINER_multihashmap_remove (peers, &hash, pi);
+  GNUNET_SCHEDULER_cancel (pi->path_refresh_task);
+  GNUNET_free (pi);
+  return GNUNET_OK;
 }
+#endif
 
 
 /**
- * Get the cost of the path.
- * @param path The path to analyze
- * @return Number of hops to reach destination, UINT_MAX in case the peer is not
- * in the path
+ * Destroy the path and free any allocated resources linked to it
+ *
+ * @param p the path to destroy
+ *
+ * @return GNUNET_OK on success
+ */
+static int
+path_destroy (struct MeshPeerPath *p)
+{
+  GNUNET_PEER_decrement_rcs (p->peers, p->length);
+  GNUNET_free (p->peers);
+  GNUNET_free (p);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Find the first peer whom to send a packet to go down this path
+ * 
+ * @param t The tunnel to use
+ * @param peer The peerinfo of the peer we are trying to reach
+ * 
+ * @return peerinfo of the peer who is the first hop in the tunnel
+ *         NULL on error
+ */
+static struct MeshPeerInfo *
+path_get_first_hop (struct MeshTunnel *t, struct MeshPeerInfo *peer)
+{
+  struct GNUNET_PeerIdentity id;
+
+  GNUNET_PEER_resolve(peer->id, &id);
+  return GNUNET_CONTAINER_multihashmap_get(t->paths->first_hops,
+                                            &id.hashPubKey);
+}
+
+
+/**
+ * Get the length of a path
+ * 
+ * @param path The path to measure, with the local peer at any point of it
+ * 
+ * @return Number of hops to reach destination
+ *         UINT_MAX in case the peer is not in the path
  */
 static unsigned int
-get_path_cost (struct MeshPath *path)
+path_get_length (struct MeshPeerPath *path)
 {
   unsigned int i;
 
@@ -560,61 +823,136 @@ get_path_cost (struct MeshPath *path)
 
 
 /**
+ * Get the cost of the path relative to the already built tunnel tree
+ *
+ * @param t The tunnel to which compare
+ * @param path The individual path to reach a peer
+ *
+ * @return Number of hops to reach destination, UINT_MAX in case the peer is not
+ * in the path
+ *
+ * TODO: remove dummy implementation, look into the tunnel tree
+ */
+static unsigned int
+path_get_cost (struct MeshTunnel *t, struct MeshPeerPath *path)
+{
+  return path_get_length(path);
+}
+
+
+/**
  * Add the path to the peer and update the path used to reach it in case this
  * is the shortest.
+ * 
  * @param peer_info Destination peer to add the path to.
  * @param path New path to add. Last peer must be the peer in arg 1.
+ *
+ * TODO: trim the part from origin to us? Add it as path to origin?
  */
 static void
-add_path_to_peer (struct MeshPeerInfo *peer_info, struct MeshPath *path)
+path_add_to_peer (struct MeshPeerInfo *peer_info, struct MeshPeerPath *path)
 {
-  unsigned int i;
-  unsigned int new_cost;
-  unsigned int best_cost;
-  struct MeshPath *aux;
-  struct MeshPath *best;
+  unsigned int l;
+  struct MeshPeerPath *aux;
 
   if (NULL == peer_info || NULL == path)
+  {
+    GNUNET_break (0);
     return;
+  }
 
-  new_cost = get_path_cost (path);
-  best_cost = UINT_MAX;
-  best = NULL;
-  for (aux = peer_info->path; aux != NULL; aux = aux->next)
+  l = path_get_length (path);
+
+  for (aux = peer_info->path_head; aux != NULL; aux = aux->next)
   {
-    if ((i = get_path_cost (aux)) < best_cost)
+    if (path_get_length (aux) > l)
     {
-      best = aux;
-      best_cost = i;
+      GNUNET_CONTAINER_DLL_insert_before (peer_info->path_head,
+                                          peer_info->path_tail,
+                                          aux,
+                                          path);
     }
   }
-  if (best_cost < new_cost)
+  GNUNET_CONTAINER_DLL_insert_tail (peer_info->path_head,
+                                    peer_info->path_tail,
+                                    path);
+  return;
+}
+
+
+/**
+ * Notify a tunnel that a connection has broken that affects at least
+ * some of its peers.
+ *
+ * @param t Tunnel affected
+ * @param peer Peer that (at least) has been affected by the disconnection
+ * @param p1 Peer that got disconnected from p2
+ * @param p2 Peer that got disconnected from p1
+ */
+static void
+tunnel_notify_connection_broken(struct MeshTunnel *t,
+                                struct MeshPeerInfo *peer,
+                                GNUNET_PEER_Id p1,
+                                GNUNET_PEER_Id p2);
+
+
+/**
+ * Remove all paths that rely on a direct connection between p1 and p2
+ * from the peer itself and notify all tunnels about it.
+ *
+ * @param pi PeerInfo of affected peer
+ * @param p1 GNUNET_PEER_Id of one peer.
+ * @param p2 GNUNET_PEER_Id of another peer that was connected to the first and
+ *           no longer is.
+ */
+static void
+path_remove_from_peer (struct MeshPeerInfo *peer,
+                       GNUNET_PEER_Id p1,
+                       GNUNET_PEER_Id p2)
+{
+  struct MeshPeerPath *p;
+  struct MeshPeerPath *aux;
+  unsigned int destroyed;
+  unsigned int i;
+
+  destroyed = 0;
+  p = peer->path_head;
+  while (NULL != p)
   {
-    path->in_use = 0;
-    GNUNET_CONTAINER_DLL_insert_tail (peer_info->path, peer_info->path_tail,
-                                      path);
+    aux = p->next;
+    for (i = 0; i < (p->length - 1); i++)
+    {
+      if ((p->peers[i] == p1 && p->peers[i + 1] == p2) ||
+          (p->peers[i] == p2 && p->peers[i + 1] == p1))
+      {
+        path_destroy(p);
+        destroyed++;
+        break;
+      }
+    }
+    p = aux;
   }
-  else
+  if (0 == destroyed)
+    return;
+
+  for (i = 0; i < peer->ntunnels; i++)
   {
-    if (NULL != best)
-      best->in_use = 0;
-    path->in_use = 1;
-    GNUNET_CONTAINER_DLL_insert (peer_info->path, peer_info->path_tail, path);
+    tunnel_notify_connection_broken(peer->tunnels[i], peer, p1, p2);
   }
-  return;
 }
 
 
 /**
- * Add the path to the peer and update the path used to reach it in case this
- * is the shortest. The path is given in reverse, the destination peer is
- * path[0]. The function modifies the path, inverting it to use the origin as
- * destination.
- * @param peer_info Destination peer to add the path to.
- * @param path New path to add. First peer must be the peer in arg 1.
+ * Add the path to the origin peer and update the path used to reach it in case
+ * this is the shortest.
+ * The path is given in peer_info -> destination, therefore we turn the path
+ * upside down first.
+ * 
+ * @param peer_info Peer to add the path to, being the origin of the path.
+ * @param path New path to add after being inversed. 
  */
 static void
-add_path_to_origin (struct MeshPeerInfo *peer_info, struct MeshPath *path)
+path_add_to_origin (struct MeshPeerInfo *peer_info, struct MeshPeerPath *path)
 {
   GNUNET_PEER_Id aux;
   unsigned int i;
@@ -625,17 +963,138 @@ add_path_to_origin (struct MeshPeerInfo *peer_info, struct MeshPath *path)
     path->peers[i] = path->peers[path->length - i - 1];
     path->peers[path->length - i - 1] = aux;
   }
-  add_path_to_peer (peer_info, path);
+  path_add_to_peer (peer_info, path);
+}
+
+/**
+ * Integrate a stand alone path into the tunnel tree.
+ *
+ * @param t Tunnel where to add the new path.
+ * @param p Path to be integrated.
+ *
+ * @return GNUNET_OK in case of success.
+ *         GNUNET_SYSERR in case of error.
+ *
+ * FIXME path: remove old path to the same peer if needed
+ */
+static int
+path_add_to_tunnel(struct MeshTunnel *t, struct MeshPeerPath *p)
+{
+  struct MeshTunnelPathNode *parent;
+  struct MeshTunnelPathNode *n;
+  struct GNUNET_PeerIdentity id;
+  struct GNUNET_PeerIdentity hop;
+  int me;
+  unsigned int i;
+  unsigned int j;
+
+  n = t->paths->root;
+  if (n->peer->id != p->peers[0])
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  /* Assuming that the tree is somewhat balanced, O((log n * log N).
+   * - Length of the path is expected to be log N (size of whole network).
+   * - Each level of the tree is expected to have log n children (size of tree).
+   */
+  for (i = 1, me = -1; i < p->length; i++)
+  {
+    parent = n;
+    if (p->peers[i] == myid)
+      me = i;
+    for (j = 0; j < n->nchildren; j++)
+    {
+      if (n->children[j].peer->id == p->peers[i])
+      {
+        n = &n->children[j];
+        break;
+      }
+    }
+    /*  If we couldn't find a child equal to path[i], we have reached the end
+     * of the common path. */
+    if (parent == n)
+      break;
+  }
+  if (-1 == me)
+  {
+    GNUNET_break (0);
+    return GNUNET_SYSERR;
+  }
+  /* Add the rest of the path as a branch from parent. */
+  while (i < p->length)
+  {
+    parent->children = GNUNET_realloc(parent->children, parent->nchildren);
+    parent->nchildren++;
+    GNUNET_PEER_resolve(p->peers[i], &id);
+    n->peer = peer_info_get(&id);
+    n->parent = parent;
+    n->t = t;
+    i++;
+  }
+  /* Add info about first hop into hashmap. */
+  if (me < p->length - 1)
+  {
+    GNUNET_PEER_resolve(p->peers[p->length - 1], &id);
+    GNUNET_PEER_resolve(p->peers[me + 1], &hop);
+    GNUNET_CONTAINER_multihashmap_put(
+      t->paths->first_hops,
+      &id.hashPubKey,
+      peer_info_get(&hop),
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_FAST);
+  }
+  return GNUNET_OK;
+}
+
+
+/**
+ * Build a PeerPath from the paths returned from the DHT, reversing the paths
+ * to obtain a local peer -> destination path and interning the peer ids.
+ *
+ * @param get_path NULL-terminated array of pointers
+ *                 to the peers on reverse GET path (or NULL if not recorded)
+ * @param put_path NULL-terminated array of pointers
+ *                 to the peers on the PUT path (or NULL if not recorded)
+ *
+ * @return Newly allocated and created path
+ */
+static struct MeshPeerPath *
+path_build_from_dht(const struct GNUNET_PeerIdentity *const *get_path,
+                    const struct GNUNET_PeerIdentity *const *put_path)
+{
+  struct MeshPeerPath *p;
+  int i;
+
+  p = GNUNET_malloc (sizeof (struct MeshPeerPath));
+  for (i = 0; get_path[i] != NULL; i++) ;
+  for (i--; i >= 0; i--)
+  {
+    p->peers =
+        GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * (p->length + 1));
+    p->peers[p->length] = GNUNET_PEER_intern (get_path[i]);
+    p->length++;
+  }
+  for (i = 0; put_path[i] != NULL; i++) ;
+  for (i--; i >= 0; i--)
+  {
+    p->peers =
+        GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * (p->length + 1));
+    p->peers[p->length] = GNUNET_PEER_intern (put_path[i]);
+    p->length++;
+  }
+  return p;
 }
 
 
 /**
  * Check if client has registered with the service and has not disconnected
+ * 
  * @param client the client to check
+ * 
  * @return non-NULL if client exists in the global DLL
  */
 static struct MeshClient *
-retrieve_client (struct GNUNET_SERVER_Client *client)
+client_get (struct GNUNET_SERVER_Client *client)
 {
   struct MeshClient *c;
 
@@ -652,12 +1111,16 @@ retrieve_client (struct GNUNET_SERVER_Client *client)
 
 /**
  * Checks if a given client has subscribed to certain message type
+ * 
  * @param message_type Type of message to check
  * @param c Client to check
+ * 
  * @return GNUNET_YES or GNUNET_NO, depending on subscription status
+ *
+ * TODO inline?
  */
-static int                      /* FIXME inline? */
-is_client_subscribed (uint16_t message_type, struct MeshClient *c)
+static int
+client_is_subscribed (uint16_t message_type, struct MeshClient *c)
 {
   GNUNET_HashCode hc;
 
@@ -668,12 +1131,14 @@ is_client_subscribed (uint16_t message_type, struct MeshClient *c)
 
 /**
  * Search for a tunnel among the tunnels for a client
+ * 
  * @param c the client whose tunnels to search in
  * @param tid the local id of the tunnel
+ * 
  * @return tunnel handler, NULL if doesn't exist
  */
 static struct MeshTunnel *
-retrieve_tunnel_by_local_id (struct MeshClient *c, MESH_TunnelNumber tid)
+tunnel_get_by_local_id (struct MeshClient *c, MESH_TunnelNumber tid)
 {
   GNUNET_HashCode hash;
 
@@ -681,14 +1146,17 @@ retrieve_tunnel_by_local_id (struct MeshClient *c, MESH_TunnelNumber tid)
   return GNUNET_CONTAINER_multihashmap_get (c->tunnels, &hash);
 }
 
+
 /**
  * Search for a tunnel by global ID using PEER_ID
+ * 
  * @param pi owner of the tunnel
  * @param tid global tunnel number
+ * 
  * @return tunnel handler, NULL if doesn't exist
  */
 static struct MeshTunnel *
-retrieve_tunnel_by_pi (GNUNET_PEER_Id pi, MESH_TunnelNumber tid)
+tunnel_get_by_pi (GNUNET_PEER_Id pi, MESH_TunnelNumber tid)
 {
   struct MESH_TunnelID id;
   GNUNET_HashCode hash;
@@ -704,63 +1172,84 @@ retrieve_tunnel_by_pi (GNUNET_PEER_Id pi, MESH_TunnelNumber tid)
 
 /**
  * Search for a tunnel by global ID using full PeerIdentities
+ * 
  * @param oid owner of the tunnel
  * @param tid global tunnel number
+ * 
  * @return tunnel handler, NULL if doesn't exist
  */
 static struct MeshTunnel *
-retrieve_tunnel (struct GNUNET_PeerIdentity *oid, MESH_TunnelNumber tid)
+tunnel_get (struct GNUNET_PeerIdentity *oid, MESH_TunnelNumber tid)
 {
-  return retrieve_tunnel_by_pi (GNUNET_PEER_search (oid), tid);
+  return tunnel_get_by_pi (GNUNET_PEER_search (oid), tid);
 }
 
 
 /**
- * Destroy the path and free any allocated resources linked to it
- * @param p the path to destroy
- * @return GNUNET_OK on success
+ * Add a peer to a tunnel, accomodating paths accordingly and initializing all
+ * needed rescources.
+ *
+ * @param t Tunnel we want to add a new peer to
+ * @param peer PeerInfo of the peer being added
+ *
  */
-static int
-destroy_path (struct MeshPath *p)
+static void
+tunnel_add_peer(struct MeshTunnel *t, struct MeshPeerInfo *peer)
 {
-  GNUNET_PEER_decrement_rcs (p->peers, p->length);
-  GNUNET_free (p->peers);
-  GNUNET_free (p);
-  return GNUNET_OK;
+  struct MeshPeerPath *p;
+  struct MeshPeerPath *best_p;
+  unsigned int best_cost;
+  unsigned int cost;
+
+  GNUNET_array_append(peer->tunnels, peer->ntunnels, t);
+  if (NULL == (p = peer->path_head))
+    return;
+
+  best_p = p;
+  best_cost = UINT_MAX;
+  while (NULL != p)
+  {
+    if ((cost = path_get_cost(t, p)) < best_cost)
+    {
+      best_cost = cost;
+      best_p = p;
+    }
+    p = p->next;
+  }
+  path_add_to_tunnel(t, best_p);
+  if (GNUNET_SCHEDULER_NO_TASK == t->path_refresh_task)
+    t->path_refresh_task = GNUNET_SCHEDULER_add_delayed (REFRESH_PATH_TIME,
+                                                         &path_refresh, t);
 }
 
-#if LATER
+
 /**
- * Destroy the peer_info and free any allocated resources linked to it
- * @param t tunnel the path belongs to
- * @param pi the peer_info to destroy
- * @return GNUNET_OK on success
+ * Notify a tunnel that a connection has broken that affects at least
+ * some of its peers.
+ *
+ * @param t Tunnel affected
+ * @param peer Peer that (at least) has been affected by the disconnection
+ * @param p1 Peer that got disconnected from p2
+ * @param p2 Peer that got disconnected from p1
  */
-static int
-destroy_peer_info (struct MeshPeerInfo *pi)
+static void
+tunnel_notify_connection_broken(struct MeshTunnel *t,
+                                struct MeshPeerInfo *peer,
+                                GNUNET_PEER_Id p1,
+                                GNUNET_PEER_Id p2)
 {
-  GNUNET_HashCode hash;
-  struct GNUNET_PeerIdentity id;
-
-  GNUNET_PEER_resolve (pi->id, &id);
-  GNUNET_PEER_change_rc (pi->id, -1);
-  GNUNET_CRYPTO_hash (&id, sizeof (struct GNUNET_PeerIdentity), &hash);
-
-  GNUNET_CONTAINER_multihashmap_remove (peers, &hash, pi);
-  GNUNET_SCHEDULER_cancel (pi->path_refresh_task);
-  GNUNET_free (pi);
-  return GNUNET_OK;
 }
-#endif
 
 
 /**
  * Destroy the tunnel and free any allocated resources linked to it
+ * 
  * @param t the tunnel to destroy
+ * 
  * @return GNUNET_OK on success
  */
 static int
-destroy_tunnel (struct MeshTunnel *t)
+tunnel_destroy (struct MeshTunnel *t)
 {
   struct MeshClient *c;
   struct MeshQueue *q;
@@ -799,106 +1288,12 @@ destroy_tunnel (struct MeshTunnel *t)
   return r;
 }
 
-/******************************************************************************/
-/************************    PERIODIC FUNCTIONS    ****************************/
-/******************************************************************************/
-
-/**
- * Announce iterator over for each application provided by the peer
- *
- * @param cls closure
- * @param key current key code
- * @param value value in the hash map
- * @return GNUNET_YES if we should continue to
- *         iterate,
- *         GNUNET_NO if not.
- */
-static int
-announce_application (void *cls, const GNUNET_HashCode * key, void *value)
-{
-  /* FIXME are hashes in multihash map equal on all aquitectures? */
-  GNUNET_DHT_put (dht_handle, key, 10U, GNUNET_DHT_RO_RECORD_ROUTE,
-                  GNUNET_BLOCK_TYPE_TEST, sizeof (struct GNUNET_PeerIdentity),
-                  (const char *) &my_full_id,
-//                   GNUNET_TIME_absolute_add (GNUNET_TIME_absolute_get (),
-//                                             APP_ANNOUNCE_TIME), FIXME
-//                   APP_ANNOUNCE_TIME,
-                  GNUNET_TIME_UNIT_FOREVER_ABS, GNUNET_TIME_UNIT_FOREVER_REL,
-#if MESH_DEBUG
-                  &mesh_debug, "DHT_put for app completed");
-#else
-                  NULL, NULL);
-#endif
-  return GNUNET_OK;
-}
-
-
-/**
- * Periodically announce what applications are provided by local clients
- *
- * @param cls closure
- * @param tc task context
- */
-static void
-announce_applications (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
-  {
-    announce_applications_task = GNUNET_SCHEDULER_NO_TASK;
-    return;
-  }
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Starting PUT for apps\n");
-  GNUNET_CONTAINER_multihashmap_iterate (applications, &announce_application,
-                                         NULL);
-  announce_applications_task =
-      GNUNET_SCHEDULER_add_delayed (APP_ANNOUNCE_TIME, &announce_applications,
-                                    cls);
-  GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Finished PUT for apps\n");
-  return;
-}
-
-
-/**
- * Periodically announce self id in the DHT
- *
- * @param cls closure
- * @param tc task context
- */
-static void
-announce_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
-  {
-    announce_id_task = GNUNET_SCHEDULER_NO_TASK;
-    return;
-  }
-  /* TODO
-   * - Set data expiration in function of X
-   * - Adapt X to churn
-   */
-  GNUNET_DHT_put (dht_handle,   /* DHT handle */
-                  &my_full_id.hashPubKey,       /* Key to use */
-                  10U,          /* Replication level */
-                  GNUNET_DHT_RO_RECORD_ROUTE,   /* DHT options */
-                  GNUNET_BLOCK_TYPE_TEST,       /* Block type */
-                  0,            /* Size of the data */
-                  NULL,         /* Data itself */
-                  GNUNET_TIME_absolute_get_forever (),  /* Data expiration */
-                  GNUNET_TIME_UNIT_FOREVER_REL, /* Retry time */
-#if MESH_DEBUG
-                  &mesh_debug, "DHT_put for id completed");
-#else
-                  NULL,         /* Continuation */
-                  NULL);        /* Continuation closure */
-#endif
-  announce_id_task =
-      GNUNET_SCHEDULER_add_delayed (ID_ANNOUNCE_TIME, &announce_id, cls);
-}
 
 /******************************************************************************/
 /****************      MESH NETWORK HANDLER HELPERS     ***********************/
 /******************************************************************************/
 
+
 /**
  * Function called to notify a client about the socket
  * being ready to queue more data.  "buf" will be
@@ -911,64 +1306,37 @@ announce_id (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @return number of bytes written to buf
  */
 static size_t
-send_core_create_path_for_peer (void *cls, size_t size, void *buf)
+send_core_create_path (void *cls, size_t size, void *buf)
 {
-  struct MeshPeerInfo *peer_info = cls;
+  struct MeshPathInfo *info = cls;
   struct GNUNET_MESH_ManipulatePath *msg;
-  struct MeshPath *p;
   struct GNUNET_PeerIdentity *peer_ptr;
   struct GNUNET_PeerIdentity id;
+  struct MeshPeerInfo *peer = info->peer;
+  struct MeshTunnel *t = info->t;
+  struct MeshPeerPath *p = info->path;
   size_t size_needed;
   int i;
 
-  if (0 == size && NULL == buf)
-  {
-    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Retransmitting create path\n");
-    GNUNET_PEER_resolve (get_first_hop (peer_info->path), &id);
-    GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
-                                       GNUNET_TIME_UNIT_FOREVER_REL, &id,
-                                       sizeof (struct
-                                               GNUNET_MESH_ManipulatePath) +
-                                       (peer_info->path->length *
-                                        sizeof (struct GNUNET_PeerIdentity)),
-                                       &send_core_create_path_for_peer,
-                                       peer_info);
-    return 0;
-  }
-  p = peer_info->path;
-  while (NULL != p)
-  {
-    if (p->in_use)
-    {
-      break;
-    }
-    p = p->next;
-  }
-  if (p == NULL)
-    return 0;                   // TODO Notify ERROR Path not found
-
   size_needed =
       sizeof (struct GNUNET_MESH_ManipulatePath) +
       p->length * sizeof (struct GNUNET_PeerIdentity);
-  if (size < size_needed)
+
+  if (size < size_needed || NULL == buf)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Retransmitting create path\n");
-    GNUNET_PEER_resolve (get_first_hop (peer_info->path), &id);
+    GNUNET_PEER_resolve (path_get_first_hop (t, peer)->id, &id);
     GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
                                        GNUNET_TIME_UNIT_FOREVER_REL, &id,
-                                       sizeof (struct
-                                               GNUNET_MESH_ManipulatePath) +
-                                       (peer_info->path->length *
-                                        sizeof (struct GNUNET_PeerIdentity)),
-                                       &send_core_create_path_for_peer,
-                                       peer_info);
+                                       size_needed, &send_core_create_path,
+                                       info);
     return 0;
   }
 
   msg = (struct GNUNET_MESH_ManipulatePath *) buf;
   msg->header.size = htons (size_needed);
   msg->header.type = htons (GNUNET_MESSAGE_TYPE_MESH_PATH_CREATE);
-  msg->tid = 0; /* FIXME */
+  msg->tid = ntohl(t->id.tid);
 
   peer_ptr = (struct GNUNET_PeerIdentity *) &msg[1];
   for (i = 0; i < p->length; i++)
@@ -976,7 +1344,8 @@ send_core_create_path_for_peer (void *cls, size_t size, void *buf)
     GNUNET_PEER_resolve (p->peers[i], peer_ptr++);
   }
 
-  peer_info->state = MESH_PEER_WAITING;
+  path_destroy(p);
+  GNUNET_free (info);
 
   return size_needed;
 }
@@ -1215,7 +1584,7 @@ send_p2p_tunnel_destroy (void *cls, size_t size, void *buf)
       htons (sizeof (struct GNUNET_MESH_TunnelMessage));
   msg->tunnel_id = htonl (t->id.tid);
 
-  destroy_tunnel (c, t);
+  tunnel_destroy (c, t);
   return sizeof (struct GNUNET_MESH_TunnelMessage);
 }
 #endif
@@ -1237,7 +1606,7 @@ send_subscribed_clients (struct GNUNET_MessageHeader *msg)
   type = ntohs (msg->type);
   for (count = 0, c = clients; c != NULL; c = c->next)
   {
-    if (is_client_subscribed (type, c))
+    if (client_is_subscribed (type, c))
     {
       count++;
       GNUNET_SERVER_notification_context_unicast (nc, c->handle, msg,
@@ -1261,23 +1630,22 @@ static int
 iterate_collect_neighbors (void *cls, const GNUNET_HashCode * key, void *value)
 {
   struct MeshPeerInfo *peer_info = value;
-  GNUNET_PEER_Id **neighbors = cls;
-  GNUNET_PEER_Id id;
+  struct MeshPathInfo *neighbors = cls;
   unsigned int i;
 
   if (peer_info->id == myid)
   {
     return GNUNET_YES;
   }
-  id = get_first_hop (peer_info->path);
-  for (i = 0; *neighbors[i] != 0; i++)
+  peer_info = path_get_first_hop (neighbors->t, peer_info);
+  for (i = 0; i < neighbors->path->length; i++)
   {
-    if (*neighbors[i] == id)
+    if (neighbors->path->peers[i] == peer_info->id)
       return GNUNET_YES;
   }
-  *neighbors = GNUNET_realloc (*neighbors, (i + 2) * sizeof (GNUNET_PEER_Id));
-  *neighbors[i] = id;
-  *neighbors[i + 1] = 0;
+  GNUNET_array_append(neighbors->path->peers,
+                      neighbors->path->length,
+                      peer_info->id);
 
   return GNUNET_YES;
 }
@@ -1313,7 +1681,7 @@ handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
   struct GNUNET_PeerIdentity *pi;
   struct GNUNET_PeerIdentity id;
   GNUNET_HashCode hash;
-  struct MeshPath *path;
+  struct MeshPeerPath *path;
   struct MeshPeerInfo *dest_peer_info;
   struct MeshPeerInfo *orig_peer_info;
   struct MeshTunnel *t;
@@ -1323,30 +1691,27 @@ handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
   size = ntohs (message->size);
   if (size < sizeof (struct GNUNET_MESH_ManipulatePath))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "received create path message too short\n");
+    GNUNET_break_op (0);
     return GNUNET_OK;
   }
 
   size -= sizeof (struct GNUNET_MESH_ManipulatePath);
-  if (size < 2 * sizeof (struct GNUNET_PeerIdentity))
+  if (size % sizeof (struct GNUNET_PeerIdentity))
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "create path message lacks enough peers\n");
+    GNUNET_break_op (0);
     return GNUNET_OK;
   }
-  if (size % sizeof (struct GNUNET_PeerIdentity))
+  size /= sizeof (struct GNUNET_PeerIdentity);
+  if (size < 2)
   {
-    GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
-                "create path message of wrong size\n");
+    GNUNET_break_op (0);
     return GNUNET_OK;
   }
   msg = (struct GNUNET_MESH_ManipulatePath *) message;
-  size /= sizeof (struct GNUNET_PeerIdentity);
 
   tid = ntohl (msg->tid);
   pi = (struct GNUNET_PeerIdentity *) &msg[1];
-  t = retrieve_tunnel (pi, tid);
+  t = tunnel_get (pi, tid);
 
   if (NULL == t)
   {
@@ -1358,8 +1723,9 @@ handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
 
     GNUNET_CRYPTO_hash (&t->id, sizeof (struct MESH_TunnelID), &hash);
     if (GNUNET_OK !=
-        GNUNET_CONTAINER_multihashmap_put (tunnels, &hash, t,
-                                           GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
+        GNUNET_CONTAINER_multihashmap_put (
+          tunnels, &hash, t,
+          GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
     {
       GNUNET_break (0);
       return GNUNET_OK;
@@ -1372,23 +1738,25 @@ handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
   {
     dest_peer_info = GNUNET_malloc (sizeof (struct MeshPeerInfo));
     dest_peer_info->id = GNUNET_PEER_intern (&pi[size - 1]);
-    dest_peer_info->state = MESH_PEER_WAITING;
-    GNUNET_CONTAINER_multihashmap_put (peers, &pi[size - 1].hashPubKey,
-                                       dest_peer_info,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+    GNUNET_CONTAINER_multihashmap_put (
+      peers,
+      &pi[size - 1].hashPubKey,
+      dest_peer_info,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
   }
   orig_peer_info = GNUNET_CONTAINER_multihashmap_get (peers, &pi->hashPubKey);
   if (NULL == orig_peer_info)
   {
     orig_peer_info = GNUNET_malloc (sizeof (struct MeshPeerInfo));
     orig_peer_info->id = GNUNET_PEER_intern (pi);
-    orig_peer_info->state = MESH_PEER_WAITING;
-    GNUNET_CONTAINER_multihashmap_put (peers, &pi->hashPubKey, orig_peer_info,
-                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
+    GNUNET_CONTAINER_multihashmap_put (
+      peers,
+      &pi->hashPubKey,
+      orig_peer_info,
+      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
   }
 
-
-  path = GNUNET_malloc (sizeof (struct MeshPath));
+  path = GNUNET_malloc (sizeof (struct MeshPeerPath));
   path->length = size;
   path->peers = GNUNET_malloc (size * sizeof (GNUNET_PEER_Id));
   own_pos = 0;
@@ -1402,17 +1770,17 @@ handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
   {                             /* cannot be self, must be 'not found' */
     /* create path: self not found in path through self */
     GNUNET_break_op (0);
-    destroy_path (path);
+    path_destroy (path);
     /* FIXME error. destroy tunnel? leave for timeout? */
     return 0;
   }
   if (own_pos == size - 1)
-  {                             /* it is for us! */
+  {
+    /* It is for us! Send ack. */
     struct MeshDataDescriptor *info;
     unsigned int j;
 
-    add_path_to_origin (orig_peer_info, path);  /* inverts path!  */
-    GNUNET_PEER_resolve (get_first_hop (path), &id);    /* path is inverted :) */
+    path_add_to_origin (orig_peer_info, path);  /* inverts path!  */
     info = GNUNET_malloc (sizeof (struct MeshDataDescriptor));
     info->origin = &t->id;
     info->peer = GNUNET_CONTAINER_multihashmap_get (peers, &id.hashPubKey);
@@ -1428,19 +1796,27 @@ handle_mesh_path_create (void *cls, const struct GNUNET_PeerIdentity *peer,
     info->handler_n = j;
     info->peer->core_transmit[j] =
         GNUNET_CORE_notify_transmit_ready (core_handle, 0, 100,
-                                           GNUNET_TIME_UNIT_FOREVER_REL, &id,
+                                           GNUNET_TIME_UNIT_FOREVER_REL, peer,
                                            sizeof (struct GNUNET_MessageHeader),
                                            &send_core_path_ack, info);
   }
   else
   {
-    add_path_to_peer (dest_peer_info, path);
-    GNUNET_PEER_resolve (get_first_hop (path), &id);
+    /* It's for somebody else! Retransmit. */
+    struct MeshPathInfo *path_info;
+
+    path_info = GNUNET_malloc (sizeof(struct MeshPathInfo));
+    path_info->t = t;
+    path_info->path = path;
+    path_info->peer = dest_peer_info;
+
+    path_add_to_peer (dest_peer_info, path);
+    GNUNET_PEER_resolve (path->peers[own_pos + 1], &id);
     GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
                                        GNUNET_TIME_UNIT_FOREVER_REL, &id,
                                        sizeof (struct GNUNET_MessageHeader),
-                                       &send_core_create_path_for_peer,
-                                       dest_peer_info);
+                                       &send_core_create_path,
+                                       path_info);
   }
   return GNUNET_OK;
 }
@@ -1476,7 +1852,7 @@ handle_mesh_data_unicast (void *cls, const struct GNUNET_PeerIdentity *peer,
     return GNUNET_OK;
   }
   msg = (struct GNUNET_MESH_Unicast *) message;
-  t = retrieve_tunnel (&msg->oid, ntohl (msg->tid));
+  t = tunnel_get (&msg->oid, ntohl (msg->tid));
   if (NULL == t)
   {
     /* TODO notify back: we don't know this tunnel */
@@ -1494,7 +1870,7 @@ handle_mesh_data_unicast (void *cls, const struct GNUNET_PeerIdentity *peer,
     send_subscribed_clients ((struct GNUNET_MessageHeader *) &msg[1]);
     return GNUNET_OK;
   }
-  GNUNET_PEER_resolve (get_first_hop (pi->path), &id);
+  GNUNET_PEER_resolve (path_get_first_hop (t, pi)->id, &id);
   msg = GNUNET_malloc (size);
   memcpy (msg, message, size);
   GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
@@ -1521,9 +1897,9 @@ handle_mesh_data_multicast (void *cls, const struct GNUNET_PeerIdentity *peer,
 {
   struct GNUNET_MESH_Multicast *msg;
   struct GNUNET_PeerIdentity id;
-  struct MeshTunnel *t;
   struct MeshDataDescriptor *info;
-  GNUNET_PEER_Id *neighbors;
+  struct MeshPathInfo neighbors;
+  struct MeshTunnel *t;
   size_t size;
   uint16_t i;
   uint16_t j;
@@ -1538,7 +1914,7 @@ handle_mesh_data_multicast (void *cls, const struct GNUNET_PeerIdentity *peer,
     return GNUNET_OK;
   }
   msg = (struct GNUNET_MESH_Multicast *) message;
-  t = retrieve_tunnel (&msg->oid, ntohl (msg->tid));
+  t = tunnel_get (&msg->oid, ntohl (msg->tid));
 
   if (NULL == t)
   {
@@ -1552,29 +1928,30 @@ handle_mesh_data_multicast (void *cls, const struct GNUNET_PeerIdentity *peer,
     send_subscribed_clients ((struct GNUNET_MessageHeader *) &msg[1]);
   }
 
-  /* Retransmit to other peers */
-  neighbors = GNUNET_malloc (sizeof (GNUNET_PEER_Id));
-  neighbors[0] = 0;
+  /* Retransmit to other peers.
+   * Using path here as just a collection of peers, not a path per se.
+   */
+  neighbors.t = t;
+  neighbors.path = GNUNET_malloc (sizeof(struct MeshPeerPath));
   GNUNET_CONTAINER_multihashmap_iterate (t->peers, &iterate_collect_neighbors,
                                          &neighbors);
-  if (!neighbors[0])
+  if (0 == neighbors.path->length)
   {
+    GNUNET_free(neighbors.path);
     return GNUNET_OK;
   }
   size -= sizeof (struct GNUNET_MESH_Multicast);
   info = GNUNET_malloc (sizeof (struct MeshDataDescriptor) + size);
   info->origin = &t->id;
-  info->copies = 0;
-  for (i = 0; 0 != neighbors[i]; i++)
+  info->copies = neighbors.path->length;
+  for (i = 0; i < info->copies; i++)
   {
-    GNUNET_PEER_resolve (neighbors[i], &id);
-    info->copies++;
-    info->destination = neighbors[i];
+    GNUNET_PEER_resolve (neighbors.path->peers[i], &id);
     info->peer = GNUNET_CONTAINER_multihashmap_get (peers, &id.hashPubKey);
-    GNUNET_assert (info->peer);
-    for (j = 0; info->peer->core_transmit[j]; j++)
+    GNUNET_assert (NULL != info->peer);
+    for (j = 0; 0 != info->peer->core_transmit[j]; j++)
     {
-      if (j == 9)
+      if (j == (CORE_QUEUE_SIZE - 1))
       {
         GNUNET_break (0);
         return GNUNET_OK;
@@ -1588,6 +1965,8 @@ handle_mesh_data_multicast (void *cls, const struct GNUNET_PeerIdentity *peer,
                                            ntohs (msg->header.size),
                                            &send_core_data_multicast, info);
   }
+  GNUNET_free(neighbors.path->peers);
+  GNUNET_free(neighbors.path);
   return GNUNET_OK;
 }
 
@@ -1601,12 +1980,14 @@ handle_mesh_data_multicast (void *cls, const struct GNUNET_PeerIdentity *peer,
  * @param atsi performance data
  * @return GNUNET_OK to keep the connection open,
  *         GNUNET_SYSERR to close it (signal serious error)
+ *
+ * FIXME path
  */
 static int
 handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer,
                           const struct GNUNET_MessageHeader *message,
                           const struct GNUNET_TRANSPORT_ATS_Information *atsi)
-{
+{  
   struct GNUNET_MESH_ToOrigin *msg;
   struct GNUNET_PeerIdentity id;
   struct MeshTunnel *t;
@@ -1622,7 +2003,7 @@ handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer,
     return GNUNET_OK;
   }
   msg = (struct GNUNET_MESH_ToOrigin *) message;
-  t = retrieve_tunnel (&msg->oid, ntohl (msg->tid));
+  t = tunnel_get (&msg->oid, ntohl (msg->tid));
 
   if (NULL == t)
   {
@@ -1642,14 +2023,14 @@ handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer,
                                                 GNUNET_YES);
     return GNUNET_OK;
   }
-  peer_info = get_peer_info (&msg->oid);
+  peer_info = peer_info_get (&msg->oid);
   if (NULL == peer_info)
   {
     /* unknown origin of tunnel */
     GNUNET_break (0);
     return GNUNET_OK;
   }
-  GNUNET_PEER_resolve (get_first_hop (peer_info->path), &id);
+  GNUNET_PEER_resolve (path_get_first_hop (t, peer_info)->id, &id);
   msg = GNUNET_malloc (size);
   memcpy (msg, message, size);
   GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
@@ -1667,8 +2048,11 @@ handle_mesh_data_to_orig (void *cls, const struct GNUNET_PeerIdentity *peer,
  * @param message message
  * @param peer peer identity this notification is about
  * @param atsi performance data
+ *
  * @return GNUNET_OK to keep the connection open,
  *         GNUNET_SYSERR to close it (signal serious error)
+ *
+ * FIXME path change state
  */
 static int
 handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
@@ -1681,7 +2065,7 @@ handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
   struct MeshPeerInfo *peer_info;
 
   msg = (struct GNUNET_MESH_PathACK *) message;
-  t = retrieve_tunnel (&msg->oid, msg->tid);
+  t = tunnel_get (&msg->oid, msg->tid);
   if (NULL == t)
   {
     /* TODO notify that we don't know the tunnel */
@@ -1698,13 +2082,13 @@ handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
       GNUNET_break (0);
       return GNUNET_OK;
     }
-    peer_info = get_peer_info (&msg->peer_id);
+    peer_info = peer_info_get (&msg->peer_id);
     if (NULL == peer_info)
     {
       GNUNET_break_op (0);
       return GNUNET_OK;
     }
-    peer_info->state = MESH_PEER_READY;
+    /* FIXME change state of peer */
     pc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD);
     pc.header.size = htons (sizeof (struct GNUNET_MESH_PeerControl));
     pc.tunnel_id = htonl (t->local_tid);
@@ -1714,14 +2098,14 @@ handle_mesh_path_ack (void *cls, const struct GNUNET_PeerIdentity *peer,
     return GNUNET_OK;
   }
 
-  peer_info = get_peer_info (&msg->oid);
+  peer_info = peer_info_get (&msg->oid);
   if (NULL == peer_info)
   {
     /* If we know the tunnel, we should DEFINITELY know the peer */
     GNUNET_break (0);
     return GNUNET_OK;
   }
-  GNUNET_PEER_resolve (get_first_hop (peer_info->path), &id);
+  GNUNET_PEER_resolve (path_get_first_hop (t, peer_info)->id, &id);
   msg = GNUNET_malloc (sizeof (struct GNUNET_MESH_PathACK));
   memcpy (msg, message, sizeof (struct GNUNET_MESH_PathACK));
   GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
@@ -1764,7 +2148,7 @@ delete_tunnel_entry (void *cls, const GNUNET_HashCode * key, void *value)
 {
   int r;
 
-  r = destroy_tunnel ((struct MeshTunnel *) value);
+  r = tunnel_destroy ((struct MeshTunnel *) value);
   return r;
 }
 
@@ -1824,36 +2208,6 @@ notify_client_connection_failure (void *cls, size_t size, void *buf)
 
 
 /**
- * Send keepalive packets for a peer
- *
- * @param cls unused
- * @param tc unused
- */
-static void
-path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
-{
-  struct MeshPeerInfo *peer_info = cls;
-  struct GNUNET_PeerIdentity id;
-
-  if (tc->reason == GNUNET_SCHEDULER_REASON_SHUTDOWN)
-    return;
-  GNUNET_PEER_resolve (get_first_hop (peer_info->path), &id);
-  GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
-                                     GNUNET_TIME_UNIT_FOREVER_REL, &id,
-                                     sizeof (struct GNUNET_MESH_ManipulatePath)
-                                     +
-                                     (peer_info->path->length *
-                                      sizeof (struct GNUNET_PeerIdentity)),
-                                     &send_core_create_path_for_peer,
-                                     peer_info);
-  peer_info->path_refresh_task =
-      GNUNET_SCHEDULER_add_delayed (REFRESH_PATH_TIME, &path_refresh,
-                                    peer_info);
-  return;
-}
-
-
-/**
  * Function to process paths received for a new peer addition. The recorded
  * paths form the initial tunnel, which can be optimized later.
  * Called on each result obtained for the DHT search.
@@ -1868,6 +2222,8 @@ path_refresh (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
  * @param type type of the result
  * @param size number of bytes in data
  * @param data pointer to the result data
+ *
+ * FIXME path
  */
 static void
 dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
@@ -1876,60 +2232,42 @@ dht_get_id_handler (void *cls, struct GNUNET_TIME_Absolute exp,
                     const struct GNUNET_PeerIdentity *const *put_path,
                     enum GNUNET_BLOCK_Type type, size_t size, const void *data)
 {
-  struct MeshPeerInfo *peer_info = cls;
-  struct MeshPath *p;
+  struct MeshPathInfo *path_info = cls;
+  struct MeshPeerPath *p;
   struct GNUNET_PeerIdentity pi;
   int i;
 
-  if ((NULL == get_path || NULL == put_path) && NULL == peer_info->path)
+  if (NULL == get_path || NULL == put_path)
   {
-    // Find ourselves some alternate initial path to the destination: retry
-    GNUNET_DHT_get_stop (peer_info->dhtget);
-    GNUNET_PEER_resolve (peer_info->id, &pi);
-    peer_info->dhtget = GNUNET_DHT_get_start (dht_handle,       /* handle */
-                                              GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_BLOCK_TYPE_TEST,     /* type */
-                                              &pi.hashPubKey,   /*key to search */
-                                              4,        /* replication level */
-                                              GNUNET_DHT_RO_RECORD_ROUTE, NULL, /* bloom filter */
-                                              0,        /* mutator */
-                                              NULL,     /* xquery */
-                                              0,        /* xquery bits */
-                                              dht_get_id_handler,
-                                              (void *) peer_info);
+    if (NULL == path_info->peer->path_head)
+    {
+      // Find ourselves some alternate initial path to the destination: retry
+      GNUNET_DHT_get_stop (path_info->peer->dhtget);
+      GNUNET_PEER_resolve (path_info->peer->id, &pi);
+      path_info->peer->dhtget = GNUNET_DHT_get_start (
+        dht_handle,       /* handle */
+        GNUNET_TIME_UNIT_FOREVER_REL, /* timeout */
+        GNUNET_BLOCK_TYPE_TEST,     /* type */
+        &pi.hashPubKey,   /*key to search */
+        4,        /* replication level */
+        GNUNET_DHT_RO_RECORD_ROUTE, NULL, /* bloom filter */
+        0,        /* mutator */
+        NULL,     /* xquery */
+        0,        /* xquery bits */
+        dht_get_id_handler,
+        (void *) path_info);
+      return;
+    }
   }
 
-  p = GNUNET_malloc (sizeof (struct MeshPath));
-  for (i = 0; get_path[i] != NULL; i++) ;
-  for (i--; i >= 0; i--)
-  {
-    p->peers =
-        GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * (p->length + 1));
-    p->peers[p->length] = GNUNET_PEER_intern (get_path[i]);
-    p->length++;
-  }
-  for (i = 0; put_path[i] != NULL; i++) ;
-  for (i--; i >= 0; i--)
+  p = path_build_from_dht(get_path, put_path);
+  path_add_to_peer (path_info->peer, p);
+  for (i = 0; i < path_info->peer->ntunnels; i++)
   {
-    p->peers =
-        GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * (p->length + 1));
-    p->peers[p->length] = GNUNET_PEER_intern (put_path[i]);
-    p->length++;
-  }
-  add_path_to_peer (peer_info, p);
-  GNUNET_CORE_notify_transmit_ready (core_handle, 0, 0,
-                                     GNUNET_TIME_UNIT_FOREVER_REL, get_path[1],
-                                     sizeof (struct GNUNET_MESH_ManipulatePath)
-                                     +
-                                     (p->length *
-                                      sizeof (struct GNUNET_PeerIdentity)),
-                                     &send_core_create_path_for_peer,
-                                     peer_info);
-  if (0 == peer_info->path_refresh_task)
-  {
-    peer_info->path_refresh_task =
-        GNUNET_SCHEDULER_add_delayed (REFRESH_PATH_TIME, &path_refresh,
-                                      peer_info);
+    tunnel_add_peer(path_info->peer->tunnels[i], path_info->peer);
   }
+  GNUNET_free(path_info);
+
   return;
 }
 
@@ -1962,7 +2300,7 @@ dht_get_type_handler (void *cls, struct GNUNET_TIME_Absolute exp,
   struct GNUNET_PeerIdentity id;
   struct MeshTunnel *t = cls;
   struct MeshPeerInfo *peer_info;
-  struct MeshPath *p;
+  struct MeshPeerPath *p;
   int i;
 
   if (size != sizeof (struct GNUNET_PeerIdentity))
@@ -1973,12 +2311,12 @@ dht_get_type_handler (void *cls, struct GNUNET_TIME_Absolute exp,
   GNUNET_assert (NULL != t->client);
   GNUNET_DHT_get_stop (t->client->dht_get_type);
   t->client->dht_get_type = NULL;
-  peer_info = get_peer_info (pi);
+  peer_info = peer_info_get (pi);
   GNUNET_CONTAINER_multihashmap_put (t->peers, &pi->hashPubKey, peer_info,
                                      GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
 
   if ((NULL == get_path || NULL == put_path) &&
-    NULL == peer_info->path &&
+    NULL == peer_info->path_head &&
     NULL == peer_info->dhtget)
   {
     /* we don't have a route to the peer, let's try a direct lookup */
@@ -1997,24 +2335,8 @@ dht_get_type_handler (void *cls, struct GNUNET_TIME_Absolute exp,
       peer_info);       /* closure */
   }
 
-  p = GNUNET_malloc (sizeof (struct MeshPath));
-  for (i = 0; get_path[i] != NULL; i++) ;
-  for (i--; i >= 0; i--)
-  {
-    p->peers =
-        GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * (p->length + 1));
-    p->peers[p->length] = GNUNET_PEER_intern (get_path[i]);
-    p->length++;
-  }
-  for (i = 0; put_path[i] != NULL; i++) ;
-  for (i--; i >= 0; i--)
-  {
-    p->peers =
-        GNUNET_realloc (p->peers, sizeof (GNUNET_PEER_Id) * (p->length + 1));
-    p->peers[p->length] = GNUNET_PEER_intern (put_path[i]);
-    p->length++;
-  }
-  add_path_to_peer (peer_info, p);
+  p = path_build_from_dht(get_path, put_path);
+  path_add_to_peer (peer_info, p);
 #if MESH_DEBUG
   GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
              "MESH: new route for tunnel 0x%x found, has %u hops\n",
@@ -2039,7 +2361,7 @@ dht_get_type_handler (void *cls, struct GNUNET_TIME_Absolute exp,
     &id,       /* target */
     sizeof (struct GNUNET_MESH_ManipulatePath) +
     (p->length * sizeof (struct GNUNET_PeerIdentity)),          /*size */
-    &send_core_create_path_for_peer,    /* callback */
+    &send_core_create_path,    /* callback */
     peer_info);        /* cls */
 }
 
@@ -2217,7 +2539,7 @@ handle_local_tunnel_create (void *cls, struct GNUNET_SERVER_Client *client,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: new tunnel requested\n");
 
   /* Sanity check for client registration */
-  if (NULL == (c = retrieve_client (client)))
+  if (NULL == (c = client_get (client)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2241,7 +2563,7 @@ handle_local_tunnel_create (void *cls, struct GNUNET_SERVER_Client *client,
     return;
   }
   /* Sanity check for duplicate tunnel IDs */
-  if (NULL != retrieve_tunnel_by_local_id (c, ntohl (t_msg->tunnel_id)))
+  if (NULL != tunnel_get_by_local_id (c, ntohl (t_msg->tunnel_id)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2249,7 +2571,7 @@ handle_local_tunnel_create (void *cls, struct GNUNET_SERVER_Client *client,
   }
 
   t = GNUNET_malloc (sizeof (struct MeshTunnel));
-  while (NULL != retrieve_tunnel_by_pi (myid, next_tid))
+  while (NULL != tunnel_get_by_pi (myid, next_tid))
     next_tid = (next_tid + 1) & ~GNUNET_MESH_LOCAL_TUNNEL_ID_CLI;
   t->id.tid = next_tid++;
   t->id.oid = myid;
@@ -2302,7 +2624,7 @@ handle_local_tunnel_destroy (void *cls, struct GNUNET_SERVER_Client *client,
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: destroying tunnel\n");
 
   /* Sanity check for client registration */
-  if (NULL == (c = retrieve_client (client)))
+  if (NULL == (c = client_get (client)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2342,6 +2664,8 @@ handle_local_tunnel_destroy (void *cls, struct GNUNET_SERVER_Client *client,
  * @param cls closure
  * @param client identification of the client
  * @param message the actual message (PeerControl)
+ *
+ * FIXME path
  */
 static void
 handle_local_connect_add (void *cls, struct GNUNET_SERVER_Client *client,
@@ -2355,7 +2679,7 @@ handle_local_connect_add (void *cls, struct GNUNET_SERVER_Client *client,
 
 
   /* Sanity check for client registration */
-  if (NULL == (c = retrieve_client (client)))
+  if (NULL == (c = client_get (client)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2373,7 +2697,7 @@ handle_local_connect_add (void *cls, struct GNUNET_SERVER_Client *client,
 
   /* Tunnel exists? */
   tid = ntohl (peer_msg->tunnel_id);
-  t = retrieve_tunnel_by_local_id (c, tid);
+  t = tunnel_get_by_local_id (c, tid);
   if (NULL == t)
   {
     GNUNET_break (0);
@@ -2390,10 +2714,10 @@ handle_local_connect_add (void *cls, struct GNUNET_SERVER_Client *client,
   }
 
   t->peers_total++;
-  peer_info = get_peer_info (&peer_msg->peer);
+  peer_info = peer_info_get (&peer_msg->peer);
 
-  /* Start DHT search if needed */
-  if (MESH_PEER_READY != peer_info->state && NULL == peer_info->dhtget)
+  /* Start DHT search if needed FIXME: if not already connected */
+  if (NULL == peer_info->dhtget)
   {
     peer_info->dhtget = GNUNET_DHT_get_start (dht_handle, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_BLOCK_TYPE_TEST, &peer_msg->peer.hashPubKey, 4,  /* replication level */
                                               GNUNET_DHT_RO_RECORD_ROUTE, NULL, /* bloom filter */
@@ -2426,7 +2750,7 @@ handle_local_connect_del (void *cls, struct GNUNET_SERVER_Client *client,
   MESH_TunnelNumber tid;
 
   /* Sanity check for client registration */
-  if (NULL == (c = retrieve_client (client)))
+  if (NULL == (c = client_get (client)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2443,7 +2767,7 @@ handle_local_connect_del (void *cls, struct GNUNET_SERVER_Client *client,
 
   /* Tunnel exists? */
   tid = ntohl (peer_msg->tunnel_id);
-  t = retrieve_tunnel_by_local_id (c, tid);
+  t = tunnel_get_by_local_id (c, tid);
   if (NULL == t)
   {
     GNUNET_break (0);
@@ -2488,7 +2812,7 @@ handle_local_connect_by_type (void *cls, struct GNUNET_SERVER_Client *client,
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: got connect by type request\n");
   /* Sanity check for client registration */
-  if (NULL == (c = retrieve_client (client)))
+  if (NULL == (c = client_get (client)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2507,7 +2831,7 @@ handle_local_connect_by_type (void *cls, struct GNUNET_SERVER_Client *client,
 
   /* Tunnel exists? */
   tid = ntohl (connect_msg->tunnel_id);
-  t = retrieve_tunnel_by_local_id (c, tid);
+  t = tunnel_get_by_local_id (c, tid);
   if (NULL == t)
   {
     GNUNET_break (0);
@@ -2538,7 +2862,7 @@ handle_local_connect_by_type (void *cls, struct GNUNET_SERVER_Client *client,
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:  available locally\n");
     pc.peer = my_full_id;
     GNUNET_CONTAINER_multihashmap_put (t->peers, &pc.peer.hashPubKey,
-                                       get_peer_info (&pc.peer),
+                                       peer_info_get (&pc.peer),
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY);
     pc.header.size = htons (sizeof (struct GNUNET_MESH_PeerControl));
     pc.header.type = htons (GNUNET_MESSAGE_TYPE_MESH_LOCAL_PEER_ADD);
@@ -2591,7 +2915,7 @@ handle_local_unicast (void *cls, struct GNUNET_SERVER_Client *client,
   size_t data_size;
 
   /* Sanity check for client registration */
-  if (NULL == (c = retrieve_client (client)))
+  if (NULL == (c = client_get (client)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2609,7 +2933,7 @@ handle_local_unicast (void *cls, struct GNUNET_SERVER_Client *client,
 
   /* Tunnel exists? */
   tid = ntohl (data_msg->tid);
-  t = retrieve_tunnel_by_local_id (c, tid);
+  t = tunnel_get_by_local_id (c, tid);
   if (NULL == t)
   {
     GNUNET_break (0);
@@ -2645,7 +2969,7 @@ handle_local_unicast (void *cls, struct GNUNET_SERVER_Client *client,
     handle_mesh_data_unicast (NULL, &my_full_id, &copy.header, NULL);
     return;
   }
-  GNUNET_PEER_resolve (get_first_hop (pi->path), &next_hop);
+  GNUNET_PEER_resolve (path_get_first_hop (t, pi)->id, &next_hop);
   data_size = ntohs (message->size) - sizeof (struct GNUNET_MESH_Unicast);
   info = GNUNET_malloc (sizeof (struct MeshDataDescriptor) + data_size);
   memcpy (&info[1], &data_msg[1], data_size);
@@ -2679,7 +3003,7 @@ handle_local_multicast (void *cls, struct GNUNET_SERVER_Client *client,
   MESH_TunnelNumber tid;
 
   /* Sanity check for client registration */
-  if (NULL == (c = retrieve_client (client)))
+  if (NULL == (c = client_get (client)))
   {
     GNUNET_break (0);
     GNUNET_SERVER_receive_done (client, GNUNET_SYSERR);
@@ -2696,7 +3020,7 @@ handle_local_multicast (void *cls, struct GNUNET_SERVER_Client *client,
 
   /* Tunnel exists? */
   tid = ntohl (data_msg->tid);
-  t = retrieve_tunnel_by_local_id (c, tid);
+  t = tunnel_get_by_local_id (c, tid);
   if (NULL == t)
   {
     GNUNET_break (0);
@@ -2782,20 +3106,20 @@ core_connect (void *cls, const struct GNUNET_PeerIdentity *peer,
 {
 //     GNUNET_PEER_Id              pid;
   struct MeshPeerInfo *peer_info;
-  struct MeshPath *path;
+  struct MeshPeerPath *path;
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH: Peer connected\n");
-  peer_info = get_peer_info (peer);
+  peer_info = peer_info_get (peer);
   if (myid == peer_info->id)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      (self)\n");
   }
-  path = GNUNET_malloc (sizeof (struct MeshPath));
+  path = GNUNET_malloc (sizeof (struct MeshPeerPath));
   path->length = 2;
   path->peers = GNUNET_malloc (sizeof (GNUNET_PEER_Id) * 2);
   path->peers[0] = myid;
   path->peers[1] = peer_info->id;
-  add_path_to_peer (peer_info, path);
+  path_add_to_peer (peer_info, path);
   return;
 }
 
@@ -2827,6 +3151,7 @@ core_disconnect (void *cls, const struct GNUNET_PeerIdentity *peer)
       GNUNET_free (pi->infos[i]);
     }
   }
+  path_remove_from_peer (pi, pi->id, myid);
   if (myid == pi->id)
   {
     GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "MESH:      (self)\n");